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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 2c6696dd3a fix(json): validate JSON files and map SchemaStore schemas for common config files
vscode-json-language-server validates nothing unless `json.validate.enable`
is set, so even a file's own `$schema` was ignored. Turn validation on and
associate package.json, tsconfig/jsconfig, ESLint, Prettier, Babel, Lerna,
Turborepo, SWC and Composer configuration files with their published schemas,
for both JSON and JSON with Comments.
2026-11-21 23:08:11 +08:00
744 змінених файлів з 4903 додано та 28565 видалено

No files matched your search

+1 -3
Переглянути файл
@@ -28,8 +28,6 @@ on:
- "src/workbench/**"
- "src/ui/**"
- "src/editor/api.ts"
- "src/editor/navigationProviders.ts"
- "src/editor/relatedProviders.ts"
- "src/editor/core/cm/cornerInset.ts"
- "src/editor/core/cm/iconArea.ts"
- "src/editor/lsp/availability.ts"
@@ -100,7 +98,7 @@ jobs:
# ide-lsp/dap/run/sdk/tools.
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-spell|ide-ssh|ide-vcs|ide-web)/'
# The workflow's paths, less those handled per language below.
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger|build-tools)/|src/platform/|src/workbench/|src/ui/|src/editor/(api|navigationProviders|relatedProviders|core/cm/(cornerInset|iconArea)|lsp/(availability|diagnostics|files|hint|lsp|positions))\.ts$|src/bindings\.ts$|src/styles/tokens\.css$|src/test/setup\.ts$|src-tauri/icons/128x128\.png$|smoke/|vite\.config\.ts$|tsconfig\.json$|package\.json$|pnpm-(lock|workspace)\.yaml$|patches/|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger|build-tools)/|src/platform/|src/workbench/|src/ui/|src/editor/(api|core/cm/(cornerInset|iconArea)|lsp/(availability|diagnostics|files|hint|lsp|positions))\.ts$|src/bindings\.ts$|src/styles/tokens\.css$|src/test/setup\.ts$|src-tauri/icons/128x128\.png$|smoke/|vite\.config\.ts$|tsconfig\.json$|package\.json$|pnpm-(lock|workspace)\.yaml$|patches/|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
langs=""
while read -r f; do
case "$f" in
-1
Переглянути файл
@@ -79,7 +79,6 @@ Shared agent skills live in `.agents/skills/` (`.claude/skills/` links to them):
`pnpm dev:app` also enables the global Tauri API. `pnpm dev:status` reports
this worktree's running MCP bridges and actual ports.
- `pnpm build` — typecheck + bundle frontend.
- `pnpm dogfood:build` / `pnpm dogfood:install` (or `mise run dogfood:build` / `mise run dogfood:install`) — build and locally install the grey-icon dogfood desktop app sharing release settings and data.
- `cargo nextest run --workspace` (or `cargo test`), `cargo clippy --workspace --all-targets -- -D warnings`, `cargo fmt --all`.
- `cargo test -p ide-host --test language_smoke -- --ignored --exact <language>` — code intelligence
on `fixtures/` with that language's real server installed (CI: `Language smoke`, pinned versions).
Створено
-1
Переглянути файл
@@ -4146,7 +4146,6 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
name = "ide-agent"
version = "0.1.50"
dependencies = [
"base64 0.22.1",
"blake3",
"dunce",
"encoding_rs",
-1
Переглянути файл
@@ -7,7 +7,6 @@ license.workspace = true
[dependencies]
encoding_rs.workspace = true
base64.workspace = true
blake3.workspace = true
ide-vfs.workspace = true
ide-core.workspace = true
+20 -92
Переглянути файл
@@ -23,7 +23,6 @@ mod provider;
pub mod registry;
pub mod security;
mod shell;
pub mod skill_installer;
pub mod skills;
mod timeline;
mod worktree;
@@ -32,10 +31,6 @@ pub use catalogs::AgentCatalogs;
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
pub use external::ExternalSession;
pub use model::*;
pub use skill_installer::{
InstallRemoteSkillRequest, RemoteSkillBrowseResult, RemoteSkillCandidate, RemoteSkillFile, RemoteSkillPreview,
SkillScanWarning, SkillScanWarningKind,
};
use conversation::{Conversation, SavedSubagent, Session};
use ide_core::{IdeError, IdeResult, IpcPath};
@@ -59,10 +54,6 @@ pub type SecurityHook = Arc<dyn Fn() -> ide_core::settings::AgentSecuritySetting
/// Returns the user's choice of the approvals new tasks start with.
pub type NewTaskApprovalsHook = Arc<dyn Fn() -> ide_core::settings::NewTaskApprovals + Send + Sync>;
/// Returns the roots of the project's workspace an agent may work in: the project and the
/// attached projects the user trusts.
pub type WorkspaceRootsHook = Arc<dyn Fn() -> Vec<PathBuf> + Send + Sync>;
/// Entry changes are batched for this long before they are sent.
const FLUSH_DELAY: Duration = Duration::from_millis(40);
/// Updates that arrive this late after `session/load` returns are still replayed history.
@@ -143,27 +134,11 @@ 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)]
#[derive(Clone, Debug, Default)]
pub struct SkillsPolicy {
pub user: BTreeMap<String, AgentSkillPolicy>,
pub workspace: BTreeMap<String, AgentSkillPolicy>,
pub workspace_trusted: bool,
/// All workspace folders (the project root plus any multi-repo workspace members).
pub workspace_roots: Vec<PathBuf>,
/// Validated `<dir>` folders contributed by live OpenIDEA plugins (`[[contributes.skills]]`).
pub plugin_dirs: Vec<PathBuf>,
}
impl Default for SkillsPolicy {
fn default() -> Self {
Self {
user: BTreeMap::new(),
workspace: BTreeMap::new(),
workspace_trusted: true,
workspace_roots: Vec::new(),
plugin_dirs: Vec::new(),
}
}
}
/// Returns the skill policies for this project.
@@ -184,7 +159,6 @@ struct Shared {
sinks: RwLock<HashMap<String, AgentSink>>,
security: RwLock<Option<SecurityHook>>,
new_task_approvals: RwLock<Option<NewTaskApprovalsHook>>,
workspace_roots: RwLock<Option<WorkspaceRootsHook>>,
known: Arc<Mutex<HashMap<String, Known>>>,
providers: RwLock<Vec<provider::ProviderSpec>>,
/// Last probe of each provider.
@@ -212,24 +186,6 @@ struct Known {
}
impl Shared {
/// The workspace roots offered to a session besides its own directory and project, for an
/// agent that takes them (`sessionCapabilities.additionalDirectories`).
fn additional_directories(&self, init: &acp::Negotiated, cwd: &Path, project_root: Option<&Path>) -> Vec<String> {
let Some(hook) = self.workspace_roots.read().clone().filter(|_| init.session("additionalDirectories")) else {
return Vec::new();
};
let canonical = |p: &Path| dunce::canonicalize(p).unwrap_or_else(|_| p.to_path_buf());
let own: Vec<PathBuf> = std::iter::once(cwd).chain(project_root).map(canonical).collect();
let mut roots = Vec::new();
for root in hook().iter().map(|r| canonical(r)) {
let root = root.to_string_lossy().into_owned();
if !own.iter().any(|o| o.to_string_lossy() == root) && !roots.contains(&root) {
roots.push(root);
}
}
roots
}
fn spec(&self, id: &str) -> Option<provider::ProviderSpec> {
self.providers.read().iter().find(|p| p.id == id).cloned()
}
@@ -598,7 +554,6 @@ impl AgentManager {
sinks: RwLock::new(HashMap::new()),
security: RwLock::new(None),
new_task_approvals: RwLock::new(None),
workspace_roots: RwLock::new(None),
known,
providers,
probes: Mutex::new(HashMap::new()),
@@ -666,11 +621,6 @@ impl AgentManager {
*self.shared.new_task_approvals.write() = Some(hook);
}
/// Sets the callback that lists the workspace roots offered to agents besides a task's own.
pub fn set_workspace_roots_hook(&self, hook: WorkspaceRootsHook) {
*self.shared.workspace_roots.write() = Some(hook);
}
/// The agents (custom ones re-read), whether each is installed, and what they offered last time.
pub fn providers(&self) -> Vec<AgentProvider> {
let specs = provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
@@ -805,22 +755,20 @@ impl AgentManager {
}
let home = self.shared.paths.home_dir.clone();
if provider == "hermes" || provider.starts_with("hermes-") {
let hermes_home = home.clone();
let hermes_provider = provider.clone();
let found = blocking(move || {
let profile =
hermes::root(hermes_home.as_deref()).and_then(|root| hermes::profile_home(&root, &hermes_provider));
let profile = hermes::root(home.as_deref()).and_then(|root| hermes::profile_home(&root, &provider));
Ok(profile.map(|p| skills::hermes(&p)).unwrap_or_default())
})
.await?;
offered = skills::merge(offered, found);
} else if provider == "claude" || provider == "claude-acp" {
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);
}
// The hub's active skills complete on every agent; its `off` ones drop out here
// (including entries `offered` already held), which is all the enforcement an ACP agent gets.
// 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,
@@ -830,12 +778,10 @@ impl AgentManager {
let policy = shared.skills_policy_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
(policy, shared.paths.project_root.clone())
};
let roots = if policy.workspace_roots.is_empty() { vec![root] } else { policy.workspace_roots };
let plugin_dirs = policy.plugin_dirs;
let home = self.shared.paths.home_dir.clone();
blocking(move || {
Ok(skills::resolve(
skills::discover_skills_with_plugins(&roots, home.as_deref(), &plugin_dirs),
skills::discover_skills(&root, home.as_deref()),
None,
&policy.workspace,
&policy.user,
@@ -1395,13 +1341,11 @@ impl AgentManager {
if !live.capabilities.fork || (keep < total && !live.capabilities.rollback) {
return Err(IdeError::invalid("this agent can't copy a conversation from there"));
}
let (cwd, provider_id, mcp_overrides, project_root) = {
let (cwd, provider_id, mcp_overrides) = {
let s = source.state.lock();
let t = &s.task;
(t.cwd.0.clone(), t.provider.clone(), t.mcp_overrides.clone(), t.project_root.clone().map(|p| p.0))
(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 roots = source.shared.additional_directories(&live.init, &cwd, project_root.as_deref());
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
@@ -1409,7 +1353,7 @@ impl AgentManager {
.request(
"session/fork",
{
let mut params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref(), &roots);
let mut params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref());
params["sessionId"] = json!(live.session);
params
},
@@ -2139,24 +2083,15 @@ 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, roots) = {
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, task_root) = {
let s = self.state.lock();
(s.task.skill_overrides.clone(), s.task.project_root.as_ref().map(|p| p.0.clone()))
};
let mut roots = Vec::new();
if let Some(tr) = task_root {
roots.push(tr);
}
roots.extend(policy.workspace_roots.iter().cloned());
roots.push(shared.paths.project_root.clone());
(policy, overrides, shared.paths.home_dir.clone(), roots)
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_with_plugins(&roots, home.as_deref(), &policy.plugin_dirs),
skills::discover_skills(&root, home.as_deref()),
Some(&overrides),
&policy.workspace,
&policy.user,
@@ -3058,12 +2993,8 @@ impl Task {
let sign_in_message = spec.sign_in_message(&init.auth_methods);
let can_load = init.load_session();
let (capabilities, embedded) = capabilities_of(&init);
let (mcp_overrides, project_root) = {
let s = self.state.lock();
(s.task.mcp_overrides.clone(), s.task.project_root.clone().map(|p| p.0))
};
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 roots = self.shared.additional_directories(&init, cwd, project_root.as_deref());
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();
@@ -3079,7 +3010,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(), &roots);
let mut params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref());
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;
@@ -3119,7 +3050,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(), &roots);
let params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref());
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 },
@@ -4109,12 +4040,9 @@ fn stage_key(driver: provider::Driver) -> &'static str {
/// 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, and the workspace's other roots.
fn session_params(cwd: &str, mcp: &McpForSession, skills: Option<&skills::Delivery>, roots: &[String]) -> Value {
/// session's staged skills for the drivers that take them.
fn session_params(cwd: &str, mcp: &McpForSession, skills: Option<&skills::Delivery>) -> Value {
let mut params = json!({ "cwd": cwd, "mcpServers": mcp.servers });
if !roots.is_empty() {
params["additionalDirectories"] = json!(roots);
}
let mut meta = json!({});
if !mcp.off.is_empty() {
meta["mcpServersOff"] = json!(mcp.off);
+1 -15
Переглянути файл
@@ -898,8 +898,6 @@ pub enum AgentSkillSource {
Workspace,
/// The user's `~/.agents/skills` (what `npx skills add` fills).
User,
/// Contributed by an enabled OpenIDEA plugin (`[[contributes.skills]]`).
Plugin,
/// The project's `.claude/skills`.
ClaudeWorkspace,
/// `~/.claude/skills`.
@@ -922,7 +920,7 @@ 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 | Self::Plugin)
!matches!(self, Self::Workspace | Self::User)
}
}
@@ -933,21 +931,9 @@ pub struct AgentSkill {
/// The frontmatter `name`, else the folder's name.
pub name: String,
pub description: String,
/// Optional `argument-hint` from frontmatter, completed in the `/` menu.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hint: Option<String>,
/// Canonical folder holding `SKILL.md` (symlinks resolved, so duplicates collapse).
pub path: IpcPath,
pub source: AgentSkillSource,
/// Other skill roots whose symlinked entry resolved to this same canonical `path`.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub also_in: Vec<AgentSkillSource>,
/// False when frontmatter sets `user-invocable: false` (omitted from `/` completion).
#[serde(default = "default_true")]
pub user_invocable: bool,
/// True when frontmatter sets `disable-model-invocation: true` (defaults to `slashOnly`).
#[serde(default)]
pub disable_model_invocation: bool,
/// The `SKILL.md` passes validation (`name` matches its folder, `description` present).
pub valid: bool,
/// What validation found (`name` mismatch, missing or over-long description…).
+1 -13
Переглянути файл
@@ -174,8 +174,6 @@ struct Session {
mcp_off: Vec<String>,
/// The staged skills folder passed as `--add-dir` (its `.claude/skills` holds the copies).
skills_add_dir: Option<PathBuf>,
/// The workspace's other roots, each passed as `--add-dir`.
additional_dirs: Vec<String>,
/// The staged skills' `--settings` JSON (`skillOverrides` for the native ones too).
skills_settings: Option<String>,
shim: Weak<Shim>,
@@ -368,7 +366,6 @@ impl Shim {
mcp_config,
mcp_off,
skills_add_dir: skills.and_then(|s| s.get("claudeAddDir")).and_then(Value::as_str).map(PathBuf::from),
additional_dirs: additional_dirs(params),
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 {
@@ -415,7 +412,7 @@ impl Shim {
"agentCapabilities": {
"loadSession": true,
"promptCapabilities": { "image": true, "embeddedContext": true },
"sessionCapabilities": { "fork": {}, "additionalDirectories": {} },
"sessionCapabilities": { "fork": {} },
"mcpCapabilities": { "stdio": true, "http": true, "sse": true },
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true, "contextUsage": true } },
},
@@ -688,9 +685,6 @@ impl Session {
if let Some(dir) = &self.skills_add_dir {
args.extend(["--add-dir".to_owned(), dir.to_string_lossy().into_owned()]);
}
for dir in &self.additional_dirs {
args.extend(["--add-dir".to_owned(), dir.clone()]);
}
if let Some(settings) = &self.skills_settings {
args.extend(["--settings".to_owned(), settings.clone()]);
}
@@ -1528,12 +1522,6 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
/// Claude Code's own configuration stays off too.
/// The session's `additionalDirectories`: the workspace's other roots.
fn additional_dirs(params: &Value) -> Vec<String> {
let dirs = params.get("additionalDirectories").and_then(Value::as_array);
dirs.into_iter().flatten().filter_map(Value::as_str).map(str::to_owned).collect()
}
fn mcp_off(params: &Value) -> Vec<String> {
params
.pointer("/_meta/openidea/mcpServersOff")
-7
Переглянути файл
@@ -1275,10 +1275,3 @@ fn mcp_servers_become_an_mcp_config() {
drop(path);
assert!(!kept.exists());
}
#[test]
fn additional_directories_are_read_from_the_session_params() {
let params = json!({ "cwd": "/w/api", "additionalDirectories": ["/w/web", 3, "/w/docs"] });
assert_eq!(additional_dirs(&params), ["/w/web", "/w/docs"]);
assert!(additional_dirs(&json!({ "cwd": "/w/api" })).is_empty());
}
+1 -8
Переглянути файл
@@ -357,13 +357,6 @@ fn apply_thread_config(params: &Value, request: &mut Value) {
if !config.as_object().is_some_and(|m| m.is_empty()) {
request["config"] = config;
}
// The workspace's other roots join the thread's own: they are where `workspace-write`
// may write and what the model is told the workspace holds.
if let Some(extra) = params.get("additionalDirectories").and_then(Value::as_array).filter(|a| !a.is_empty())
&& let Some(cwd) = params.get("cwd").filter(|c| c.is_string())
{
request["runtimeWorkspaceRoots"] = std::iter::once(cwd).chain(extra).cloned().collect();
}
}
impl CodexShim {
@@ -413,7 +406,7 @@ impl CodexShim {
"loadSession": true,
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
"mcpCapabilities": { "http": false, "sse": false, "stdio": true },
"sessionCapabilities": { "fork": {}, "close": {}, "additionalDirectories": {} },
"sessionCapabilities": { "fork": {}, "close": {} },
"_meta": { "openidea": { "rollback": true, "steer": true } },
},
"agentInfo": { "name": "codex", "title": "Codex", "version": version },
-11
Переглянути файл
@@ -1847,14 +1847,3 @@ fn skills_become_commands_with_their_invocation_names() {
assert!(skill_commands(&json!({"data": []})).unwrap()["availableCommands"].as_array().unwrap().is_empty());
assert!(skill_commands(&json!({})).is_none());
}
#[test]
fn workspace_roots_join_the_thread_roots() {
let params = json!({ "cwd": "/w/api", "mcpServers": [], "additionalDirectories": ["/w/web"] });
let mut request = json!({});
apply_thread_config(&params, &mut request);
assert_eq!(request["runtimeWorkspaceRoots"], json!(["/w/api", "/w/web"]));
let mut request = json!({});
apply_thread_config(&json!({ "cwd": "/w/api", "mcpServers": [] }), &mut request);
assert!(request.get("runtimeWorkspaceRoots").is_none());
}
File diff suppressed because it is too large. Load diff
+107 -612
Переглянути файл
@@ -240,301 +240,86 @@ const HOME_ROOTS: &[(&str, AgentSkillSource)] = &[
/// 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> {
discover_skills_in(&[workspace.to_path_buf()], home)
}
/// Every skill found across `workspaces` (a project and any workspace/monorepo member
/// folders) and `home`, in source precedence order, symlinked duplicates collapsed by
/// canonical path while recording secondary sources in [`AgentSkill::also_in`].
pub fn discover_skills_in(workspaces: &[PathBuf], home: Option<&Path>) -> Vec<AgentSkill> {
discover_skills_with_plugins(workspaces, home, &[])
}
/// [`discover_skills_in`] plus the `<dir>` skill folders contributed by enabled OpenIDEA
/// plugins (`[[contributes.skills]]`). Workspace and user skills take precedence on a name
/// clash; a plugin skill is never silently renamed.
pub fn discover_skills_with_plugins(
workspaces: &[PathBuf],
home: Option<&Path>,
plugin_skill_dirs: &[PathBuf],
) -> 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();
let mut seen_workspaces: HashSet<PathBuf> = HashSet::new();
let mut all_workspaces: Vec<PathBuf> = Vec::new();
for ws in workspaces {
let canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.clone());
if seen_workspaces.insert(canon) {
all_workspaces.push(ws.clone());
}
}
for ws in &all_workspaces {
roots.extend(WORKSPACE_ROOTS.iter().map(|(rel, source)| (ws.join(rel), *source)));
}
// Nested monorepo packages (up to two levels below each workspace root, e.g. `apps/web`).
for ws in &all_workspaces {
for sub in monorepo_subdirs(ws, 2) {
let sub_canon = dunce::canonicalize(&sub).unwrap_or_else(|_| sub.clone());
if seen_workspaces.insert(sub_canon) {
roots.extend(WORKSPACE_ROOTS.iter().map(|(rel, source)| (sub.join(rel), *source)));
}
}
}
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)));
}
let mut push_skill = |skill: AgentSkill| {
let path = dunce::canonicalize(&skill.path.0).unwrap_or_else(|_| skill.path.0.clone());
if !seen_paths.insert(path.clone()) {
if let Some(existing) = out.iter_mut().find(|s| s.path.0 == path)
&& existing.source != skill.source
&& !existing.also_in.contains(&skill.source)
{
existing.also_in.push(skill.source);
}
return;
}
if !seen_names.insert(skill.name.to_ascii_lowercase()) {
return;
}
out.push(AgentSkill { path: path.into(), ..skill });
};
for (root, source) in roots {
for skill in skills_of(&root, source) {
push_skill(skill);
}
}
for dir in plugin_skill_dirs {
let Some(folder) = file_name(dir) else { continue };
if !dir.is_dir() {
continue;
}
let Ok(text) = std::fs::read_to_string(dir.join("SKILL.md")) else { continue };
push_skill(parse_skill_file(dir, &folder, &text, AgentSkillSource::Plugin));
}
if let Some(home) = home {
for (root, source) in copilot_installed_plugin_roots(&home.join(".copilot")) {
for skill in skills_of(&root, source) {
push_skill(skill);
}
}
}
out
}
/// Validates a plugin-contributed `<folder>/SKILL.md` against the hub's folder-name and
/// frontmatter rules (`name` 1–64 `[a-z0-9-]`, matching `folder`, non-empty `description` ≤ 1024 chars).
pub fn validate_plugin_skill(dir: &Path, folder: &str, text: &str) -> Result<AgentSkill, String> {
if !valid_name(folder) {
return Err(format!("skill folder `{folder}` must be 1-64 lowercase letters, digits or hyphens"));
}
let skill = parse_skill_file(dir, folder, text, AgentSkillSource::Plugin);
if !skill.valid {
return Err(skill.warnings.join("; "));
}
Ok(skill)
}
const SKIP_MONOREPO_DIRS: &[&str] =
&["node_modules", "target", "dist", "build", "out", "vendor", "coverage", ".git", ".openidea", ".idea"];
fn monorepo_subdirs(root: &Path, max_depth: usize) -> Vec<PathBuf> {
if max_depth == 0 {
return Vec::new();
}
let mut out = Vec::new();
for dir in sorted(root) {
let Some(name) = file_name(&dir) else { continue };
if SKIP_MONOREPO_DIRS.contains(&name.as_str()) {
continue;
}
let Ok(meta) = std::fs::symlink_metadata(&dir) else { continue };
if !meta.file_type().is_dir() {
continue;
}
if WORKSPACE_ROOTS.iter().any(|(rel, _)| dir.join(rel).is_dir()) {
out.push(dir.clone());
}
if max_depth > 1 {
out.extend(monorepo_subdirs(&dir, max_depth - 1));
}
}
out
}
/// Discovers skill roots inside `~/.copilot/installed-plugins`, supporting both Copilot CLI's
/// 2-level `<marketplace-or-_direct>/<plugin>` layout (and `config.json` `installedPlugins`
/// enablement) and flat 1-level `<plugin>` folders.
fn copilot_installed_plugin_roots(copilot_dir: &Path) -> Vec<(PathBuf, AgentSkillSource)> {
let mut disabled_paths: HashSet<PathBuf> = HashSet::new();
let mut plugin_dirs: Vec<PathBuf> = Vec::new();
let mut seen_dirs: HashSet<PathBuf> = HashSet::new();
let mut push_plugin = |dir: PathBuf, disabled: &HashSet<PathBuf>| {
if !dir.is_dir() {
return;
}
let canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
if disabled.contains(&canon) || !seen_dirs.insert(canon) {
return;
}
plugin_dirs.push(dir);
};
if let Ok(text) = std::fs::read_to_string(copilot_dir.join("config.json"))
&& let Ok(root) = serde_json::from_str::<serde_json::Value>(&crate::mcp::strip_jsonc(&text))
&& let Some(installed) = root.get("installedPlugins").and_then(serde_json::Value::as_array)
{
for entry in installed {
let Some(raw_cache) = entry.get("cache_path").and_then(serde_json::Value::as_str).map(str::trim) else {
continue;
};
if raw_cache.is_empty() {
continue;
}
let dir =
if Path::new(raw_cache).is_relative() { copilot_dir.join(raw_cache) } else { PathBuf::from(raw_cache) };
if entry.get("enabled").and_then(serde_json::Value::as_bool) == Some(false) {
disabled_paths.insert(dunce::canonicalize(&dir).unwrap_or(dir));
} else {
push_plugin(dir, &disabled_paths);
}
}
}
let plugins_root = copilot_dir.join("installed-plugins");
for entry in sorted(&plugins_root) {
if !entry.is_dir() {
continue;
}
if looks_like_plugin_dir(&entry) {
push_plugin(entry, &disabled_paths);
} else {
// 2-level `<marketplace>/<plugin>` or `_direct/<plugin>`.
for sub in sorted(&entry) {
if sub.is_dir() {
push_plugin(sub, &disabled_paths);
// `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));
}
}
}
}
let mut roots = Vec::new();
for plugin in plugin_dirs {
let skills_sub = plugin.join("skills");
if skills_sub.is_dir() {
roots.push((skills_sub, AgentSkillSource::CopilotUser));
} else {
roots.push((plugin, AgentSkillSource::CopilotUser));
}
}
roots
}
fn looks_like_plugin_dir(dir: &Path) -> bool {
dir.join("skills").is_dir()
|| dir.join("plugin.json").is_file()
|| dir.join(".plugin").is_dir()
|| dir.join(".claude-plugin").is_dir()
|| dir.join(".cursor-plugin").is_dir()
|| dir.join("SKILL.md").is_file()
}
/// The skills of one root: `<name>/SKILL.md` folders and `<category>/<name>/SKILL.md`
/// category folders, validated.
fn skills_of(root: &Path, source: AgentSkillSource) -> Vec<AgentSkill> {
let mut out: Vec<AgentSkill> = Vec::new();
// Warn when a user drops `SKILL.md` directly inside a `skills/` root instead of `<name>/SKILL.md`.
if file_name(root).as_deref() == Some("skills")
&& let Ok(text) = std::fs::read_to_string(root.join("SKILL.md"))
{
let mut misplaced = parse_skill_file(root, "skills", &text, source);
misplaced.valid = false;
misplaced
.warnings
.insert(0, "SKILL.md is directly inside `skills/`: move it into a `<name>/SKILL.md` subfolder".into());
out.push(misplaced);
}
for dir in sorted(root) {
let Some(folder) = file_name(&dir) else { continue };
if !dir.is_dir() {
continue;
}
if let Ok(text) = std::fs::read_to_string(dir.join("SKILL.md")) {
out.push(parse_skill_file(&dir, &folder, &text, source));
continue;
}
// Category folder (`<root>/<category>/<skill>/SKILL.md`): only entered when `<dir>` itself
// has no `SKILL.md`, so a skill's own subdirectories remain resources rather than skills.
for sub in sorted(&dir) {
let Some(sub_folder) = file_name(&sub) else { continue };
if !sub.is_dir() {
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;
}
if let Ok(text) = std::fs::read_to_string(sub.join("SKILL.md")) {
out.push(parse_skill_file(&sub, &sub_folder, &text, source));
}
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
}
fn parse_skill_file(dir: &Path, folder: &str, text: &str, source: AgentSkillSource) -> AgentSkill {
let meta = Frontmatter::parse(text);
let name = meta
.get("name")
.map(|n| strip_ansi(n).trim().to_owned())
.filter(|n| !n.is_empty())
.unwrap_or_else(|| folder.to_owned());
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"));
}
let hint = meta.get("argument-hint").map(|h| strip_ansi(h).trim().to_owned()).filter(|h| !h.is_empty());
let user_invocable = !meta.get("user-invocable").is_some_and(|v| v.eq_ignore_ascii_case("false"));
let disable_model_invocation = meta.get("disable-model-invocation").is_some_and(|v| v.eq_ignore_ascii_case("true"));
AgentSkill {
name,
description: truncate(&description),
hint,
path: dir.to_path_buf().into(),
source,
also_in: Vec::new(),
user_invocable,
disable_model_invocation,
valid: warnings.is_empty(),
warnings,
}
}
/// A skill's mode, as one policy layer of the settings has it.
type Policies = BTreeMap<String, AgentSkillPolicy>;
fn lookup_mode(map: &BTreeMap<String, AgentSkillMode>, name: &str) -> Option<AgentSkillMode> {
map.get(name).copied().or_else(|| map.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| *v))
}
fn lookup_policy<'a>(map: &'a Policies, name: &str) -> Option<&'a AgentSkillPolicy> {
map.get(name).or_else(|| map.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v))
}
/// Resolves every skill's mode: a session override, then the workspace's and the user's
/// `[agents.skills.<name>]` policy, then the frontmatter default (`slashOnly` when
/// `disable-model-invocation: true`, else `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.
/// `[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>>,
@@ -552,21 +337,19 @@ pub fn resolve(
| AgentSkillSource::CodexWorkspace
| AgentSkillSource::CursorWorkspace
);
let default_mode =
if skill.disable_model_invocation { AgentSkillMode::SlashOnly } else { AgentSkillMode::Auto };
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| lookup_mode(s, &skill.name)) {
(chosen, AgentSkillOrigin::Session)
} else if let Some(chosen) = session.and_then(|s| s.get(&skill.name)) {
(*chosen, AgentSkillOrigin::Session)
} else if let Some(policy) =
lookup_policy(workspace, &skill.name).filter(|p| workspace_trusted || p.mode == AgentSkillMode::Off)
workspace.get(&skill.name).filter(|p| workspace_trusted || p.mode == AgentSkillMode::Off)
{
(policy.mode, AgentSkillOrigin::Workspace)
} else if let Some(policy) = lookup_policy(user, &skill.name) {
} else if let Some(policy) = user.get(&skill.name) {
(policy.mode, AgentSkillOrigin::User)
} else {
(default_mode, AgentSkillOrigin::None)
(AgentSkillMode::Auto, AgentSkillOrigin::None)
};
out.push(AgentSkillState { skill, mode, origin });
}
@@ -633,24 +416,16 @@ pub fn stage(
for state in states {
let name = state.skill.name.as_str();
let path = state.skill.path.0.as_path();
if file_name(path).as_deref() == Some("skills") && !state.skill.valid {
continue;
}
match state.mode {
AgentSkillMode::Off => {
out.codex_off.push((name.to_owned(), codex_skill_md_path(path)));
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 slash-only toggle and disable model auto-loading.
// Copilot and Codex have no such mode and get it disabled or left out.
AgentSkillMode::SlashOnly => {
if state.skill.user_invocable
&& let Some(tree) = claude_tree.as_ref().filter(|_| !native_claude(&state.skill, &cwd, home))
{
if let Some(tree) = claude_tree.as_ref().filter(|_| !native_claude(&state.skill, &cwd, home)) {
link_skill(&tree.join(name), path)?;
}
if native_codex(&state.skill, &cwd, home) {
out.codex_off.push((name.to_owned(), codex_skill_md_path(path)));
}
}
AgentSkillMode::Auto => {
if let Some(tree) = claude_tree.as_ref().filter(|_| !native_claude(&state.skill, &cwd, home)) {
@@ -676,16 +451,10 @@ pub fn stage(
}
// 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 || (s.mode == AgentSkillMode::SlashOnly && !s.skill.user_invocable))
.map(|s| s.skill.name.as_str())
.collect();
let slash: Vec<&str> = states
.iter()
.filter(|s| s.mode == AgentSkillMode::SlashOnly && s.skill.user_invocable)
.map(|s| s.skill.name.as_str())
.collect();
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"))) {
@@ -700,94 +469,32 @@ pub fn stage(
Ok(out)
}
/// Codex `[[skills.config]]` matches `path` against the canonical `SKILL.md` document path.
fn codex_skill_md_path(skill_dir: &Path) -> String {
let md = skill_dir.join("SKILL.md");
let md = dunce::canonicalize(&md)
.or_else(|_| dunce::canonicalize(skill_dir).map(|dir| dir.join("SKILL.md")))
.unwrap_or(md);
// Skill roots are joined as `.agents/skills`; rebuilding from components gives Windows
// one separator when the path could not be canonicalized.
md.components().collect::<PathBuf>().to_string_lossy().into_owned()
}
fn direct_link_matches(root: &Path, name: &str, target: &Path) -> bool {
let candidate = root.join(name);
candidate == target || dunce::canonicalize(&candidate).ok().as_deref() == Some(target)
}
/// Claude Code sees this skill without the farm when `<dir>/.claude/skills/<name>` in `cwd`
/// (or `~/.claude/skills/<name>`) already resolves to `skill.path` — including when `.claude/skills/<name>`
/// is a symlink to `.agents/skills/<name>`. Category-nested skills are not direct children, so
/// they still get staged flat into the farm.
/// 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 {
let target = skill.path.0.as_path();
let home_canon = home.map(|h| dunce::canonicalize(h).unwrap_or_else(|_| h.to_path_buf()));
for ancestor in cwd.ancestors() {
if home_canon.as_deref().is_some_and(|h| h == ancestor) {
break;
}
if direct_link_matches(&ancestor.join(".claude/skills"), &skill.name, target) {
return true;
}
}
if let Some(h) = home_canon.as_deref()
&& direct_link_matches(&h.join(".claude/skills"), &skill.name, target)
{
return true;
}
match skill.source {
AgentSkillSource::ClaudeWorkspace => target.parent() == Some(cwd.join(".claude/skills").as_path()),
AgentSkillSource::ClaudeUser => {
home_canon.as_deref().is_some_and(|h| target.parent() == Some(h.join(".claude/skills").as_path()))
}
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 natively scans `.github/skills`, `.agents/skills` and `.claude/skills` in `cwd`,
/// plus `~/.copilot` and `~/.agents/skills` in `home`. `.openidea/skills` is NOT native.
/// Copilot reads the repository's `.github/skills` and the home's `.copilot` itself.
fn native_copilot(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
let target = skill.path.0.as_path();
for rel in [".github/skills", ".agents/skills", ".claude/skills"] {
let root = cwd.join(rel);
if is_under(target, &root) || direct_link_matches(&root, &skill.name, target) {
return true;
}
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,
}
if let Some(h) = home {
let h = dunce::canonicalize(h).unwrap_or_else(|_| h.to_path_buf());
if is_under(target, &h.join(".copilot"))
|| is_under(target, &h.join(".agents/skills"))
|| direct_link_matches(&h.join(".copilot/skills"), &skill.name, target)
|| direct_link_matches(&h.join(".agents/skills"), &skill.name, target)
{
return true;
}
}
false
}
/// Codex natively scans `.codex/skills` and `.agents/skills` in `cwd` and `home`.
/// Codex reads its own folders itself.
fn native_codex(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
let target = skill.path.0.as_path();
for rel in [".codex/skills", ".agents/skills"] {
let root = cwd.join(rel);
if is_under(target, &root) || direct_link_matches(&root, &skill.name, target) {
return true;
}
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,
}
if let Some(h) = home {
let h = dunce::canonicalize(h).unwrap_or_else(|_| h.to_path_buf());
if is_under(target, &h.join(".codex/skills"))
|| is_under(target, &h.join(".agents/skills"))
|| direct_link_matches(&h.join(".codex/skills"), &skill.name, target)
|| direct_link_matches(&h.join(".agents/skills"), &skill.name, target)
{
return true;
}
}
false
}
fn is_under(path: &Path, root: &Path) -> bool {
@@ -846,48 +553,21 @@ fn sanitized(id: &str) -> String {
id.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '-').collect()
}
fn bare_skill_name(name: &str) -> String {
name.trim_start_matches('$').to_ascii_lowercase()
}
/// The `/` menu's skills: active user-invocable skills as commands (the agent's own listing
/// wins on a name clash, including Codex's `$name` spelling). `Off` and `user-invocable: false`
/// skills are actively stripped from `offered` too, so previously cached or CLI-advertised
/// entries cannot leak back into OpenIDEA's `/` completion.
/// 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 blocked: HashSet<String> = states
let extra = states
.iter()
.filter(|s| s.mode == AgentSkillMode::Off || !s.skill.user_invocable)
.map(|s| bare_skill_name(&s.skill.name))
.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();
let mut out: Vec<AgentCommand> =
offered.into_iter().filter(|c| !blocked.contains(&bare_skill_name(&c.name))).collect();
for state in states {
if state.mode == AgentSkillMode::Off
|| !state.skill.user_invocable
|| (file_name(&state.skill.path.0).as_deref() == Some("skills") && !state.skill.valid)
{
continue;
}
let target = bare_skill_name(&state.skill.name);
if let Some(existing) = out.iter_mut().find(|c| bare_skill_name(&c.name) == target) {
existing.source = AgentCommandSource::Skill;
if existing.hint.is_none() {
existing.hint = state.skill.hint.clone();
}
if existing.description.is_empty() {
existing.description = state.skill.description.clone();
}
} else {
out.push(AgentCommand {
name: state.skill.name.clone(),
description: state.skill.description.clone(),
hint: state.skill.hint.clone(),
source: AgentCommandSource::Skill,
});
}
}
out
merge(offered, extra)
}
#[cfg(test)]
@@ -1028,12 +708,8 @@ mod tests {
AgentSkill {
name: name.into(),
description: format!("{name} does things"),
hint: None,
path: root.join(name).into(),
source,
also_in: Vec::new(),
user_invocable: true,
disable_model_invocation: false,
valid: true,
warnings: Vec::new(),
}
@@ -1181,16 +857,7 @@ mod tests {
true,
);
//For a local session, `.github/skills`, `.agents/skills` and `~/.agents/skills` are
// already scanned natively by Copilot; `.openidea/skills` and `~/.codex/skills` are staged.
let mut states = states;
std::fs::create_dir_all(repo.join(".openidea/skills/ideonly")).unwrap();
states.push(AgentSkillState {
skill: skill("ideonly", AgentSkillSource::Workspace, &repo.join(".openidea/skills")),
mode: AgentSkillMode::Auto,
origin: AgentSkillOrigin::None,
});
// 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()));
@@ -1198,7 +865,7 @@ mod tests {
let staged = listed(&claude_tree);
assert_eq!(
staged,
["codexy", "gh", "ideonly", "lint", "muted", "tdd"],
["codexy", "gh", "lint", "muted", "tdd"],
"everything but the off one: none is native to Claude here, and slash-only needs the folder"
);
@@ -1206,31 +873,18 @@ mod tests {
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", "ideonly"],
"`gh` (.github), `tdd` (.agents) and `lint` (~/.agents) are native to Copilot; `.openidea` & `~/.codex` are staged"
);
assert_eq!(copilot_staged, ["codexy", "lint", "tdd"], "`gh` is native to a local Copilot session");
assert_eq!(
delivery.codex_off,
[
(
"muted".to_owned(),
home.join(".agents").join("skills").join("muted").join("SKILL.md").to_string_lossy().into_owned(),
),
(
"off".to_owned(),
repo.join(".agents").join("skills").join("off").join("SKILL.md").to_string_lossy().into_owned(),
),
]
[("off".to_owned(), repo.join(".agents/skills").join("off").to_string_lossy().into_owned())]
);
// A worktree task: the repo's skills are untracked, so workspace skills are staged now.
// 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()) && copilot_staged.contains(&"tdd".to_string()));
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();
@@ -1248,7 +902,7 @@ mod tests {
true,
);
stage(&farm, "claude", &restated, &repo, Some(&home)).unwrap();
assert_eq!(listed(&claude_tree), ["codexy", "gh", "ideonly", "muted", "tdd"]);
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");
@@ -1264,175 +918,16 @@ mod tests {
#[test]
fn hub_menu_filters_off_and_keeps_the_agents_own() {
let root = PathBuf::from("/r");
let mut hidden = skill("bg-only", AgentSkillSource::Workspace, &root);
hidden.user_invocable = false;
let mut with_hint = skill("verify", AgentSkillSource::Workspace, &root);
with_hint.hint = Some("[flow]".into());
with_hint.path = tempfile::tempdir().unwrap().path().to_path_buf().into();
write(&with_hint.path.0.join("SKILL.md"), "---\nname: verify\ndescription: v\n---\n");
let states = resolve(
vec![
skill("tdd", AgentSkillSource::Workspace, &root),
skill("lint", AgentSkillSource::User, &root),
hidden,
with_hint,
],
vec![skill("tdd", AgentSkillSource::Workspace, &root), skill("lint", AgentSkillSource::User, &root)],
Some(&BTreeMap::from([("lint".to_owned(), AgentSkillMode::Off)])),
&BTreeMap::new(),
&BTreeMap::new(),
true,
);
// Even when the agent itself (or cached `known_commands` / Codex `$lint`) already offered
// `lint` or `bg-only`, `menu_commands` strips them, and merges `$tdd` without duplicating `tdd`.
let offered = vec![
cmd("$tdd", "from codex itself"),
AgentCommand { source: AgentCommandSource::Skill, ..cmd("lint", "offered before turning off") },
cmd("$lint", "codex offered before turning off"),
AgentCommand { source: AgentCommandSource::Skill, ..cmd("bg-only", "model only") },
cmd("compact", "Compact context"),
];
let menu = menu_commands(offered, &states);
assert_eq!(names(&menu), ["$tdd", "compact", "verify"]);
assert_eq!(menu[0].description, "from codex itself");
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);
assert_eq!(menu[2].hint.as_deref(), Some("[flow]"));
}
#[test]
fn hub_discovers_copilot_two_level_plugins_categories_monorepos_and_frontmatter_flags() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap();
let home = root.join("home");
let ws_a = root.join("ws-a");
let ws_b = root.join("ws-b");
// Category subfolder in `.agents/skills/testing/coverage/SKILL.md`.
write(
&ws_a.join(".agents/skills/testing/coverage/SKILL.md"),
"---\nname: coverage\ndescription: Coverage workflow\nargument-hint: \"[pkg]\"\ndisable-model-invocation: true\n---\n",
);
// Nested monorepo subpackage `apps/web/.agents/skills/web-e2e/SKILL.md`.
write(
&ws_a.join("apps/web/.agents/skills/web-e2e/SKILL.md"),
"---\nname: web-e2e\ndescription: Web e2e\n---\n",
);
// Second workspace member root `ws-b`.
write(&ws_b.join(".agents/skills/deploy/SKILL.md"), "---\nname: deploy\ndescription: Deploy\n---\n");
// Misplaced top-level `SKILL.md` directly inside `.claude/skills/SKILL.md`.
write(&ws_a.join(".claude/skills/SKILL.md"), "---\nname: misplaced\ndescription: Wrong level\n---\n");
// Copilot 2-level marketplace & `_direct` plugins + disabled plugin in `config.json`.
write(
&home.join(".copilot/installed-plugins/awesome-copilot/db-tools/skills/pg-tune/SKILL.md"),
"---\nname: pg-tune\ndescription: Tune Postgres\n---\n",
);
write(
&home.join(".copilot/installed-plugins/_direct/muted-plug/skills/secret-op/SKILL.md"),
"---\nname: secret-op\ndescription: Disabled plugin skill\n---\n",
);
write(
&home.join(".copilot/config.json"),
"// Managed by Copilot CLI\n{\"installedPlugins\":[{\"name\":\"muted-plug\",\"enabled\":false,\"cache_path\":\"installed-plugins/_direct/muted-plug\"}]}\n",
);
#[cfg(unix)]
{
std::fs::create_dir_all(ws_a.join(".claude/skills")).unwrap();
std::os::unix::fs::symlink(
ws_a.join(".agents/skills/testing/coverage"),
ws_a.join(".claude/skills/coverage"),
)
.unwrap();
}
let found = discover_skills_in(&[ws_a.clone(), ws_b], Some(&home));
let by = |n: &str| found.iter().find(|s| s.name == n);
let cov = by("coverage").expect("category skill discovered");
assert_eq!(cov.hint.as_deref(), Some("[pkg]"));
assert!(cov.disable_model_invocation);
#[cfg(unix)]
assert_eq!(cov.also_in, [AgentSkillSource::ClaudeWorkspace]);
assert!(by("web-e2e").is_some(), "nested monorepo subpackage skill discovered");
assert!(by("deploy").is_some(), "second workspace member skill discovered");
assert!(by("pg-tune").is_some(), "2-level Copilot marketplace plugin skill discovered");
assert!(by("secret-op").is_none(), "disabled Copilot plugin skipped");
let misplaced = by("misplaced").expect("misplaced top-level SKILL.md surfaced");
assert!(!misplaced.valid && misplaced.warnings[0].contains("subfolder"));
// `disable-model-invocation: true` resolves to `SlashOnly` by default, and because
// `.claude/skills/coverage` symlinks to it in `ws_a`, Claude does not stage a duplicate.
let states = resolve(found, None, &BTreeMap::new(), &BTreeMap::new(), true);
let cov_state = states.iter().find(|s| s.skill.name == "coverage").unwrap();
assert_eq!(cov_state.mode, AgentSkillMode::SlashOnly);
#[cfg(unix)]
{
let farm = farm_dir(&root.join("store"), "task-symlink");
let _ = stage(&farm, "claude", &states, &ws_a, Some(&home)).unwrap();
let claude_staged = listed(&farm.join(".claude/skills"));
assert!(
!claude_staged.contains(&"coverage".to_string()),
"symlinked `.claude/skills/coverage` not duplicated"
);
}
}
#[test]
fn plugin_skills_yield_to_workspace_and_user_and_stage_to_all_clis() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap();
let ws = root.join("ws");
let home = root.join("home");
let plugin_pkg = root.join("plugins/acme.tools/1.0.0");
write(&ws.join(".agents/skills/clash-ws/SKILL.md"), "---\nname: clash-ws\ndescription: workspace copy\n---\n");
write(&home.join(".agents/skills/clash-user/SKILL.md"), "---\nname: clash-user\ndescription: user copy\n---\n");
write(&plugin_pkg.join("skills/clash-ws/SKILL.md"), "---\nname: clash-ws\ndescription: plugin copy\n---\n");
write(&plugin_pkg.join("skills/clash-user/SKILL.md"), "---\nname: clash-user\ndescription: plugin copy\n---\n");
write(
&plugin_pkg.join("skills/release-notes/SKILL.md"),
"---\nname: release-notes\ndescription: draft release notes\n---\n",
);
let plugin_dirs = vec![
plugin_pkg.join("skills/clash-ws"),
plugin_pkg.join("skills/clash-user"),
plugin_pkg.join("skills/release-notes"),
];
let found = discover_skills_with_plugins(std::slice::from_ref(&ws), Some(&home), &plugin_dirs);
let summary: Vec<(&str, AgentSkillSource, &str)> =
found.iter().map(|s| (s.name.as_str(), s.source, s.description.as_str())).collect();
assert_eq!(
summary,
[
("clash-ws", AgentSkillSource::Workspace, "workspace copy"),
("clash-user", AgentSkillSource::User, "user copy"),
("release-notes", AgentSkillSource::Plugin, "draft release notes"),
],
"workspace and user skills win on name clash without renaming plugin skills"
);
assert!(!AgentSkillSource::Plugin.discovered());
let states = resolve(found.clone(), None, &BTreeMap::new(), &BTreeMap::new(), true);
for provider in ["claude", "copilot", "codex"] {
let farm = farm_dir(&root.join("store"), &format!("plugin-{provider}"));
let _ = stage(&farm, provider, &states, &ws, Some(&home)).unwrap();
}
assert!(
listed(&farm_dir(&root.join("store"), "plugin-claude").join(".claude/skills"))
.contains(&"release-notes".into())
);
assert!(
listed(&farm_dir(&root.join("store"), "plugin-copilot").join("copilot")).contains(&"release-notes".into())
);
assert!(listed(&farm_dir(&root.join("store"), "plugin-codex").join("codex")).contains(&"release-notes".into()));
// Turning a plugin skill off omits it from every CLI's staged farm.
let off_states = resolve(
found,
None,
&BTreeMap::new(),
&BTreeMap::from([("release-notes".to_owned(), policy(AgentSkillMode::Off).unwrap())]),
true,
);
let farm = farm_dir(&root.join("store"), "plugin-off");
let _ = stage(&farm, "claude", &off_states, &ws, Some(&home)).unwrap();
assert!(!farm.join(".claude/skills/release-notes").exists());
}
}
+3 -113
Переглянути файл
@@ -986,7 +986,7 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
wait_for(&mgr_a, &task.id, AgentStatus::NeedsInput).await;
assert_eq!(names(mgr_a.commands("claude", None).await.unwrap()), ["review", "triage"]);
assert_eq!(names(mgr_a.commands("claude", Some(&task.id)).await.unwrap()), ["review", "triage"]);
// Other agents also receive the project's active skills from the skills hub, plus verified native builtins.
// Other agents get only what they offered, plus verified native builtins.
assert_eq!(
names(mgr_a.commands("codex", None).await.unwrap()),
[
@@ -1001,7 +1001,6 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
"goal",
"rename",
"logout",
"triage",
]
);
mgr_a.cancel(&task.id, None).unwrap();
@@ -4444,82 +4443,6 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn per_session_skill_overrides_filter_commands_persist_and_reload_when_idle() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
std::fs::create_dir_all(root.join(".agents/skills/tdd")).unwrap();
std::fs::write(root.join(".agents/skills/tdd/SKILL.md"), "---\nname: tdd\ndescription: TDD\n---\n").unwrap();
std::fs::create_dir_all(root.join(".claude/skills/noisy")).unwrap();
std::fs::write(root.join(".claude/skills/noisy/SKILL.md"), "---\nname: noisy\ndescription: Noisy\n---\n").unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(root, agent.clone());
mgr.set_skills_policy_hook(Box::new({
let root = root.to_path_buf();
move || SkillsPolicy {
user: BTreeMap::from([("tdd".into(), AgentSkillPolicy { mode: AgentSkillMode::Off })]),
workspace_roots: vec![root.clone()],
..SkillsPolicy::default()
}
}));
// Start task with `tdd` (default off) enabled for this session and `noisy` turned off.
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
skill_overrides: BTreeMap::from([
("tdd".into(), AgentSkillMode::Auto),
("noisy".into(), AgentSkillMode::Off),
]),
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let cmd_names: Vec<String> =
mgr.commands("claude", Some(&task.id)).await.unwrap().into_iter().map(|c| c.name).collect();
assert!(cmd_names.contains(&"tdd".to_string()), "{cmd_names:?}");
assert!(
!cmd_names.contains(&"noisy".to_string()),
"`noisy` offered on disk must be stripped when off: {cmd_names:?}"
);
// Flip overrides while idle -> recycles resumable session so next turn calls `session/load`.
let updated = mgr
.set_skill_overrides(
&task.id,
BTreeMap::from([("tdd".into(), AgentSkillMode::Off), ("noisy".into(), AgentSkillMode::Auto)]),
)
.unwrap();
assert_eq!(updated.skill_overrides.get("tdd"), Some(&AgentSkillMode::Off));
assert_eq!(updated.skill_overrides.get("noisy"), Some(&AgentSkillMode::Auto));
let cmd_names_after: Vec<String> =
mgr.commands("claude", Some(&task.id)).await.unwrap().into_iter().map(|c| c.name).collect();
assert!(!cmd_names_after.contains(&"tdd".to_string()), "{cmd_names_after:?}");
assert!(cmd_names_after.contains(&"noisy".to_string()), "{cmd_names_after:?}");
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert_eq!(agent.mcp_calls.lock().last().map(|c| c.0.as_str()), Some("session/load"));
mgr.shutdown();
// Persisted task file preserves `skill_overrides` across restart.
let restored_mgr = manager(root, Arc::new(FakeAgent::default()));
let restored = restored_mgr.subscribe(Arc::new(|_| {})).into_iter().find(|t| t.id == task.id).unwrap();
assert_eq!(restored.skill_overrides.get("tdd"), Some(&AgentSkillMode::Off));
assert_eq!(restored.skill_overrides.get("noisy"), Some(&AgentSkillMode::Auto));
restored_mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails() {
#[derive(Clone, Copy)]
@@ -4726,43 +4649,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, None);
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());
}
#[test]
fn session_params_offer_the_workspace_roots() {
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
let params = session_params("/w/api", &none, None, &["/w/web".to_owned()]);
assert_eq!(params["additionalDirectories"], json!(["/w/web"]));
assert!(session_params("/w/api", &none, None, &[]).get("additionalDirectories").is_none());
}
#[tokio::test]
async fn workspace_roots_go_to_agents_that_take_them() {
let tmp = tempfile::tempdir().unwrap();
let [api, web, worktree] = ["api", "web", "worktree"].map(|d| tmp.path().join(d));
for d in [&api, &web, &worktree] {
std::fs::create_dir_all(d).unwrap();
}
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let hook_roots = [api.clone(), web.clone(), web.clone()];
mgr.set_workspace_roots_hook(Arc::new(move || hook_roots.to_vec()));
let init = |capabilities: Value| acp::Negotiated {
generation: 1,
capabilities,
agent_info: None,
auth_methods: Vec::new(),
meta: None,
};
let takes = init(json!({ "sessionCapabilities": { "additionalDirectories": {} } }));
let web = dunce::canonicalize(&web).unwrap().to_string_lossy().into_owned();
assert_eq!(mgr.shared.additional_directories(&takes, &api, None), vec![web.clone()]);
// A task in a worktree of `api` isn't offered the project's own checkout.
assert_eq!(mgr.shared.additional_directories(&takes, &worktree, Some(&api)), vec![web]);
assert!(mgr.shared.additional_directories(&init(json!({})), &api, None).is_empty());
assert!(session_params("/p", &none, None).get("_meta").is_none());
}
+13 -112
Переглянути файл
@@ -15,8 +15,8 @@ pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
pub use launch_resources::process_launch_resources;
pub use modules::record_module_build;
pub use single::{
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, module_classpaths,
single_file_classpath, single_file_target,
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
single_file_target,
};
pub use structure::{
StructureJdk, StructureRoots, artifact_file, artifact_output, language_release, structure_outputs, structure_plan,
@@ -916,47 +916,6 @@ fn launch_plan(
Ok(plan)
}
/// Directory of the linked Maven reactor that builds the launch module at `module`;
/// launches of one reactor can share a build ([`build_for_launches`]).
pub fn launch_reactor(root: &Path, model: &BuildModel, module: &Path) -> Option<String> {
maven_reactor(model.maven.as_ref()?, &rel_str(root, module)).map(|top| top.dir.clone())
}
/// One Maven step building every module of `modules` (all of one reactor) with what they
/// depend on: `-pl a,b -am`, so their shared upstream modules build once (#3971).
fn merged_launch_plan(
root: &Path,
model: &BuildModel,
modules: &[PathBuf],
test: bool,
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<BuildPlan> {
let mut plan = launch_plan(root, model, &modules[0], test, kind, cancel)?;
if plan.system != BuildSystem::Maven || modules.len() == 1 {
return Ok(plan);
}
let mut selection = Vec::new();
for module in modules {
let one = launch_plan(root, model, module, test, kind, cancel)?;
if one.steps.len() != 1 || one.steps[0].cwd != plan.steps[0].cwd {
return Err(IdeError::invalid("launch modules belong to different Maven reactors"));
}
match one.steps[0].args.iter().position(|a| a == "-pl") {
Some(i) => selection.push(one.steps[0].args[i + 1].clone()),
// The reactor root itself builds every module.
None => return Ok(one),
}
}
selection.sort();
selection.dedup();
let step = &mut plan.steps[0];
if let Some(i) = step.args.iter().position(|a| a == "-pl") {
step.args[i + 1] = selection.join(",");
}
Ok(plan)
}
#[derive(Debug)]
pub struct LaunchBuild {
pub class_dirs: Vec<PathBuf>,
@@ -973,21 +932,7 @@ pub fn build_for_launch(
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<LaunchBuild> {
let mut built = build_for_launches(root, model, &[module.to_path_buf()], test, kind, cancel)?;
Ok(built.pop().unwrap())
}
/// [`build_for_launch`] of several modules of one Maven reactor in a single Maven run:
/// one result per module, in order, sharing the build's failure.
pub fn build_for_launches(
root: &Path,
model: &BuildModel,
modules: &[PathBuf],
test: bool,
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<Vec<LaunchBuild>> {
let plan = merged_launch_plan(root, model, modules, test, kind, cancel)?;
let plan = launch_plan(root, model, module, test, kind, cancel)?;
let result = run(root, &plan, cancel, &|_| {})?;
let failure = if !result.success {
let errors: Vec<String> = result
@@ -1004,21 +949,17 @@ pub fn build_for_launches(
} else {
None
};
let class_dirs = |module: &Path| {
if plan.system == BuildSystem::Maven
&& let Some(m) = &model.maven
{
maven_launch_projects(root, m, module, test)
.iter()
.flat_map(|p| {
launch_class_dirs(plan.system, &subdir(root, &p.dir), test && subdir(root, &p.dir) == module)
})
.collect()
} else {
launch_class_dirs(plan.system, module, test)
}
let class_dirs = if plan.system == BuildSystem::Maven
&& let Some(m) = &model.maven
{
maven_launch_projects(root, m, module, test)
.iter()
.flat_map(|p| launch_class_dirs(plan.system, &subdir(root, &p.dir), test && subdir(root, &p.dir) == module))
.collect()
} else {
launch_class_dirs(plan.system, module, test)
};
Ok(modules.iter().map(|m| LaunchBuild { class_dirs: class_dirs(m), failure: failure.clone() }).collect())
Ok(LaunchBuild { class_dirs, failure })
}
fn launch_class_dirs(system: BuildSystem, module: &Path, test: bool) -> Vec<PathBuf> {
@@ -1718,46 +1659,6 @@ mod tests {
}
}
#[test]
fn launches_of_one_reactor_merge_into_one_module_selection() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
for dir in ["app", "lib", "unrelated"] {
write(root, &format!("{dir}/pom.xml"), "<project/>");
}
let mut model = reactor_model();
let cancel = CancellationToken::new();
let modules = |dirs: &[&str]| dirs.iter().map(|d| root.join(d)).collect::<Vec<_>>();
let selection = |plan: BuildPlan| {
let args = &plan.steps[0].args;
args.iter().position(|a| a == "-pl").map(|i| (args[i + 1].clone(), args[i + 2].clone(), args.len()))
};
assert_eq!(launch_reactor(root, &model, &root.join("lib")).as_deref(), Some(""));
let plan = merged_launch_plan(root, &model, &modules(&["lib", "app", "lib"]), false, BuildKind::Build, &cancel)
.unwrap();
assert_eq!(plan.steps.len(), 1);
assert_eq!(plan.steps[0].args.last().unwrap(), "compile");
assert_eq!(selection(plan), Some(("app,lib".into(), "-am".into(), 10)));
// One module: exactly the single launch's step.
let single = merged_launch_plan(root, &model, &modules(&["app"]), true, BuildKind::Rebuild, &cancel).unwrap();
let expected = launch_plan(root, &model, &root.join("app"), true, BuildKind::Rebuild, &cancel).unwrap();
assert_eq!(single.steps[0].args, expected.steps[0].args);
// The reactor root among them builds the whole reactor.
model.maven.as_mut().unwrap().projects[0].packaging = "jar".into();
let whole = merged_launch_plan(root, &model, &modules(&["app", ""]), false, BuildKind::Build, &cancel).unwrap();
assert_eq!(selection(whole), None);
// Another linked reactor can't join the step.
let m = model.maven.as_mut().unwrap();
m.projects[4].aggregated = false;
m.projects[4].command = "other".into();
m.projects[0].modules.retain(|p| p != "unrelated/pom.xml");
assert_eq!(launch_reactor(root, &model, &root.join("unrelated")).as_deref(), Some("unrelated"));
assert!(
merged_launch_plan(root, &model, &modules(&["app", "unrelated"]), false, BuildKind::Build, &cancel)
.is_err()
);
}
#[cfg(unix)]
#[test]
fn external_launch_returns_upstream_outputs_and_blocks_failure_or_cancellation() {
+47 -157
Переглянути файл
@@ -129,73 +129,31 @@ pub fn module_classpath(
cache: &Path,
cancel: &ide_core::CancellationToken,
) -> IdeResult<String> {
module_classpaths(root, model, &[module.to_path_buf()], test, local_repo, cache, cancel)
}
/// [`module_classpath`] of `modules[0]`. The other modules, launched together with it
/// (#3971), share its Maven probe when they have no cached classpath, which leaves
/// theirs cached for their own launches.
pub fn module_classpaths(
root: &Path,
model: &BuildModel,
modules: &[PathBuf],
test: bool,
local_repo: Option<PathBuf>,
cache: &Path,
cancel: &ide_core::CancellationToken,
) -> IdeResult<String> {
let mut probes: Vec<Probe> = Vec::new();
for (i, module) in modules.iter().enumerate() {
let target = match module_target(root, model, module, test) {
Ok(target) => target,
Err(e) if i == 0 => return Err(e),
Err(_) => continue,
};
if i > 0 && (target.top.dir != probes[0].0.top.dir || probes.iter().any(|p| p.0.module == target.module)) {
continue;
}
let fingerprint = launch_fingerprint(root, model, &target.module, test, local_repo.clone(), cancel)?;
let cache_path = classpath_cache_path(root, cache, &target.module, test);
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
if i == 0 {
return Ok(cached.classpath);
}
continue;
}
probes.push(Probe(target, fingerprint, cache_path));
let target = module_target(root, model, module, test)?;
let fingerprint = launch_fingerprint(root, model, &target.module, test, local_repo, cancel)?;
let cache_path = classpath_cache_path(root, cache, &target.module, test);
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
return Ok(cached.classpath);
}
let scope = if test { "test" } else { "runtime" };
let targets: Vec<&SingleFileTarget> = probes.iter().map(|p| &p.0).collect();
let classpaths = match classpaths(root, model, &targets, scope, true) {
Ok(classpaths) => classpaths,
// Another module's failure must not cost this launch its own probe.
Err(_) if targets.len() > 1 && !cancel.is_cancelled() => classpaths(root, model, &targets[..1], scope, true)?,
Err(e) => return Err(e),
};
let classpath = classpath(root, model, &target, if test { "test" } else { "runtime" }, true)?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
for (Probe(_, fingerprint, cache_path), classpath) in probes.into_iter().zip(&classpaths) {
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached =
CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
}
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
}
}
Ok(classpaths.into_iter().next().unwrap())
Ok(classpath)
}
/// A module whose classpath the Maven probe resolves, with its cache key and file.
struct Probe(SingleFileTarget, Option<LaunchFingerprint>, Option<PathBuf>);
/// One cache file per module and scope. Mirroring the module path keeps nested
/// modules and their different dependency scopes from overwriting each other.
fn classpath_cache_path(root: &Path, cache: &Path, module: &Path, test: bool) -> Option<PathBuf> {
@@ -237,62 +195,6 @@ fn classpath(
scope: &str,
compile_first: bool,
) -> IdeResult<String> {
Ok(classpaths(root, model, &[target], scope, compile_first)?.pop().unwrap())
}
/// The classpath of each of `targets` (modules of one reactor) from one Maven probe.
fn classpaths(
root: &Path,
model: &BuildModel,
targets: &[&SingleFileTarget],
scope: &str,
compile_first: bool,
) -> IdeResult<Vec<String>> {
let top = &targets[0].top;
let probe = CP_FILE;
let mut args = vec!["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG];
args.extend(top.options.iter().map(String::as_str));
// The reactor root among them builds every module.
let selection = if targets.iter().any(|t| t.pl.is_empty()) {
String::new()
} else {
let mut pl: Vec<&str> = targets.iter().map(|t| t.pl.as_str()).collect();
pl.sort();
pl.dedup();
pl.join(",")
};
if !selection.is_empty() {
args.extend(["-pl", selection.as_str(), "-am"]);
}
let output_arg = format!("-Dmdep.outputFile={probe}");
let scope_arg = format!("-Dmdep.includeScope={scope}");
// A launch build may only have reached `compile`. Running `compile` in this
// same Maven session lets the dependency plugin resolve Reactor siblings from
// their target/classes without paying for package-phase plugins.
if compile_first {
args.push("compile");
}
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
let top_dir = subdir(root, &top.dir);
let mut command = ProcCommand::new(&top.command);
command.args(&args).envs(&top.env).current_dir(&top_dir);
let status = ide_core::process::prepare(&mut command)
.output()
.map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
if !status.status.success() {
let stdout = String::from_utf8_lossy(&status.stdout);
let stderr = String::from_utf8_lossy(&status.stderr);
// Maven reports reactor/dependency failures on stdout, not only stderr.
let tail: Vec<&str> = stdout.lines().chain(stderr.lines()).filter(|l| !l.trim().is_empty()).collect();
let tail = tail.iter().rev().take(5).rev().cloned().collect::<Vec<_>>().join("\n");
return Err(IdeError::internal(format!("cannot resolve the compile classpath:\n{tail}")));
}
targets.iter().map(|target| target_classpath(root, model, target)).collect()
}
/// The classpath of `target` after a probe: its reactor class directories, then
/// the dependencies Maven wrote to the module's probe file.
fn target_classpath(root: &Path, model: &BuildModel, target: &SingleFileTarget) -> IdeResult<String> {
let mut entries: Vec<String> = Vec::new();
// The module's own classes first: the file almost always uses classes next to it.
let own: &[&str] = if target.test { &["target/test-classes", "target/classes"] } else { &["target/classes"] };
@@ -318,8 +220,37 @@ fn target_classpath(root: &Path, model: &BuildModel, target: &SingleFileTarget)
}
}
}
let probe = CP_FILE;
let mut args = vec!["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG];
args.extend(target.top.options.iter().map(String::as_str));
if !target.pl.is_empty() {
args.extend(["-pl", target.pl.as_str(), "-am"]);
}
let output_arg = format!("-Dmdep.outputFile={probe}");
let scope_arg = format!("-Dmdep.includeScope={scope}");
// A launch build may only have reached `compile`. Running `compile` in this
// same Maven session lets the dependency plugin resolve Reactor siblings from
// their target/classes without paying for package-phase plugins.
if compile_first {
args.push("compile");
}
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
let top_dir = subdir(root, &target.top.dir);
let mut command = ProcCommand::new(&target.top.command);
command.args(&args).envs(&target.top.env).current_dir(&top_dir);
let status = ide_core::process::prepare(&mut command)
.output()
.map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
if !status.status.success() {
let stdout = String::from_utf8_lossy(&status.stdout);
let stderr = String::from_utf8_lossy(&status.stderr);
// Maven reports reactor/dependency failures on stdout, not only stderr.
let tail: Vec<&str> = stdout.lines().chain(stderr.lines()).filter(|l| !l.trim().is_empty()).collect();
let tail = tail.iter().rev().take(5).rev().cloned().collect::<Vec<_>>().join("\n");
return Err(IdeError::internal(format!("cannot resolve the compile classpath:\n{tail}")));
}
// With `-am` every visited module writes its own file; only this module's counts.
let cp_file = target.module.join(CP_FILE);
let cp_file = target.module.join(probe);
let content = fs::read_to_string(&cp_file).map_err(|e| {
IdeError::internal(format!("cannot resolve the compile classpath: {} ({e})", cp_file.display()))
})?;
@@ -597,47 +528,6 @@ mod tests {
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
}
/// Modules launched together resolve their classpaths in one Maven probe and leave
/// the others' cached; a probe another module breaks still resolves the first one.
#[cfg(unix)]
#[test]
fn launch_modules_share_one_classpath_probe() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
fixture(root);
write(root, "lib/src/main/java/demo/Lib.java", "class Lib {}");
let script = root.join("mvnw");
fs::write(
&script,
"#!/bin/sh\necho \"$@\" >> calls.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\ncase \"$pl\" in *lib*) [ -f lib/broken ] && exit 1;; esac\nfor m in $(echo \"$pl\" | tr ',' ' '); do mkdir -p \"$m/target\" repo; touch \"repo/$m.jar\"; printf \"$PWD/repo/$m.jar\" > \"$m/target/ide-compile-cp.txt\"; done\n",
)
.unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
let model = crate::load(root, &root.join("cache"), None);
let cache = root.join("cache");
let cancel = CancellationToken::new();
let calls = || fs::read_to_string(root.join("calls.txt")).unwrap_or_default().lines().count();
let modules = [root.join("app"), root.join("lib"), root.join("app")];
let app = module_classpaths(root, &model, &modules, false, None, &cache, &cancel).unwrap();
assert!(app.contains("/repo/app.jar") && !app.contains("repo/lib.jar"), "{app}");
assert_eq!(calls(), 1);
assert!(fs::read_to_string(root.join("calls.txt")).unwrap().contains("-pl app,lib -am compile"));
let lib = module_classpath(root, &model, &root.join("lib"), false, None, &cache, &cancel).unwrap();
assert!(lib.contains("/repo/lib.jar"), "{lib}");
assert_eq!(calls(), 1, "lib's classpath came from the shared probe");
// A probe another module breaks is retried for the first module alone.
write(root, "lib/src/main/java/demo/Lib.java", "class Lib { int changed; }");
write(root, "lib/broken", "");
let app = module_classpaths(root, &model, &[root.join("app"), root.join("lib")], false, None, &cache, &cancel)
.unwrap();
assert!(app.contains("/repo/app.jar"), "{app}");
assert_eq!(calls(), 3, "the shared probe failed, then app was probed alone");
// The first module's own failure stays its failure.
assert!(module_classpath(root, &model, &root.join("lib"), false, None, &cache, &cancel).is_err());
}
/// The launch classpath follows the Maven runner JDK and is reused until that
/// build input changes; the probe does not run packaging plugins.
#[cfg(unix)]
-6
Переглянути файл
@@ -288,8 +288,6 @@ pub struct SmartKeysSettings {
pub pair_quotes: bool,
pub surround_selection: bool,
pub tab_out_of_pair: bool,
/// A `;` typed before the closing `)` of a statement goes to the end of the statement.
pub semicolon_at_statement_end: bool,
/// Simultaneous `<tag></tag>` editing: renaming a tag renames its matching tag.
pub simultaneous_tag_editing: bool,
/// Reformat on paste: `none` | `indentBlock` | `indentEachLine`.
@@ -311,7 +309,6 @@ impl Default for SmartKeysSettings {
pair_quotes: true,
surround_selection: true,
tab_out_of_pair: true,
semicolon_at_statement_end: true,
simultaneous_tag_editing: true,
reformat_on_paste: "indentEachLine".into(),
escape_on_paste: true,
@@ -438,9 +435,6 @@ pub struct TextAttributesOverride {
pub effect: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effect_color: Option<String>,
/// IDEA's `ERROR_STRIPE_COLOR`: the diff overview-lane marker of a change type.
#[serde(skip_serializing_if = "Option::is_none")]
pub error_stripe_color: Option<String>,
}
/// Editor › Code Style › <Language> › Tabs and Indents (unset fields inherit).
-29
Переглянути файл
@@ -72,16 +72,6 @@ impl WindowButtonLayout {
let right = side(parts.next());
(!left.is_empty() || !right.is_empty()).then_some(Self { left, right })
}
/// The layout on Linux: the desktop's `gtk-decoration-layout` when a desktop session is running.
/// Without one (WSLg, a bare compositor) GTK reports its built-in fallback, close only, which
/// leaves no way to minimise or maximise the frameless window, so the default applies.
pub fn for_linux(gtk_layout: Option<&str>, var: impl Fn(&str) -> Option<String>) -> Self {
let desktop = ["XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP", "DESKTOP_SESSION"]
.iter()
.any(|key| var(key).is_some_and(|value| !value.trim().is_empty()));
gtk_layout.filter(|_| desktop).and_then(Self::from_gtk_decoration_layout).unwrap_or_default()
}
}
#[cfg(test)]
@@ -128,25 +118,6 @@ mod tests {
}
}
#[test]
fn linux_layout_needs_a_desktop_session() {
let env = |vars: &'static [(&'static str, &'static str)]| {
move |key: &str| vars.iter().find(|(k, _)| *k == key).map(|(_, v)| v.to_string())
};
let gnome = env(&[("XDG_CURRENT_DESKTOP", "ubuntu:GNOME")]);
assert_eq!(WindowButtonLayout::for_linux(Some("appmenu:close"), gnome), layout(&[], &[Close]).unwrap());
let kde = env(&[("DESKTOP_SESSION", "plasma")]);
assert_eq!(
WindowButtonLayout::for_linux(Some("close,maximize,minimize:icon"), kde),
layout(&[Close, Maximize, Minimize], &[]).unwrap()
);
// WSLg: no desktop session, GTK's fallback layout.
let wslg = env(&[("WAYLAND_DISPLAY", "wayland-0"), ("XDG_CURRENT_DESKTOP", " ")]);
assert_eq!(WindowButtonLayout::for_linux(Some("menu:close"), wslg), WindowButtonLayout::default());
let gnome = env(&[("XDG_SESSION_DESKTOP", "gnome")]);
assert_eq!(WindowButtonLayout::for_linux(None, gnome), WindowButtonLayout::default());
}
#[test]
fn default_layout_is_on_the_right() {
assert_eq!(WindowButtonLayout::default(), layout(&[], &[Minimize, Maximize, Close]).unwrap());
+1 -29
Переглянути файл
@@ -1254,7 +1254,6 @@ pub struct ArduinoSettings {
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct MarkdownSettings {
pub preview_layout: MarkdownPreviewLayout,
/// Preview (and notebook Markdown cell) font size in px; unset follows the editor font size.
pub preview_font_size: Option<u32>,
/// "Detect commands that can be run right from Markdown files": gutter run icons on
@@ -1266,23 +1265,10 @@ pub struct MarkdownSettings {
impl Default for MarkdownSettings {
fn default() -> Self {
Self {
preview_layout: MarkdownPreviewLayout::default(),
preview_font_size: None,
run_commands: true,
command_directory: None,
}
Self { preview_font_size: None, run_commands: true, command_directory: None }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum MarkdownPreviewLayout {
#[default]
SideBySide,
Stacked,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "lowercase")]
pub enum MarkdownCommandDirectory {
@@ -1903,20 +1889,6 @@ mod tests {
}
}
#[test]
fn markdown_preview_layout_defaults_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"languages":{"markdown":{"previewFontSize":16}}}"#).unwrap();
assert_eq!(old.languages.markdown.preview_layout, MarkdownPreviewLayout::SideBySide);
assert_eq!(old.languages.markdown.preview_font_size, Some(16));
let stacked: Settings =
serde_json::from_str(r#"{"languages":{"markdown":{"previewLayout":"stacked"}}}"#).unwrap();
assert_eq!(stacked.languages.markdown.preview_layout, MarkdownPreviewLayout::Stacked);
let saved = serde_json::to_value(&stacked).unwrap();
assert_eq!(saved["languages"]["markdown"]["previewLayout"], "stacked");
assert_eq!(serde_json::from_value::<Settings>(saved).unwrap().languages.markdown, stacked.languages.markdown);
}
#[test]
fn cmake_profile_argument_arrays_round_trip() {
let mut settings = Settings::default();
+1 -10
Переглянути файл
@@ -22,9 +22,6 @@ const LIMIT: usize = 16 * 1024 * 1024;
pub struct DbJdbcDriver {
pub id: String,
pub name: String,
/// Data source preset id; absent for a generic JDBC profile.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub vendor: Option<String>,
pub jars: Vec<String>,
pub class_name: String,
pub url_template: String,
@@ -149,7 +146,7 @@ impl DbManager {
fn jdbc_approval(&self, source: &DataSource) -> IdeResult<(PathBuf, String)> {
let registry = self.jdbc_registry()?;
let key = serde_json::to_vec(&(&self.root, &source.id)).map_err(|e| IdeError::internal(e.to_string()))?;
let mut settings = serde_json::to_vec(&(
let settings = serde_json::to_vec(&(
&source.jdbc_driver,
&source.url,
&source.user,
@@ -158,9 +155,6 @@ impl DbManager {
&source.options,
))
.map_err(|e| IdeError::internal(e.to_string()))?;
if self.jdbc_password_isolated(source) {
settings.extend_from_slice(b"\0jdbc-password");
}
Ok((
registry.with_file_name("jdbc-approvals").join(blake3::hash(&key).to_hex().as_str()),
blake3::hash(&settings).to_hex().to_string(),
@@ -201,9 +195,6 @@ impl DbManager {
.into_iter()
.find(|d| d.id == source.jdbc_driver)
.ok_or_else(|| IdeError::invalid("Select an installed JDBC driver profile"))?;
if !source.vendor.is_empty() && driver.vendor.as_deref() != Some(source.vendor.as_str()) {
return Err(IdeError::invalid("The JDBC driver profile is not associated with this data source type"));
}
JdbcPool::connect(source, password, driver, self.jdbc_registry()?.with_file_name("jdbc"))
.await
.map(Box::new)
+15 -149
Переглянути файл
@@ -25,8 +25,8 @@ pub use conn::{Held, Pool, QueryResult, ResultColumn};
pub use history::HistoryEntry;
pub use plan::{PlanNode, PlanProperty};
pub use source::{
DataSource, DbColor, DbDriver, DbIntrospection, DbOptions, DbProperty, DbSchemaSelection, DbSnowflake,
DbSnowflakeAuth, DbSsh, DbSshAuth, DbSslMode, DbTxMode, DbVisibilityChange,
DataSource, DbColor, DbDriver, DbIntrospection, DbOptions, DbProperty, DbSnowflake, DbSnowflakeAuth, DbSsh,
DbSshAuth, DbSslMode, DbTxMode,
};
pub use sql::{CellValue, DbRowEdit, SortKey};
@@ -475,29 +475,6 @@ impl DbManager {
}
}
fn non_password_snowflake(source: &DataSource) -> Option<DbSnowflake> {
let settings = match source.driver {
DbDriver::Snowflake => source.resolved().map(|source| source.snowflake()).unwrap_or_default(),
DbDriver::Jdbc => source.snowflake.clone()?,
_ => return None,
};
(settings.auth != DbSnowflakeAuth::Password).then_some(settings)
}
fn jdbc_password_isolated(&self, source: &DataSource) -> bool {
source.driver == DbDriver::Jdbc
&& (Self::non_password_snowflake(source).is_some()
|| self
.sources()
.unwrap_or_default()
.iter()
.any(|stored| stored.id == source.id && Self::non_password_snowflake(stored).is_some()))
}
fn password_key(&self, source: &DataSource) -> String {
if self.jdbc_password_isolated(source) { secrets::jdbc_key(&source.id) } else { source.id.clone() }
}
/// The connection settings of target `target` ([`DataSource::resolved`]), with
/// its database for `<id>:<database>`.
pub fn source(&self, target: &str) -> IdeResult<DataSource> {
@@ -518,21 +495,15 @@ impl DbManager {
Ok(source)
}
/// Saves the data source list, preserving connections when only visibility rules change.
/// Saves the data source list; connections of removed or changed sources are closed.
/// Global ones (`global`) go to the app-wide list, the others to the project's.
pub async fn save_sources(&self, mut sources: Vec<DataSource>) -> IdeResult<()> {
pub async fn save_sources(&self, sources: Vec<DataSource>) -> IdeResult<()> {
if sources.iter().any(|s| s.global && s.plugin_owner.is_some()) {
return Err(IdeError::invalid("plugin-owned data sources must stay project-scoped"));
}
let old = {
let _guard = plugin::EDIT.lock();
let old = self.sources().unwrap_or_default();
for source in sources.iter_mut().filter(|s| s.driver == DbDriver::Jdbc) {
// Retain the credential scope even when URL-only settings supplied the old authenticator.
if let Some(settings) = old.iter().find(|s| s.id == source.id).and_then(Self::non_password_snowflake) {
source.snowflake = Some(settings);
}
}
let (global, project): (Vec<_>, Vec<_>) = sources.iter().cloned().partition(|s| s.global);
match &self.global {
// Rewritten only when it changes: other projects' windows edit the same file.
@@ -551,10 +522,9 @@ impl DbManager {
};
for o in old {
match sources.iter().find(|s| s.id == o.id) {
Some(n) if o.same_except_visibility(n) => {}
Some(n) if *n == o => {}
gone_or_changed => {
let keys =
[o.id.clone(), secrets::jdbc_key(&o.id), secrets::ssh_key(&o.id), Self::sso_credential(&o.id)];
let keys = [o.id.clone(), secrets::ssh_key(&o.id), Self::sso_credential(&o.id)];
match gone_or_changed {
None => {
self.catalogs.forget(&o.id);
@@ -585,31 +555,6 @@ impl DbManager {
Ok(())
}
/// Updates one scope of a source's visibility against its latest saved rules.
pub fn save_source_visibility(&self, id: &str, available: &[String], change: DbVisibilityChange) -> IdeResult<()> {
let _guard = plugin::EDIT.lock();
let mut sources = source::load(&self.root)?;
let scoped_global = self.global.as_ref().filter(|_| !sources.iter().any(|source| source.id == id));
if let Some((dir, _)) = scoped_global {
sources = source::load_global(dir)?;
}
let selected = sources
.iter_mut()
.find(|source| source.id == id)
.ok_or_else(|| IdeError::not_found(format!("no data source {id}")))?;
let previous = selected.introspection.clone();
change.apply(&mut selected.introspection, available);
if selected.introspection == previous {
return Ok(());
}
if let Some((dir, _)) = scoped_global {
source::save_global(dir, &sources)?;
} else {
source::save(&self.root, &sources)?;
}
Ok(())
}
/// Watches the data source files (the project's and the global one) for edits made
/// outside the IDE; `on_change` runs on a background thread once they settle, and
/// should call [`DbManager::reconcile_sources`]. Stops when the result is dropped.
@@ -618,9 +563,9 @@ impl DbManager {
SourcesWatch::start(&self.root, self.global.as_ref().map(|(dir, _)| dir.as_path()), on_change)
}
/// Re-reads the data sources after their files changed on disk and closes affected
/// connections as on [`DbManager::save_sources`] (saved passwords stay, the source
/// may come back). Returns whether the list the tree
/// Re-reads the data sources after their files changed on disk: connections of
/// removed or changed sources close, as on [`DbManager::save_sources`] (saved
/// passwords stay, the source may come back). Returns whether the list the tree
/// shows changed, or the files no longer parse (the tree reports the error).
pub async fn reconcile_sources(&self) -> bool {
let now = match self.sources() {
@@ -635,7 +580,7 @@ impl DbManager {
return false;
}
for o in &before {
if now.iter().find(|s| s.id == o.id).is_none_or(|n| !o.same_except_visibility(n)) {
if now.iter().find(|s| s.id == o.id) != Some(o) {
self.disconnect_source(&o.id).await;
}
}
@@ -645,12 +590,7 @@ impl DbManager {
/// Remembers `password` for the session, and in the saved passwords when
/// the data source saves passwords (`None` forgets it).
pub async fn set_password(&self, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
let source = self.sources()?.into_iter().find(|s| s.id == id);
let (store, key) = match source.as_ref() {
Some(source) => (self.store_of(source), self.password_key(source)),
None => (&self.saved_passwords, id.to_owned()),
};
self.remember(store, key, password, save).await
self.remember(id, id.to_owned(), password, save).await
}
/// [`DbManager::set_password`] for the SSH password / key passphrase.
@@ -662,10 +602,10 @@ impl DbManager {
self.ssh.set_secret(&c, secret, save);
return Ok(());
}
self.remember(self.saved_for(id), secrets::ssh_key(id), secret, save).await
self.remember(id, secrets::ssh_key(id), secret, save).await
}
async fn remember(&self, store: &SecretStore, key: String, secret: Option<String>, save: bool) -> IdeResult<()> {
async fn remember(&self, id: &str, key: String, secret: Option<String>, save: bool) -> IdeResult<()> {
match &secret {
Some(p) => {
self.session_passwords.lock().insert(key.clone(), p.clone());
@@ -674,6 +614,7 @@ impl DbManager {
self.session_passwords.lock().remove(&key);
}
}
let store = self.saved_for(id);
let result = match (secret, save) {
(Some(p), true) => store.set(&key, &p),
_ => {
@@ -699,10 +640,7 @@ impl DbManager {
}
async fn password(&self, source: &DataSource) -> Option<String> {
match self
.secret(source, self.password_key(source), source.driver != DbDriver::Sqlite && source.save_password)
.await
{
match self.secret(source, source.id.clone(), source.driver != DbDriver::Sqlite && source.save_password).await {
Some(p) => Some(p),
None => source.url_password(),
}
@@ -1825,78 +1763,6 @@ mod tests {
);
}
#[tokio::test]
async fn switching_from_snowflake_key_pair_keeps_the_jdbc_password_separate() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path()).with_global_sources(tmp.path().join("global"));
let native = DataSource {
id: "snowflake".into(),
name: "Snowflake".into(),
driver: DbDriver::Snowflake,
save_password: true,
url_only: true,
url: "jdbc:snowflake://example.invalid/?authenticator=SNOWFLAKE_JWT".into(),
..Default::default()
};
db.save_sources(vec![native.clone()]).await?;
db.set_password(&native.id, Some("native-passphrase".into()), true).await?;
let jdbc = DataSource { driver: DbDriver::Jdbc, url: "jdbc:fixture:".into(), ..native.clone() };
// Test Connection can use the JDBC draft before the user saves it.
assert_eq!(db.password(&jdbc).await, None);
assert_eq!(db.password(&native).await.as_deref(), Some("native-passphrase"));
db.approve_jdbc_source(&jdbc)?;
db.save_sources(vec![jdbc.clone()]).await?;
assert_eq!(db.password(&db.source(&jdbc.id)?).await, None);
db.set_password(&jdbc.id, Some("jdbc-password".into()), true).await?;
let reopened = manager(tmp.path()).with_global_sources(tmp.path().join("global"));
let saved = reopened.source(&jdbc.id)?;
assert_eq!(reopened.password(&saved).await.as_deref(), Some("jdbc-password"));
let err = reopened.pool(&jdbc.id).await.err().expect("no JDBC profile installed");
assert!(err.message.contains("Select an installed JDBC driver profile"));
source::save(&reopened.root, std::slice::from_ref(&jdbc))?;
let err = reopened.pool(&jdbc.id).await.err().expect("edited settings need approval");
assert!(err.message.contains("Review this project's JDBC URL and properties"));
source::save(&reopened.root, std::slice::from_ref(&saved))?;
let global = DataSource { global: true, ..saved };
reopened.save_sources(vec![global.clone()]).await?;
assert_eq!(reopened.password(&reopened.source(&jdbc.id)?).await.as_deref(), Some("jdbc-password"));
let native = DataSource { global: true, ..native };
reopened.save_sources(vec![native.clone()]).await?;
assert_eq!(reopened.password(&native).await.as_deref(), Some("native-passphrase"));
reopened.save_sources(Vec::new()).await?;
assert_eq!(reopened.password(&native).await, None);
assert_eq!(reopened.password(&global).await, None);
Ok(())
}
#[tokio::test]
async fn switching_from_snowflake_password_keeps_the_password() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let native = DataSource {
id: "snowflake".into(),
name: "Snowflake".into(),
driver: DbDriver::Snowflake,
save_password: true,
url_only: true,
url: "jdbc:snowflake://example.invalid/?authenticator=snowflake".into(),
..Default::default()
};
db.save_sources(vec![native.clone()]).await?;
db.set_password(&native.id, Some("existing-password".into()), true).await?;
let jdbc = DataSource { driver: DbDriver::Jdbc, url: "jdbc:fixture:".into(), ..native };
assert_eq!(db.password(&jdbc).await.as_deref(), Some("existing-password"));
db.save_sources(vec![jdbc.clone()]).await?;
let reopened = manager(tmp.path());
assert_eq!(reopened.password(&reopened.source(&jdbc.id)?).await.as_deref(), Some("existing-password"));
Ok(())
}
#[tokio::test]
async fn moves_plaintext_passwords_of_older_versions_off_disk() {
let tmp = tempfile::tempdir().unwrap();
-5
Переглянути файл
@@ -18,11 +18,6 @@ pub fn ssh_key(id: &str) -> String {
format!("{id}#ssh")
}
/// JDBC password when the original credential is a Snowflake passphrase or token.
pub fn jdbc_key(id: &str) -> String {
format!("{id}#jdbc")
}
fn file_key(project: &str, key: &str) -> String {
format!("{project}|{key}")
}
-154
Переглянути файл
@@ -6,7 +6,6 @@
use ide_core::{IdeError, IdeResult, IpcPath, project_dir};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::BTreeMap;
use std::path::Path;
pub(crate) const FILE: &str = "data-sources.toml";
@@ -102,9 +101,6 @@ pub struct DbIntrospection {
pub databases: Vec<String>,
pub all_schemas: bool,
pub schemas: Vec<String>,
/// A database can replace the source's schema rules with all schemas or a list of exact names.
#[serde(skip_serializing_if = "BTreeMap::is_empty")]
pub schemas_by_database: BTreeMap<String, DbSchemaSelection>,
/// `pg_catalog`, `information_schema`, `mysql`…, and service databases (`rdsadmin`…).
pub show_system: bool,
/// PostgreSQL template databases (`template0`, `template1`).
@@ -121,7 +117,6 @@ impl Default for DbIntrospection {
databases: Vec::new(),
all_schemas: true,
schemas: Vec::new(),
schemas_by_database: BTreeMap::new(),
show_system: false,
show_templates: false,
object_filter: String::new(),
@@ -130,18 +125,6 @@ impl Default for DbIntrospection {
}
impl DbIntrospection {
pub(crate) fn with_visibility_from(self, source: &Self) -> Self {
Self {
all_databases: source.all_databases,
databases: source.databases.clone(),
all_schemas: source.all_schemas,
schemas: source.schemas.clone(),
schemas_by_database: source.schemas_by_database.clone(),
object_filter: source.object_filter.clone(),
..self
}
}
/// 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).
@@ -180,60 +163,6 @@ fn schema_matches(pattern: &str, name: &str) -> bool {
p[pi..].iter().all(|&c| c == '*')
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default)]
pub struct DbSchemaSelection {
pub all: bool,
pub names: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum DbVisibilityChange {
Databases { selection: DbSchemaSelection },
Schemas { selection: DbSchemaSelection },
DatabaseSchemas { database: String, selection: Option<DbSchemaSelection> },
}
impl DbVisibilityChange {
pub(crate) fn apply(self, introspection: &mut DbIntrospection, available: &[String]) {
let available: std::collections::HashSet<_> = available.iter().map(String::as_str).collect();
let keep_names = |before: &mut Vec<String>, selection: DbSchemaSelection, exact: bool| {
if selection.all || (!exact && before.iter().any(|name| name.contains(['*', '?']))) {
return;
}
before.retain(|name| !available.contains(if exact { name.as_str() } else { name.trim() }));
let mut seen: std::collections::HashSet<_> = before.iter().cloned().collect();
before.extend(
selection
.names
.into_iter()
.filter(|name| (exact || !name.contains(['*', '?'])) && seen.insert(name.clone())),
);
};
match self {
Self::Databases { selection } => {
introspection.all_databases = selection.all;
keep_names(&mut introspection.databases, selection, false);
}
Self::Schemas { selection } => {
introspection.all_schemas = selection.all;
keep_names(&mut introspection.schemas, selection, false);
}
Self::DatabaseSchemas { database, selection } => match selection {
Some(selection) => {
let rule = introspection.schemas_by_database.entry(database).or_default();
rule.all = selection.all;
keep_names(&mut rule.names, selection, true);
}
None => {
introspection.schemas_by_database.remove(&database);
}
},
}
}
}
/// Advanced tab: a driver property. PostgreSQL: run-time parameters (and
/// `application_name`); MySQL: session variables (and `charset`, `collation`);
/// SQLite: pragmas. See [`crate::conn`].
@@ -501,14 +430,6 @@ pub fn parse_url(raw: &str) -> IdeResult<ParsedUrl> {
}
impl DataSource {
pub(crate) fn same_except_visibility(&self, other: &Self) -> bool {
if self == other {
return true;
}
let introspection = other.introspection.clone().with_visibility_from(&self.introspection);
*self == Self { introspection, ..other.clone() }
}
/// The settings to connect with: with [`DataSource::url_only`], host, port,
/// database, user, SSL and driver properties come from the URL (properties
/// of the Advanced tab still apply after the URL's).
@@ -740,81 +661,6 @@ mod tests {
assert_eq!(load(tmp.path()).unwrap(), vec![s]);
}
#[test]
fn visibility_change_preserves_patterns_unavailable_names_and_other_scopes() {
let mut introspection = DbIntrospection {
schemas: vec!["app_*".into(), "unavailable_?".into()],
databases: vec!["reporting".into(), "offline".into()],
schemas_by_database: BTreeMap::from([
("reporting".into(), DbSchemaSelection { all: false, names: vec!["private".into()] }),
("sandbox".into(), DbSchemaSelection { all: false, names: vec!["experiments".into()] }),
]),
show_system: true,
..Default::default()
};
DbVisibilityChange::Schemas { selection: DbSchemaSelection { all: false, names: vec!["demo".into()] } }
.apply(&mut introspection, &["app_sales".into(), "demo".into()]);
assert_eq!(introspection.schemas, ["app_*", "unavailable_?"]);
DbVisibilityChange::Databases { selection: DbSchemaSelection { all: false, names: vec!["sandbox".into()] } }
.apply(&mut introspection, &["reporting".into(), "sandbox".into()]);
assert_eq!(introspection.databases, ["offline", "sandbox"]);
DbVisibilityChange::DatabaseSchemas {
database: "reporting".into(),
selection: Some(DbSchemaSelection {
all: false,
names: vec!["finance".into(), "finance".into(), "private".into()],
}),
}
.apply(&mut introspection, &["public".into(), "finance".into()]);
assert_eq!(introspection.schemas_by_database["reporting"].names, ["private", "finance"]);
assert_eq!(introspection.schemas_by_database["sandbox"].names, ["experiments"]);
assert!(introspection.show_system);
}
#[test]
fn schema_override_can_omit_default_fields() {
let introspection: DbIntrospection = toml::from_str(
r#"
[schemasByDatabase.reporting]
all = true
[schemasByDatabase.sandbox]
names = ["finance"]
"#,
)
.unwrap();
assert_eq!(
introspection.schemas_by_database,
BTreeMap::from([
("reporting".into(), DbSchemaSelection { all: true, names: vec![] }),
("sandbox".into(), DbSchemaSelection { all: false, names: vec!["finance".into()] }),
])
);
}
#[test]
fn round_trips_database_schema_overrides() {
let tmp = tempfile::tempdir().unwrap();
let source = DataSource {
id: "postgres".into(),
name: "PostgreSQL Demo".into(),
driver: DbDriver::Postgres,
introspection: DbIntrospection {
all_schemas: false,
schemas: vec!["app_*".into()],
schemas_by_database: BTreeMap::from([
("analytics".into(), DbSchemaSelection { all: true, names: vec![] }),
("reporting.eu".into(), DbSchemaSelection { all: false, names: vec!["public".into()] }),
("sandbox".into(), DbSchemaSelection { all: false, names: vec![] }),
]),
..Default::default()
},
..Default::default()
};
save(tmp.path(), std::slice::from_ref(&source)).unwrap();
assert_eq!(load(tmp.path()).unwrap(), vec![source]);
}
#[test]
fn sqlserver_defaults() {
assert_eq!(DbDriver::SqlServer.default_port(), Some(1433));
-41
Переглянути файл
@@ -17,14 +17,12 @@ async fn jdbc_profiles_persist_and_project_files_cannot_start_drivers() -> IdeRe
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Test".into(),
vendor: None,
jars: vec![jar.display().to_string()],
class_name: "test.Driver".into(),
url_template: "jdbc:test:".into(),
})?;
let reopened = manager(tmp.path());
assert_eq!(reopened.jdbc_drivers()?[0].class_name, "test.Driver");
assert_eq!(reopened.jdbc_drivers()?[0].vendor, None);
let source = DataSource {
id: "local".into(),
name: "local".into(),
@@ -55,40 +53,6 @@ async fn jdbc_profiles_persist_and_project_files_cannot_start_drivers() -> IdeRe
Ok(())
}
#[tokio::test]
async fn named_jdbc_sources_persist_the_type_and_reject_a_profile_for_another_type() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let jar = tmp.path().join("fixture.jar");
std::fs::write(&jar, [])?;
let db = manager(tmp.path());
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Test".into(),
vendor: Some("tidb".into()),
jars: vec![jar.display().to_string()],
class_name: "test.Driver".into(),
url_template: String::new(),
})?;
let source = DataSource {
id: "local".into(),
name: "local".into(),
driver: DbDriver::Jdbc,
vendor: "mariadb".into(),
jdbc_driver: "fixture".into(),
url: "jdbc:test:".into(),
..Default::default()
};
db.save_sources(vec![source]).await?;
let reopened = manager(tmp.path());
let source = reopened.source("local")?;
assert_eq!(reopened.jdbc_drivers()?[0].vendor.as_deref(), Some("tidb"));
assert_eq!(source.driver, DbDriver::Jdbc);
assert_eq!(source.vendor, "mariadb");
let err = reopened.test(&source, None, None).await.unwrap_err();
assert!(err.message.contains("not associated with this data source type"));
Ok(())
}
#[tokio::test]
#[ignore = "requires DUCKDB_JDBC_JAR and a local Java 17+ runtime"]
async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
@@ -99,7 +63,6 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
db.save_jdbc_driver(DbJdbcDriver {
id: "duck".into(),
name: "DuckDB".into(),
vendor: None,
jars: vec![jar],
class_name: "org.duckdb.DuckDBDriver".into(),
url_template: "jdbc:duckdb:".into(),
@@ -172,7 +135,6 @@ async fn clickhouse_vendor_driver_reads_catalog_and_results() -> IdeResult<()> {
db.save_jdbc_driver(DbJdbcDriver {
id: "clickhouse".into(),
name: "ClickHouse JDBC".into(),
vendor: Some("clickhouse".into()),
jars,
class_name: "com.clickhouse.jdbc.ClickHouseDriver".into(),
url_template: "jdbc:clickhouse://".into(),
@@ -181,7 +143,6 @@ async fn clickhouse_vendor_driver_reads_catalog_and_results() -> IdeResult<()> {
id: "test".into(),
name: "ClickHouse JDBC".into(),
driver: DbDriver::Jdbc,
vendor: "clickhouse".into(),
jdbc_driver: "clickhouse".into(),
url: format!("jdbc:clickhouse://127.0.0.1:{port}/default"),
user: "fixture".into(),
@@ -220,7 +181,6 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Fixture".into(),
vendor: None,
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
url_template: String::new(),
@@ -269,7 +229,6 @@ async fn a_lost_session_reconnects_on_the_next_statement() -> IdeResult<()> {
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Fixture".into(),
vendor: None,
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
url_template: String::new(),
+1 -68
Переглянути файл
@@ -2,8 +2,7 @@
use ide_core::{CancellationToken, IdeResult};
use ide_db::{
CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbSchemaSelection, DbTableKind,
DbVisibilityChange, QueryResult, SortKey,
CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbTableKind, QueryResult, SortKey,
};
async fn setup() -> (tempfile::TempDir, DbManager) {
@@ -243,72 +242,6 @@ async fn manual_commit_keeps_a_transaction_until_commit_or_rollback() -> IdeResu
Ok(())
}
#[tokio::test]
async fn visibility_edits_preserve_the_held_transaction() -> IdeResult<()> {
let (tmp, db) = setup().await;
let c = CancellationToken::new();
db.set_manual_commit("s1", true).await?;
db.execute("s1", "INSERT INTO users (name) VALUES ('dee')", 1, &c).await?;
assert_eq!(count(&db).await, "4");
let mut source = db.source("s1")?;
source.introspection.all_schemas = false;
source.introspection.schemas.clear();
db.save_sources(vec![source.clone()]).await?;
assert!(db.is_connected("s1"), "saving rules must keep the active connection");
assert_eq!(count(&db).await, "4", "the held transaction must still see its uncommitted row");
db.save_source_visibility(
"s1",
&["main".into()],
DbVisibilityChange::Schemas { selection: DbSchemaSelection { all: true, names: vec![] } },
)?;
assert!(db.source("s1")?.introspection.all_schemas);
assert_eq!(count(&db).await, "4", "the scoped save must keep the live transaction");
db.reconcile_sources().await;
let root = tmp.path();
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
let other = DbManager::new(root.to_path_buf(), root.join("passwords.json"), root.join("history.json"), ssh);
source = db.source("s1")?;
source.introspection.object_filter = "user*".into();
other.save_sources(vec![source.clone()]).await?;
assert!(db.reconcile_sources().await);
assert_eq!(count(&db).await, "4", "a visibility edit from another window must keep the transaction");
db.finish_transaction("s1", true).await?;
assert_eq!(count(&db).await, "4");
source.introspection.show_system = true;
db.save_sources(vec![source]).await?;
assert!(!db.is_connected("s1"), "raw metadata option changes keep their invalidation path");
Ok(())
}
#[tokio::test]
async fn visibility_save_does_not_mask_an_unreconciled_connection_edit() -> IdeResult<()> {
let (tmp, db) = setup().await;
let first = db.source("s1")?;
let second = DataSource { id: "s2".into(), name: "Another source".into(), ..first.clone() };
db.save_sources(vec![first.clone(), second.clone()]).await?;
db.reconcile_sources().await;
assert!(db.is_connected("s1"));
let root = tmp.path();
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
let external = DbManager::new(root.to_path_buf(), root.join("passwords.json"), root.join("history.json"), ssh);
external.save_sources(vec![DataSource { read_only: true, ..first }, second]).await?;
db.save_source_visibility(
"s2",
&["main".into()],
DbVisibilityChange::Schemas { selection: DbSchemaSelection { all: false, names: vec![] } },
)?;
assert!(db.is_connected("s1"));
assert!(db.reconcile_sources().await);
assert!(!db.is_connected("s1"));
assert!(!db.source("s2")?.introspection.all_schemas);
Ok(())
}
#[tokio::test]
async fn targets_name_a_database_of_a_data_source() -> IdeResult<()> {
let (_tmp, db) = setup().await;
+2 -65
Переглянути файл
@@ -18,7 +18,7 @@ use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::{Condvar, Mutex, OnceLock};
use std::sync::OnceLock;
use std::time::Duration;
/// Listing and lifecycle commands normally answer in well under a second; a
@@ -315,56 +315,9 @@ pub fn container_stats(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerContain
parse_container_stats(&out).ok_or_else(|| IdeError::not_found("no container stats returned"))
}
/// How long log lines collect before they are handed on together.
const LOG_BATCH: Duration = Duration::from_millis(30);
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
/// until it ends or `cancel` fires. Lines arrive in batches, at most one per
/// [`LOG_BATCH`]: a webview delivers each IPC message on its own, so a message
/// per line made a 1000-line tail take tens of seconds on Windows.
/// until it ends or `cancel` fires.
pub fn logs(
ep: &DockerEndpoint,
id: &str,
tail: u32,
follow: bool,
timestamps: bool,
cancel: &CancellationToken,
on_lines: &(dyn Fn(Vec<DockerLogLine>) + Sync),
) -> IdeResult<()> {
batched(LOG_BATCH, on_lines, |on_line| stream_logs(ep, id, tail, follow, timestamps, cancel, on_line))
}
/// Runs `produce` with a per-item callback and hands the items to `emit` in order,
/// collected over `every`, from a second thread so a quiet stream still flushes.
fn batched<T: Send, R>(every: Duration, emit: &(dyn Fn(Vec<T>) + Sync), produce: impl FnOnce(&dyn Fn(T)) -> R) -> R {
let pending = Mutex::new(Vec::new());
let finished = (Mutex::new(false), Condvar::new());
let flush = || {
let items = std::mem::take(&mut *pending.lock().unwrap_or_else(|e| e.into_inner()));
if !items.is_empty() {
emit(items);
}
};
std::thread::scope(|scope| {
scope.spawn(|| {
let (done, wake) = &finished;
let mut stop = done.lock().unwrap_or_else(|e| e.into_inner());
loop {
stop = wake.wait_timeout(stop, every).unwrap_or_else(|e| e.into_inner()).0;
flush();
if *stop {
break;
}
}
});
let result = produce(&|item| pending.lock().unwrap_or_else(|e| e.into_inner()).push(item));
*finished.0.lock().unwrap_or_else(|e| e.into_inner()) = true;
finished.1.notify_one();
result
})
}
fn stream_logs(
ep: &DockerEndpoint,
id: &str,
tail: u32,
@@ -653,22 +606,6 @@ pub fn cli(
mod local_tests {
use super::*;
#[test]
fn log_lines_arrive_in_order_as_few_batches() {
let batches = Mutex::new(Vec::<Vec<u32>>::new());
let result = batched(Duration::from_millis(30), &|b| batches.lock().unwrap().push(b), |line| {
(0..1000).for_each(line);
std::thread::sleep(Duration::from_millis(80));
line(1000);
"done"
});
assert_eq!(result, "done");
let batches = batches.into_inner().unwrap();
assert_eq!(batches.concat(), (0..=1000).collect::<Vec<_>>(), "every line once, in order");
assert!(batches.len() <= 3, "a burst is one message, not one per line: {} batches", batches.len());
assert_eq!(batches.last().unwrap(), &[1000], "a line after a quiet spell is flushed on its own");
}
#[test]
fn the_selected_context_overrides_docker_host() {
let local = "unix:///var/run/docker.sock";
+1 -2
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.15.0";
pub const ENGINE_VERSION: &str = "1.14.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -164,7 +164,6 @@ pub const EVENT_KINDS: &[&str] = &[
"file-saved",
"files-changed",
"editor-focused",
"caret-moved",
"action-performed",
"vcs-changed",
"problems-changed",
+1 -22
Переглянути файл
@@ -122,34 +122,13 @@ pub struct Prepared {
pub key: Option<String>,
/// User-facing one-liner for the plugin details page ("Insert Date").
pub label: String,
/// When set, this entry is skipped with a plugin load warning instead of failing the plugin.
pub warning: Option<String>,
/// Makes it take effect. Must not fail for reasons `prepare` could have checked.
pub commit: Commit,
}
impl Prepared {
pub fn new(label: impl Into<String>, commit: impl FnOnce() -> Result<Disposable, String> + Send + 'static) -> Self {
Self {
capabilities: Vec::new(),
files: Vec::new(),
key: None,
label: label.into(),
warning: None,
commit: Box::new(commit),
}
}
/// Skips an invalid declaration with a load warning while letting the rest of the plugin load.
pub fn skipped(warning: impl Into<String>) -> Self {
Self {
capabilities: Vec::new(),
files: Vec::new(),
key: None,
label: String::new(),
warning: Some(warning.into()),
commit: Box::new(|| Ok(Disposable::noop())),
}
Self { capabilities: Vec::new(), files: Vec::new(), key: None, label: label.into(), commit: Box::new(commit) }
}
pub fn key(mut self, key: impl Into<String>) -> Self {
-6
Переглянути файл
@@ -270,12 +270,6 @@ impl ExtensionRegistry {
let prepared = point
.prepare(pkg, decl)
.map_err(|e| format!("contributes.{point_id}[{i}]: {}", strip_prefix(&e, point_id)))?;
if let Some(warning) = prepared.warning {
let msg = format!("contributes.{point_id}[{i}]: {}", strip_prefix(&warning, point_id));
tracing::warn!(plugin = %pkg.id(), "{msg}");
set.warnings.push(msg);
continue;
}
for cap in &prepared.capabilities {
if !set.capabilities.contains(cap) {
set.capabilities.push(cap.clone());
+1 -1
Переглянути файл
@@ -345,7 +345,7 @@ impl Host {
}
if let Some(plugins) = plugins::editor_plugin_host() {
plugins.invalidate_client_navigation(&project.root, Some(window), None);
plugins.set_active_file(window, None, None);
plugins.set_active_file(window, None);
}
if !project.light {
self.environment.project_closed();
+5 -22
Переглянути файл
@@ -23,25 +23,7 @@ const DEFAULT_TREE_DEPTH: i64 = 5;
const TREE_LIMIT: usize = 100;
pub fn tools() -> Vec<Tool> {
vec![get_workspace_roots(), read_file(), list_directory_tree()]
}
// --- get_workspace_roots ---------------------------------------------------------
fn get_workspace_roots() -> Tool {
Tool::new(
"get_workspace_roots",
"Returns the root directories of the IDE workspace: this project and the trusted projects attached to it
in the same window, as absolute paths. A task works in one directory, but its workspace can hold several projects.
Call this when asked about the workspace, project or working directories, and before planning a change that may span
projects. Other tools reach an attached project by its root as `projectPath`.",
|call| async move {
let root = call.root().to_path_buf();
let mut roots = vec![root.clone()];
roots.extend(crate::mcp::tool::trusted_attachments(&call.host.trust, &root));
Output::json(json!({ "projectRoot": root, "roots": roots }))
},
)
vec![read_file(), list_directory_tree()]
}
// --- read_file -----------------------------------------------------------------
@@ -202,9 +184,10 @@ marked directory are not marked again.",
}
let deadline = Instant::now() + Duration::from_millis(timeout.max(0) as u64);
let cancel = call.cancel.clone();
// Matched from the root holding the directory: an attached project has its own exclusions.
let root = call.project().root_of(&dir);
let marks = Marks { excludes: FileMask::new(&[], &call.project().search_excludes_in(&root)).ok(), root };
let marks = Marks {
root: call.root().to_path_buf(),
excludes: FileMask::new(&[], &call.project().search_excludes()).ok(),
};
// The directory itself, when it or one above it is left out.
let root_mark = marker(ide_index::walk_skips(call.root(), &dir), marks.ide_excluded(&dir, true));
let mut tree = TreeRender {
-2
Переглянути файл
@@ -16,8 +16,6 @@ mod search;
pub mod service;
mod symbols;
mod tool;
pub(crate) use tool::trusted_attachments;
mod util;
use crate::Host;
+4 -12
Переглянути файл
@@ -837,6 +837,8 @@ async fn file_search(call: Call) -> IdeResult<Output> {
.add(build_glob(&normalize_glob(&q, call.root(), &[])?)?)
.build()
.map_err(|_| IdeError::invalid(format!("Invalid glob pattern: {q}")))?;
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
let root = call.root().to_path_buf();
let content = call.project().content_roots();
// Where a folder's exclusions are matched from: the content root holding it, or the project.
@@ -860,15 +862,6 @@ async fn file_search(call: Call) -> IdeResult<Output> {
.map(|r| (r.clone(), r))
.collect(),
};
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag, by walked root.
let mut excludes = Vec::new();
if !include_excluded {
for (_, base) in &roots {
if !excludes.iter().any(|(b, _)| b == base) {
excludes.push((base.clone(), FileMask::new(&[], &call.project().search_excludes_in(base))?));
}
}
}
let host = call.host();
let walk = Walk {
host: host.clone(),
@@ -905,7 +898,7 @@ struct Walk {
window: String,
root: PathBuf,
include_excluded: bool,
excludes: Vec<(PathBuf, FileMask)>,
excludes: Option<FileMask>,
glob: GlobSet,
scope: PathScope,
limit: usize,
@@ -938,8 +931,7 @@ impl Walk {
continue;
}
let Ok(in_base) = entry.path.strip_prefix(base) else { continue };
let mask = self.excludes.iter().find(|(b, _)| b == base).map(|(_, m)| m);
if mask.is_some_and(|m| !m.matches(&in_base.to_string_lossy().replace('\\', "/"))) {
if self.excludes.as_ref().is_some_and(|m| !m.matches(&in_base.to_string_lossy().replace('\\', "/"))) {
continue;
}
match entry.kind {
+4 -6
Переглянути файл
@@ -65,7 +65,10 @@ impl Call {
}
/// The projects attached to this one that the user trusts (each is trusted on its own).
fn trusted_attachments(&self) -> Vec<PathBuf> {
trusted_attachments(&self.host.trust, self.root())
attached_projects(self.root())
.into_iter()
.filter(|root| self.host.trust.trusted(root).unwrap_or(false))
.collect()
}
pub async fn ask(&self, request: ide_core::event::McpUiRequest) -> IdeResult<()> {
self.host.mcp_requests.ask(self, request).await
@@ -324,11 +327,6 @@ pub fn ensure_inside(root: &Path, path: &Path) -> IdeResult<()> {
resolve_inside(root, &path.to_string_lossy()).map(|_| ())
}
/// The projects attached to the one at `root` that the user trusts (each is trusted on its own).
pub(crate) fn trusted_attachments(trust: &crate::trust::TrustStore, root: &Path) -> Vec<PathBuf> {
attached_projects(root).into_iter().filter(|p| trust.trusted(p).unwrap_or(false)).collect()
}
/// The projects attached to the one at `root` (its workspace members), `root` itself left out.
pub(crate) fn attached_projects(root: &Path) -> Vec<PathBuf> {
ide_workspace::workspace::Workspace::load(root)
+28 -177
Переглянути файл
@@ -8,9 +8,8 @@ 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, InstallRemoteSkillRequest, McpExternalSource, McpImportSelection,
McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask, RemoteSkillBrowseResult,
RemoteSkillPreview, SkillsPolicy,
CustomAgentInput, ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer,
McpServerInput, McpTransport, NewAgentTask, SkillsPolicy,
};
use ide_command::command;
use ide_core::error::ErrorKind;
@@ -1041,20 +1040,16 @@ pub fn agent_set_skill_overrides(
host.project(window)?.agents.set_skill_overrides(&task, overrides)
}
/// Every skill discovered in the project, the user's folders and enabled plugins, with
/// the mode a session runs it with (without any session's own 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).ok().filter(|p| !p.light);
let policy = host_skills_policy(host, project.as_deref());
let home = dirs::home_dir();
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_with_plugins(
&policy.workspace_roots,
home.as_deref(),
&policy.plugin_dirs,
),
ide_agent::skills::discover_skills(&root, home.as_deref()),
None,
&policy.workspace,
&policy.user,
@@ -1106,123 +1101,21 @@ pub fn agent_skills_set_mode(
}
}
}
let policy = host_skills_policy(host, project.as_deref());
let home = dirs::home_dir();
Ok(ide_agent::skills::resolve(
ide_agent::skills::discover_skills_with_plugins(&policy.workspace_roots, home.as_deref(), &policy.plugin_dirs),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
}
/// Resolves a GitHub `owner/repo[/path][@ref]` source and lists the `SKILL.md` skills in it.
#[command(trust = always)]
pub async fn agent_skills_browse(
host: &Host,
source: String,
request: RequestId,
) -> IdeResult<RemoteSkillBrowseResult> {
let cancel = host.begin_request(request);
let search_path = ide_core::tool_path::search_path();
let res = tokio::task::spawn_blocking(move || {
let fetcher = ide_agent::skill_installer::GitHubHttpFetcher::new(&search_path)?;
ide_agent::skill_installer::browse_skills(&fetcher, &source, &cancel)
})
.await
.map_err(join_err);
host.end_request(request);
res?
}
/// Fetches one skill's `SKILL.md`, file list, and static security scan warnings before installation.
#[command(trust = always)]
pub async fn agent_skills_preview(
host: &Host,
window: &str,
owner: String,
repo: String,
git_ref: String,
subpath: String,
request: RequestId,
) -> IdeResult<RemoteSkillPreview> {
let cancel = host.begin_request(request);
let ws_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let home = dirs::home_dir();
let search_path = ide_core::tool_path::search_path();
let res = tokio::task::spawn_blocking(move || {
let fetcher = ide_agent::skill_installer::GitHubHttpFetcher::new(&search_path)?;
ide_agent::skill_installer::preview_skill(
&fetcher,
ide_agent::skill_installer::RepoRef { owner: &owner, repo: &repo, git_ref: &git_ref },
&subpath,
home.as_deref(),
ws_root.as_deref(),
&cancel,
)
})
.await
.map_err(join_err);
host.end_request(request);
res?
}
/// Installs the selected skill subtree into `~/.agents/skills` (User) or `<workspace>/.agents/skills` (Workspace).
#[command(trust = always)]
pub async fn agent_skills_install(
host: &Host,
window: &str,
input: InstallRemoteSkillRequest,
request: RequestId,
) -> IdeResult<Vec<AgentSkillState>> {
let project = host.project(window).ok().filter(|p| !p.light);
if input.scope == McpScope::Workspace {
host.require_trust(window)?;
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()),
}
let ws_root = project.as_ref().map(|p| p.root.clone());
let home = dirs::home_dir();
let cancel = host.begin_request(request);
let search_path = ide_core::tool_path::search_path();
let install_home = home.clone();
let install_ws = ws_root.clone();
let res = tokio::task::spawn_blocking(move || {
let fetcher = ide_agent::skill_installer::GitHubHttpFetcher::new(&search_path)?;
ide_agent::skill_installer::install_skill(
&fetcher,
&input,
install_home.as_deref(),
install_ws.as_deref(),
&cancel,
)
})
.await
.map_err(join_err);
host.end_request(request);
res??;
let event = IdeEvent::SettingsChanged { key: "agents.skills".into() };
for p in host.projects() {
p.agents.notify_mcp_servers_changed();
p.sink.emit(event.clone());
}
let policy = host_skills_policy(host, project.as_deref());
tokio::task::spawn_blocking(move || {
Ok(ide_agent::skills::resolve(
ide_agent::skills::discover_skills_with_plugins(
&policy.workspace_roots,
home.as_deref(),
&policy.plugin_dirs,
),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
})
.await
.map_err(join_err)?
}
/// The user's and the workspace's skill policies (`[agents.skills.<name>]`).
@@ -1269,51 +1162,12 @@ fn persist_skills_map(
Ok(())
}
/// Workspace folders to scan for skills: the project root plus any multi-repo workspace members.
pub(crate) fn workspace_skill_roots(root: &std::path::Path) -> Vec<std::path::PathBuf> {
let mut roots = vec![root.to_path_buf()];
if let Ok(Some(ws)) = ide_workspace::workspace::Workspace::load(root) {
for member in ws.projects {
if member.exists() && !roots.contains(&member) {
roots.push(member);
}
}
}
roots
}
/// The skill policies a session of `project` (or global Settings without a project) resolves against.
fn host_skills_policy(host: &Host, project: Option<&crate::Project>) -> SkillsPolicy {
match project {
Some(project) => {
let workspace_trusted = project.trusted.load(std::sync::atomic::Ordering::Acquire);
let plugin_dirs = host
.plugin_host()
.map(|plugins| plugins.skill_dirs(Some(&project.root), workspace_trusted))
.unwrap_or_default();
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,
workspace_roots: workspace_skill_roots(&project.root),
plugin_dirs,
}
}
None => {
let plugin_dirs = host.plugin_host().map(|plugins| plugins.skill_dirs(None, true)).unwrap_or_default();
SkillsPolicy {
user: host.global_settings.effective().agents.skills.clone(),
workspace: Default::default(),
workspace_trusted: true,
workspace_roots: Vec::new(),
plugin_dirs,
}
}
/// 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),
}
}
@@ -1473,10 +1327,7 @@ ide_command::domain!(
agent_set_env,
agent_set_mcp_overrides,
agent_set_skill_overrides,
agent_skills_browse,
agent_skills_install,
agent_skills_list,
agent_skills_preview,
agent_skills_set_mode,
agent_stop_background,
agent_subscribe,
+4 -4
Переглянути файл
@@ -81,12 +81,12 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
/// Every Cucumber source of the project (its folder and the content roots outside it).
pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>> {
let project = host.project(window)?;
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()) {
let mut excludes = project.search_excludes_in(&root);
// 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());
out.extend(sources_in(&root, &excludes));
}
out.sort_by(|a, b| a.path.cmp(&b.path));
+2 -22
Переглянути файл
@@ -8,8 +8,8 @@ use ide_command::command;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_db::split::SqlStatement;
use ide_db::{
CompletionModel, DataSource, Databases, DbObjectKind, DbRowEdit, DbVisibilityChange, HistoryEntry, PlanNode,
QueryResult, SchemaObjects, SortKey, TableDetails, TableInfo, TablePage,
CompletionModel, DataSource, Databases, DbObjectKind, DbRowEdit, HistoryEntry, PlanNode, QueryResult,
SchemaObjects, SortKey, TableDetails, TableInfo, TablePage,
};
use serde::{Deserialize, Serialize};
use specta::Type;
@@ -72,25 +72,6 @@ pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>
// Replaces the project's data sources with `sources`.
let db = host.project(window)?.db.clone();
db.save_sources(sources).await?;
sources_changed(host, window)
}
#[command(trust = trusted)]
pub async fn db_save_source_visibility(
host: &Host,
window: &str,
id: String,
available: Vec<String>,
change: DbVisibilityChange,
) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
tokio::task::spawn_blocking(move || db.save_source_visibility(&id, &available, change))
.await
.map_err(|e| IdeError::internal(e.to_string()))??;
sources_changed(host, window)
}
fn sources_changed(host: &Host, window: &str) -> IdeResult<()> {
let root = host.project(window)?.root.clone();
for project in host.projects().into_iter().filter(|p| p.root == root) {
project.sink.emit(ide_core::IdeEvent::DbSourcesChanged);
@@ -622,7 +603,6 @@ ide_command::domain!(
db_object_ddl,
db_remove_history,
db_retain_catalog,
db_save_source_visibility,
db_save_sources,
db_saved_catalog,
db_schema_objects,
+2 -99
Переглянути файл
@@ -2,10 +2,7 @@
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
use ide_workspace::dependencies::{
DependencyVersionSource, DependencyVersions, PythonRequirements, UnsatisfiedRequirement, cargo, go, maven, npm,
python,
};
use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo, go, maven, npm};
use std::collections::BTreeMap;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::path::{Path, PathBuf};
@@ -257,50 +254,6 @@ pub async fn dependency_versions(
result
}
/// The requirements of a `requirements*.txt` / `pyproject.toml` the project's interpreter
/// doesn't satisfy; `None` for other files, or with no local interpreter to ask.
#[command(trust = trusted)]
pub async fn python_requirements(
host: &Host,
window: &str,
doc: DocId,
request: RequestId,
) -> IdeResult<Option<PythonRequirements>> {
let project = host.project(window)?;
let config_dir = host.config_dir.clone();
let cancel = host.begin_project_read_request(window, request);
let result = host
.blocking(move || {
let snap = project.documents.snapshot(doc)?;
let name = snap.path.file_name().and_then(|n| n.to_str()).unwrap_or_default();
if snap.large || snap.read_only {
return Ok(None);
}
let dependencies = python::requirements(name, &snap.text);
if dependencies.is_empty() {
return Ok(None);
}
// Running the interpreter runs project code (sitecustomize, .pth files).
project.require_trust()?;
let Some(python) = crate::ops::sdk::effective_python(&config_dir, &project, snap.path.parent()) else {
return Ok(None);
};
let requirements: Vec<&str> = dependencies.iter().map(|d| d.requirement.as_str()).collect();
let states = ide_sdk::python::unsatisfied_requirements(&python, &requirements, &cancel)?;
let unsatisfied = dependencies
.into_iter()
.zip(states)
.filter_map(|(dependency, state)| {
state.map(|s| UnsatisfiedRequirement { dependency, installed: s.installed })
})
.collect();
Ok(Some(PythonRequirements { python: python.into(), unsatisfied }))
})
.await;
host.end_request(request);
result
}
#[cfg(test)]
mod tests {
use super::*;
@@ -360,56 +313,6 @@ mod tests {
host.close_project("main");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn requirements_are_checked_against_the_project_virtualenv() {
let Some(base) = ide_core::tool_path::find_command(
"python3",
&ide_core::tool_path::search_path_in(&std::env::temp_dir()),
&std::env::temp_dir(),
) else {
return;
};
let temp = tempfile::tempdir().unwrap();
let base_dir = dunce::canonicalize(temp.path()).unwrap();
let root = base_dir.join("project");
std::fs::create_dir(&root).unwrap();
let status = std::process::Command::new(base)
.args(["-I", "-m", "venv", "--without-pip"])
.arg(root.join(".venv"))
.status()
.unwrap();
assert!(status.success());
let text = "# 中文\nopenidea-missing-xyz>=1\n-r other.txt\n";
let path = root.join("requirements.txt");
std::fs::write(&path, text).unwrap();
let host = Host::new(HostConfig {
config_dir: base_dir.join("config"),
data_dir: base_dir.join("data"),
local_data_dir: base_dir.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(|_| {})),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
let project = host.open_project("main", &root).unwrap();
let info = project.documents.open(&path).unwrap();
// Restricted Mode never runs the interpreter.
assert!(python_requirements(&host, "main", info.id, RequestId(429)).await.is_err());
project.trusted.store(true, std::sync::atomic::Ordering::Release);
let found = python_requirements(&host, "main", info.id, RequestId(430)).await.unwrap().unwrap();
assert!(found.python.0.starts_with(root.join(".venv")));
assert_eq!(found.unsatisfied.len(), 1);
assert_eq!(found.unsatisfied[0].dependency.package, "openidea-missing-xyz");
assert_eq!(found.unsatisfied[0].installed, None);
let other = root.join("notes.txt");
std::fs::write(&other, text).unwrap();
let info = project.documents.open(&other).unwrap();
assert!(python_requirements(&host, "main", info.id, RequestId(431)).await.unwrap().is_none());
host.close_project("main");
}
struct CachedNpm;
impl DependencyVersionSource for CachedNpm {
fn id(&self) -> &'static str {
@@ -458,4 +361,4 @@ mod tests {
}
}
ide_command::domain!(dependencies: dependency_versions, python_requirements);
ide_command::domain!(dependencies: dependency_versions);
+49 -128
Переглянути файл
@@ -1,5 +1,5 @@
use super::Channel;
use crate::{Host, Project};
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_vfs::FileEntry;
@@ -21,7 +21,6 @@ pub async fn fs_compare_directories(
window: &str,
left: PathBuf,
right: PathBuf,
mode: ide_vfs::DirectoryCompareMode,
request: RequestId,
on_progress: Channel<ide_vfs::DirectoryCompareProgress>,
) -> IdeResult<Vec<ide_vfs::DirectoryCompareEntry>> {
@@ -30,58 +29,19 @@ pub async fn fs_compare_directories(
let result = host
.blocking(move || {
let last = std::cell::Cell::new(std::time::Instant::now() - std::time::Duration::from_secs(1));
ide_vfs::compare_directories(
&left,
&right,
mode,
Some(&project.root),
&project.exclude_globs(),
&cancel,
|p| {
// Bound IPC traffic even when hashing multi-gigabyte files.
if last.get().elapsed() >= std::time::Duration::from_millis(80) || p.total == Some(p.compared) {
let _ = on_progress.send(p);
last.set(std::time::Instant::now());
}
},
)
ide_vfs::compare_directories(&left, &right, Some(&project.root), &project.exclude_globs(), &cancel, |p| {
// Bound IPC traffic even when hashing multi-gigabyte files.
if last.get().elapsed() >= std::time::Duration::from_millis(80) || p.total == Some(p.compared) {
let _ = on_progress.send(p);
last.set(std::time::Instant::now());
}
})
})
.await;
host.end_request(request);
result
}
fn comparison_entry_path(path: &Path) -> IdeResult<()> {
if path.as_os_str().is_empty() || path.components().any(|c| !matches!(c, std::path::Component::Normal(_))) {
return Err(IdeError::invalid("expected a relative comparison entry path"));
}
Ok(())
}
fn copy_entry(
project: &Project,
source_root: &Path,
destination_root: &Path,
path: &Path,
overwrite: bool,
) -> IdeResult<()> {
let from = source_root.join(path);
let to = destination_root.join(path);
if overwrite {
project.history.record_deletion(&to, DELETE_SNAPSHOT_LIMIT);
}
project.with_disk_sync(|| {
ide_vfs::copy_merge(
&from,
&to,
overwrite,
Some(&project.root),
&project.exclude_globs(),
(source_root, destination_root),
)
})
}
#[command(trust = always)]
pub async fn fs_copy_merge(
host: &Host,
@@ -91,63 +51,28 @@ pub async fn fs_copy_merge(
path: PathBuf,
overwrite: bool,
) -> IdeResult<()> {
comparison_entry_path(&path)?;
let project = host.project(window)?;
host.blocking(move || copy_entry(&project, &source_root, &destination_root, &path, overwrite)).await
}
/// Runs Compare Directories' synchronisation operations in order. A failed operation is
/// reported and the rest still run; cancellation stops before the next one.
#[command(trust = always)]
pub async fn fs_synchronize_directories(
host: &Host,
window: &str,
left: PathBuf,
right: PathBuf,
operations: Vec<ide_vfs::DirectorySyncOperation>,
request: RequestId,
on_progress: Channel<ide_vfs::DirectorySyncProgress>,
) -> IdeResult<Vec<ide_vfs::DirectorySyncFailure>> {
for op in &operations {
comparison_entry_path(Path::new(&op.path))?;
if path.as_os_str().is_empty() || path.components().any(|c| !matches!(c, std::path::Component::Normal(_))) {
return Err(ide_core::IdeError::invalid("expected a relative comparison entry path"));
}
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = host
.blocking(move || {
use ide_vfs::DirectorySyncAction::*;
let total = operations.len() as u32;
let mut failures = Vec::new();
for (done, op) in operations.into_iter().enumerate() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let _ = on_progress.send(ide_vfs::DirectorySyncProgress {
done: done as u32,
total,
path: op.path.clone(),
});
let path = Path::new(&op.path);
let result = match op.action {
CopyToLeft => copy_entry(&project, &right, &left, path, op.overwrite),
CopyToRight => copy_entry(&project, &left, &right, path, op.overwrite),
DeleteLeft => delete_recorded(Some(&project), &left.join(path), false).map(|_| ()),
DeleteRight => delete_recorded(Some(&project), &right.join(path), false).map(|_| ()),
};
if let Err(e) = result {
failures.push(ide_vfs::DirectorySyncFailure {
path: op.path,
action: op.action,
message: e.message,
});
}
}
let _ = on_progress.send(ide_vfs::DirectorySyncProgress { done: total, total, path: String::new() });
Ok(failures)
host.blocking(move || {
let from = source_root.join(&path);
let to = destination_root.join(&path);
if overwrite {
project.history.record_deletion(&to, DELETE_SNAPSHOT_LIMIT);
}
project.with_disk_sync(|| {
ide_vfs::copy_merge(
&from,
&to,
overwrite,
Some(&project.root),
&project.exclude_globs(),
(&source_root, &destination_root),
)
})
.await;
host.end_request(request);
result
})
.await
}
/// Files of a deleted folder snapshotted in Local History.
@@ -160,13 +85,11 @@ pub async fn fs_read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<
host.blocking(move || {
let excludes = project
.map(|p| {
// An attached project's folders follow its own exclusions.
let root = p.root_of(&path);
let globs = p.exclude_globs_in(&root);
let globs = p.exclude_globs();
// `read_dir` matches relative to the enclosing repository: re-anchor
// root patterns (`/build`) when the project is a repo subfolder.
let repo = root.ancestors().find(|d| d.join(".git").exists());
match repo.and_then(|r| root.strip_prefix(r).ok()).filter(|rel| !rel.as_os_str().is_empty()) {
// project-root patterns (`/build`) when the project is a repo subfolder.
let repo = p.root.ancestors().find(|d| d.join(".git").exists());
match repo.and_then(|r| p.root.strip_prefix(r).ok()).filter(|rel| !rel.as_os_str().is_empty()) {
Some(rel) => {
let rel = rel.to_string_lossy().replace('\\', "/");
globs.into_iter().map(|g| if g.starts_with('/') { format!("/{rel}{g}") } else { g }).collect()
@@ -252,27 +175,26 @@ pub async fn fs_delete_with_undo(host: &Host, window: &str, path: PathBuf) -> Id
async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable: bool) -> IdeResult<DeletionUndo> {
let project = if undoable { Some(host.project(window)?) } else { host.project(window).ok() };
host.blocking(move || delete_recorded(project.as_deref(), &path, undoable)).await
}
fn delete_recorded(project: Option<&Project>, path: &Path, undoable: bool) -> IdeResult<DeletionUndo> {
let paths = ide_workspace::file_ops::deletion_paths(path)?;
let mut undo = DeletionUndo::default();
if let Some(p) = project {
if undoable {
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
} else {
for pth in &paths {
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
host.blocking(move || {
let paths = ide_workspace::file_ops::deletion_paths(&path)?;
let mut undo = DeletionUndo::default();
if let Some(p) = &project {
if undoable {
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
} else {
for pth in &paths {
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
}
}
}
}
ide_workspace::file_ops::delete(path)?;
// A checkout backend opens the paths for delete; Git's hook is a no-op.
if let Some(p) = project {
let _ = p.with_backend_of(path, |r| r.files_deleted(&paths));
}
Ok(undo)
ide_workspace::file_ops::delete(&path)?;
// A checkout backend opens the paths for delete; Git's hook is a no-op.
if let Some(p) = project {
let _ = p.with_backend_of(&path, |r| r.files_deleted(&paths));
}
Ok(undo)
})
.await
}
#[command(trust = always)]
@@ -384,6 +306,5 @@ ide_command::domain!(
fs_read_text,
fs_rename,
fs_set_writable,
fs_synchronize_directories,
fs_undo_delete,
);
+3 -90
Переглянути файл
@@ -50,7 +50,6 @@ pub(crate) async fn resolve_launch(
if !project.lsp.java_served_by_jdtls(&module) {
return resolve_launch_without_jdtls(host, &project, module, test, policy, cancel).await;
}
let waiting = project.java_launches_waiting.add(module.clone(), test, policy);
let settings = project.settings.effective();
// A launch builds incrementally unless the configuration asks for Rebuild or NoBuild.
let build = policy != BuildPolicy::NoBuild;
@@ -99,12 +98,6 @@ pub(crate) async fn resolve_launch(
drop_processor_recreate_errors(&mut info);
}
}
let model = std::sync::Arc::new(model);
let members = if delegated {
build_members(&project, &model, &module, test, prefer_maven, &waiting, cancel).await?
} else {
Vec::new()
};
let lsp_ms = started.elapsed().as_millis();
let data_dir = host.local_data_dir.clone();
let cancel = cancel.clone();
@@ -113,20 +106,16 @@ pub(crate) async fn resolve_launch(
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
// Module outputs the launch runs from a snapshot of: the originals must not come back.
let mut snapshotted = Vec::new();
// The modules of the launches sharing this build also share its classpath probe.
let probed: Vec<PathBuf> =
std::iter::once(module.clone()).chain(members.iter().map(|m| m.module.clone())).collect();
let built = if delegated {
let rebuild_on_jdt_errors = rebuild_on_jdt_errors(policy, prefer_maven, info.error_count);
let outputs = project.java_launch_snapshots.lock().build(
&project.root,
&model,
&module,
cache::BuildOptions { test, policy, rebuild_on_jdt_errors, members },
cache::BuildOptions { test, policy, rebuild_on_jdt_errors },
local_repo.clone(),
&cancel,
)?;
drop(waiting);
let copies = use_snapshot(&mut info, &outputs.originals, &outputs.snapshot);
apply_external_build_result(&mut info, outputs.failure, outputs.authoritative);
snapshotted = outputs.originals;
@@ -149,10 +138,10 @@ pub(crate) async fn resolve_launch(
// m2e runs inside jdtls on the server JDK and can resolve a different
// Maven profile/classifier than the module build. Ask the same Maven
// process that built the module for its runtime/test dependencies.
let maven_cp = compile::module_classpaths(
let maven_cp = compile::module_classpath(
&project.root,
&model,
&probed,
&module,
test,
local_repo,
&project.build_cache_dir(),
@@ -441,82 +430,6 @@ fn apply_library_classpath(
}
/// Whether a launch should be built by the project's build system instead of jdtls.
/// The launches waiting for their build that join this launch's Maven run, each with
/// whether its JDT errors call for a clean rebuild (as its own launch would decide).
async fn build_members(
project: &std::sync::Arc<crate::Project>,
model: &std::sync::Arc<BuildModel>,
module: &Path,
test: bool,
prefer_maven: bool,
waiting: &cache::WaitingGuard,
cancel: &CancellationToken,
) -> IdeResult<Vec<cache::Member>> {
let others: Vec<_> = waiting.others().into_iter().filter(|o| project.lsp.java_served_by_jdtls(&o.module)).collect();
if others.is_empty() {
return Ok(Vec::new());
}
let joining = {
let (project, model, module) = (project.clone(), model.clone(), module.to_path_buf());
tokio::task::spawn_blocking(move || {
joining_launches(&project.root, &project.build_cache_dir(), &model, &module, test, others, prefer_maven)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
};
let mut members = Vec::new();
for launch in joining {
// The build lock is held: the member's own launch reads the same diagnostics afterwards.
let errors = match project.lsp.java_launch(&launch.module, test, false, false, true, cancel).await {
Ok(info) => info.error_count,
Err(e) if e.kind == ErrorKind::Cancelled => return Err(e),
Err(e) => {
tracing::debug!(module = %launch.module.display(), "Not joining the launch build: {e}");
continue;
}
};
members.push(cache::Member {
module: launch.module.clone(),
rebuild_on_jdt_errors: rebuild_on_jdt_errors(launch.policy, prefer_maven, errors),
});
}
Ok(members)
}
/// Waiting launches that can share the Maven build of the launch of `module`: an
/// incremental build (Rebuild and "no error check" launches keep their own) of the same
/// scope, of another module of the same Maven reactor, delegated to Maven as this one is.
fn joining_launches(
root: &Path,
cache_dir: &Path,
model: &BuildModel,
module: &Path,
test: bool,
others: Vec<std::sync::Arc<cache::WaitingLaunch>>,
prefer_maven: bool,
) -> Vec<std::sync::Arc<cache::WaitingLaunch>> {
let Some(reactor) = compile::launch_reactor(root, model, module) else { return Vec::new() };
let mut seen = std::collections::HashSet::from([module.to_path_buf()]);
others
.into_iter()
.filter(|o| {
let is_maven =
model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| root.join(&p.dir) == o.module));
o.test == test
&& matches!(o.policy, BuildPolicy::Automatic | BuildPolicy::Make)
&& compile::launch_reactor(root, model, &o.module).as_ref() == Some(&reactor)
&& seen.insert(o.module.clone())
&& delegates_to_external_build(
is_maven,
o.policy,
compile::launch_has_non_java_sources(root, model, &o.module, test),
cache::has_record(root, cache_dir, &o.module),
prefer_maven,
)
})
.collect()
}
/// A Rebuild has to clean the output; jdtls' full build only recompiles sources, so
/// Maven modules always delegate for it, even when every source is Java.
/// `prefer_maven` is Settings › Maven › Delegate IDE build/run actions to Maven.
+53 -310
Переглянути файл
@@ -2,12 +2,10 @@
use ide_build::compile::{self, LaunchFingerprint};
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_run::BuildPolicy;
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use std::collections::HashSet;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
#[derive(Debug, Serialize, Deserialize)]
pub(super) struct Outputs {
@@ -51,64 +49,6 @@ pub(super) struct BuildOptions {
/// A JDT error makes a cache miss rebuild, but it must not prevent an unchanged
/// snapshot from being reused on the next launch.
pub rebuild_on_jdt_errors: bool,
/// Other launches of the same reactor waiting for their build (configurations started
/// together, #3971): their modules join this Maven run, and their launches then reuse
/// the snapshots recorded here instead of running Maven again.
pub members: Vec<Member>,
}
/// A launch module joining another launch's build; see [`BuildOptions::members`].
#[derive(Debug)]
pub(super) struct Member {
pub module: PathBuf,
pub rebuild_on_jdt_errors: bool,
}
/// Java launches from their start until their build: one launch's Maven run also builds
/// the modules of launches still waiting (configurations started together, #3971).
#[derive(Default)]
pub(crate) struct Waiting(Arc<Mutex<Vec<Arc<WaitingLaunch>>>>);
#[derive(Debug)]
pub(super) struct WaitingLaunch {
pub module: PathBuf,
pub test: bool,
pub policy: BuildPolicy,
}
/// Leaves [`Waiting`] when dropped.
pub(super) struct WaitingGuard {
all: Arc<Mutex<Vec<Arc<WaitingLaunch>>>>,
launch: Arc<WaitingLaunch>,
}
impl Waiting {
pub(super) fn add(&self, module: PathBuf, test: bool, policy: BuildPolicy) -> WaitingGuard {
let launch = Arc::new(WaitingLaunch { module, test, policy });
self.0.lock().push(launch.clone());
WaitingGuard { all: self.0.clone(), launch }
}
}
impl WaitingGuard {
/// The other launches still waiting, in the order they started.
pub(super) fn others(&self) -> Vec<Arc<WaitingLaunch>> {
self.all.lock().iter().filter(|l| !Arc::ptr_eq(l, &self.launch)).cloned().collect()
}
}
impl Drop for WaitingGuard {
fn drop(&mut self) {
self.all.lock().retain(|l| !Arc::ptr_eq(l, &self.launch));
}
}
/// A module whose launch snapshot can't be reused, ready to build.
struct Pending {
module: PathBuf,
record: PathBuf,
before: Option<LaunchFingerprint>,
previous: Option<Outputs>,
}
/// Owned by Project: running JVMs may still load superseded outputs until it drops.
@@ -116,14 +56,11 @@ pub(crate) struct Session {
cache: PathBuf,
initialized: bool,
unreferenced: Vec<PathBuf>,
/// A shared build that failed for a member, by (module, test): the member's own launch
/// reports it instead of running the same failing build again while its inputs are unchanged.
failed: HashMap<(PathBuf, bool), (LaunchFingerprint, String)>,
}
impl Session {
pub(crate) fn new(cache: PathBuf) -> Self {
Self { cache, initialized: false, unreferenced: Vec::new(), failed: HashMap::new() }
Self { cache, initialized: false, unreferenced: Vec::new() }
}
pub(super) fn initialize(&mut self) {
@@ -145,84 +82,20 @@ impl Session {
cancel: &CancellationToken,
) -> IdeResult<Outputs> {
self.initialize();
let BuildOptions { test, policy, rebuild_on_jdt_errors, members } = options;
let mut lead = match self.prepare(root, model, module, test, policy, &local_repo, cancel)? {
Ok(outputs) => return Ok(outputs),
Err(pending) => pending,
};
if let Some((fingerprint, failure)) = self.failed.remove(&(module.to_path_buf(), test))
&& lead.before.as_ref() == Some(&fingerprint)
&& matches!(policy, BuildPolicy::Automatic | BuildPolicy::Make)
{
tracing::info!(module = %module.display(), "The shared Maven launch build failed for these inputs");
return Err(IdeError::internal(failure));
}
// JDT can report errors from its own classpath while the last Maven snapshot is
// still valid. Reuse that snapshot first; only a cache miss needs the expensive
// clean rebuild that replaces JDT's error-stub classes.
let policy = if rebuild_on_jdt_errors { BuildPolicy::Rebuild } else { policy };
let mut joined = Vec::new();
let mut rebuild = policy == BuildPolicy::Rebuild;
for member in members {
if let Err(pending) =
self.prepare(root, model, &member.module, test, BuildPolicy::Make, &local_repo, cancel)?
{
rebuild |= member.rebuild_on_jdt_errors;
joined.push(pending);
}
}
let modules: Vec<PathBuf> =
std::iter::once(&lead).chain(&joined).map(|pending| pending.module.clone()).collect();
if modules.len() > 1 {
tracing::info!(?modules, "Building the launch modules in one Maven run");
}
let kind = if rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
let mut built = compile::build_for_launches(root, model, &modules, test, kind, cancel)?.into_iter();
let lead_built = built.next().unwrap();
for (pending, built) in joined.into_iter().zip(built) {
match built.failure {
Some(failure) => {
if let Some(before) = pending.before {
self.failed.insert((pending.module, test), (before, failure));
}
}
None => {
self.finish(root, model, pending, test, built.class_dirs, None, rebuild, &local_repo, cancel)?;
}
}
}
if let Some(failure) = &lead_built.failure {
if policy != BuildPolicy::MakeAndContinueOnErrors {
return Err(IdeError::internal(failure.clone()));
}
if let Some(mut previous) =
lead.previous.take().filter(|p| (0..p.originals.len()).all(|i| p.snapshot.join(i.to_string()).is_dir()))
{
previous.fingerprint = None;
previous.failure = lead_built.failure;
write_record(&lead.record, &previous)?;
return Ok(previous);
}
}
self.finish(root, model, lead, test, lead_built.class_dirs, lead_built.failure, rebuild, &local_repo, cancel)
}
/// The reusable snapshot of `module` (`Ok`), else the module marked for a build (`Err`).
#[allow(clippy::too_many_arguments)]
fn prepare(
&mut self,
root: &Path,
model: &ide_build::BuildModel,
module: &Path,
test: bool,
policy: BuildPolicy,
local_repo: &Option<PathBuf>,
cancel: &CancellationToken,
) -> IdeResult<Result<Outputs, Pending>> {
let BuildOptions { test, policy, rebuild_on_jdt_errors } = options;
let cache = &self.cache;
let record =
record_path(root, &self.cache, module, test).ok_or_else(|| IdeError::internal("launch outside project"))?;
let snapshots = self.cache.join("java-launch/snapshots");
let mut before = fingerprint(root, model, module, test, local_repo, cancel)?;
record_path(root, cache, module, test).ok_or_else(|| IdeError::internal("launch outside project"))?;
let snapshots = cache.join("java-launch/snapshots");
let fingerprint = || match compile::launch_fingerprint(root, model, module, test, local_repo.clone(), cancel) {
Ok(value) => Ok(value),
Err(e) if cancel.is_cancelled() => Err(e),
Err(e) => {
tracing::debug!(error = %e, "Cannot fingerprint Maven launch; rebuilding");
Ok(None)
}
};
let mut before = fingerprint()?;
let previous = fs::read(&record).ok().and_then(|bytes| serde_json::from_slice::<Outputs>(&bytes).ok());
// Timestamp-incremental builders (Maven, the Kotlin plugin) skip sources whose
// mtime did not advance. An external edit that preserves both length and mtime
@@ -242,7 +115,7 @@ impl Session {
tracing::debug!(path = %path.display(), %error, "Cannot re-stamp externally edited source");
}
}
before = fingerprint(root, model, module, test, local_repo, cancel)?;
before = fingerprint()?;
}
if let Some(outputs) = previous.as_ref()
&& policy != BuildPolicy::Rebuild
@@ -251,8 +124,12 @@ impl Session {
tracing::info!(module = %module.display(), test, "Reusing Maven launch snapshot");
let mut outputs = previous.unwrap();
outputs.authoritative = true;
return Ok(Ok(outputs));
return Ok(outputs);
}
// JDT can report errors from its own classpath while the last Maven snapshot is
// still valid. Reuse that snapshot first; only a cache miss needs the expensive
// clean rebuild that replaces JDT's error-stub classes.
let policy = if rebuild_on_jdt_errors { BuildPolicy::Rebuild } else { policy };
// Retain a non-reusable record even on failure, so removing the final mixed
// source still delegates to Maven to clean its old classes on the next launch.
fs::create_dir_all(record.parent().unwrap())?;
@@ -260,25 +137,24 @@ impl Session {
if let Some(previous) = &previous {
self.unreferenced.push(previous.snapshot.clone());
}
Ok(Err(Pending { module: module.to_path_buf(), record, before, previous }))
}
/// Copies the built outputs of a prepared module into a new snapshot and records it
/// when the build succeeded on inputs that did not change meanwhile.
#[allow(clippy::too_many_arguments)]
fn finish(
&mut self,
root: &Path,
model: &ide_build::BuildModel,
pending: Pending,
test: bool,
originals: Vec<PathBuf>,
failure: Option<String>,
authoritative: bool,
local_repo: &Option<PathBuf>,
cancel: &CancellationToken,
) -> IdeResult<Outputs> {
let snapshots = self.cache.join("java-launch/snapshots");
let kind = if policy == BuildPolicy::Rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
let built = compile::build_for_launch(root, model, module, test, kind, cancel)?;
if let Some(failure) = &built.failure {
if policy != BuildPolicy::MakeAndContinueOnErrors {
return Err(IdeError::internal(failure.clone()));
}
if let Some(mut previous) =
previous.filter(|p| (0..p.originals.len()).all(|i| p.snapshot.join(i.to_string()).is_dir()))
{
previous.fingerprint = None;
previous.failure = built.failure;
let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;
serde_json::to_writer(file.as_file_mut(), &previous).map_err(|e| IdeError::internal(e.to_string()))?;
file.persist(&record).map_err(|e| IdeError::from(e.error))?;
return Ok(previous);
}
}
let originals = built.class_dirs;
fs::create_dir_all(&snapshots)?;
let snapshot = tempfile::Builder::new().prefix("launch-").tempdir_in(&snapshots)?.keep();
// Retain every new snapshot even if copying or publishing its record fails.
@@ -289,46 +165,29 @@ impl Session {
}
ide_vfs::copy(source, &snapshot.join(i.to_string()))?;
}
let after = fingerprint(root, model, &pending.module, test, local_repo, cancel)?;
let after = fingerprint()?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let mut outputs = Outputs { fingerprint: None, snapshot, originals, failure, authoritative };
if outputs.failure.is_none() && pending.before.is_some() && pending.before == after {
outputs.fingerprint = pending.before;
write_record(&pending.record, &outputs)?;
let mut outputs = Outputs {
fingerprint: None,
snapshot,
originals,
failure: built.failure,
authoritative: policy == BuildPolicy::Rebuild,
};
if outputs.failure.is_none() && before.is_some() && before == after {
outputs.fingerprint = before;
fs::create_dir_all(record.parent().unwrap())?;
let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;
serde_json::to_writer(file.as_file_mut(), &outputs).map_err(|e| IdeError::internal(e.to_string()))?;
file.persist(&record).map_err(|e| IdeError::from(e.error))?;
self.unreferenced.retain(|path| path != &outputs.snapshot);
}
Ok(outputs)
}
}
fn fingerprint(
root: &Path,
model: &ide_build::BuildModel,
module: &Path,
test: bool,
local_repo: &Option<PathBuf>,
cancel: &CancellationToken,
) -> IdeResult<Option<LaunchFingerprint>> {
match compile::launch_fingerprint(root, model, module, test, local_repo.clone(), cancel) {
Ok(value) => Ok(value),
Err(e) if cancel.is_cancelled() => Err(e),
Err(e) => {
tracing::debug!(error = %e, "Cannot fingerprint Maven launch; rebuilding");
Ok(None)
}
}
}
fn write_record(record: &Path, outputs: &Outputs) -> IdeResult<()> {
fs::create_dir_all(record.parent().unwrap())?;
let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;
serde_json::to_writer(file.as_file_mut(), outputs).map_err(|e| IdeError::internal(e.to_string()))?;
file.persist(record).map_err(|e| IdeError::from(e.error))?;
Ok(())
}
impl Drop for Session {
fn drop(&mut self) {
// Recheck all records: another module or launch mode may reference a path.
@@ -414,122 +273,6 @@ mod tests {
ide_build::load(root, &root.join("cache"), None)
}
/// A reactor of `lib` and the applications `a` and `b` depending on it; the build script
/// compiles every module and logs its arguments.
fn reactor_fixture(root: &Path) -> ide_build::BuildModel {
let pom = |artifact: &str, extra: &str| {
format!(
"<project><groupId>demo</groupId><artifactId>{artifact}</artifactId><version>1</version>{extra}</project>"
)
};
fs::write(
root.join("pom.xml"),
pom(
"root",
"<packaging>pom</packaging><modules><module>lib</module><module>a</module><module>b</module></modules>",
),
)
.unwrap();
let lib = "<dependencies><dependency><groupId>demo</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>";
for (module, extra) in [("lib", ""), ("a", lib), ("b", lib), ("other", "")] {
fs::create_dir_all(root.join(module).join("src/main/java")).unwrap();
fs::write(root.join(module).join("pom.xml"), pom(module, extra)).unwrap();
fs::write(root.join(module).join("src/main/java/Main.java"), module).unwrap();
}
let script = root.join("mvnw");
fs::write(&script, "#!/bin/sh\necho build \"$@\" >> calls\nif [ -f broken ]; then exit 1; fi\nfor m in lib a b; do mkdir -p $m/target/classes; cp $m/src/main/java/Main.java $m/target/classes/Main.class; done\n").unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
ide_build::load(root, &root.join("cache"), None)
}
fn calls(root: &Path) -> Vec<String> {
fs::read_to_string(root.join("calls")).unwrap_or_default().lines().map(str::to_owned).collect()
}
#[test]
fn waiting_launches_of_one_reactor_share_one_maven_build() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = reactor_fixture(root);
let cancel = CancellationToken::new();
let mut session = Session::new(root.join("cache"));
let (a, b) = (root.join("a"), root.join("b"));
let with = |rebuild_on_jdt_errors: bool| BuildOptions {
members: vec![Member { module: b.clone(), rebuild_on_jdt_errors }],
..Default::default()
};
let lead = session.build(root, &model, &a, with(false), None, &cancel).unwrap();
assert_eq!(fs::read_to_string(lead.snapshot.join("0/Main.class")).unwrap(), "a");
assert_eq!(fs::read_to_string(lead.snapshot.join("1/Main.class")).unwrap(), "lib");
// b's own launch runs from the snapshot the shared build recorded for it.
let member = session.build(root, &model, &b, BuildOptions::default(), None, &cancel).unwrap();
assert!(member.authoritative);
assert_eq!(fs::read_to_string(member.snapshot.join("0/Main.class")).unwrap(), "b");
assert_eq!(calls(root).len(), 1);
assert!(calls(root)[0].contains("-pl a,b -am") && calls(root)[0].ends_with(" compile"), "{:?}", calls(root));
// A member whose JDT errors call for a clean build makes the shared build a rebuild.
fs::write(root.join("lib/src/main/java/Main.java"), "lib 2").unwrap();
session.build(root, &model, &a, with(true), None, &cancel).unwrap();
assert!(calls(root)[1].contains("-pl a,b -am clean compile"), "{:?}", calls(root));
let member = session.build(root, &model, &b, BuildOptions::default(), None, &cancel).unwrap();
assert_eq!(fs::read_to_string(member.snapshot.join("1/Main.class")).unwrap(), "lib 2");
assert_eq!(calls(root).len(), 2);
// A failed shared build fails the member's launch without running Maven again,
// once: unchanged inputs built on their own afterwards fail in their own build.
fs::write(root.join("lib/src/main/java/Main.java"), "lib 3").unwrap();
fs::write(root.join("broken"), "").unwrap();
assert!(session.build(root, &model, &a, with(false), None, &cancel).is_err());
let failure = session.build(root, &model, &b, BuildOptions::default(), None, &cancel).unwrap_err();
assert!(failure.message.contains("Build failed"), "{failure:?}");
assert_eq!(calls(root).len(), 3);
assert!(session.build(root, &model, &b, BuildOptions::default(), None, &cancel).is_err());
assert_eq!(calls(root).len(), 4);
assert!(calls(root)[3].contains("-pl b -am"));
// With nothing waiting, a launch builds just its own module, as before.
fs::remove_file(root.join("broken")).unwrap();
session.build(root, &model, &a, BuildOptions::default(), None, &cancel).unwrap();
assert!(calls(root)[4].contains("-pl a -am compile"), "{:?}", calls(root));
}
#[test]
fn only_incremental_launches_of_the_same_reactor_and_scope_join_a_build() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = reactor_fixture(root);
let waiting = Waiting::default();
let lead = waiting.add(root.join("a"), false, BuildPolicy::Automatic);
let _guards = [
waiting.add(root.join("b"), false, BuildPolicy::Make),
waiting.add(root.join("lib"), false, BuildPolicy::Automatic),
waiting.add(root.join("b"), false, BuildPolicy::Automatic),
waiting.add(root.join("a"), false, BuildPolicy::Automatic),
waiting.add(root.join("lib"), true, BuildPolicy::Automatic),
waiting.add(root.join("lib"), false, BuildPolicy::Rebuild),
waiting.add(root.join("lib"), false, BuildPolicy::MakeAndContinueOnErrors),
waiting.add(root.join("lib"), false, BuildPolicy::NoBuild),
waiting.add(root.join("other"), false, BuildPolicy::Automatic),
];
let join = |prefer_maven| {
super::super::joining_launches(
root,
&root.join("cache"),
&model,
&root.join("a"),
false,
lead.others(),
prefer_maven,
)
.into_iter()
.map(|l| l.module.strip_prefix(root).unwrap().to_path_buf())
.collect::<Vec<_>>()
};
assert_eq!(join(true), [PathBuf::from("b"), PathBuf::from("lib")]);
// Without "Delegate to Maven", these Java-only modules build with the language server.
assert!(join(false).is_empty());
drop(_guards);
assert!(lead.others().is_empty());
}
/// Like [`fixture`], but the build script skips sources whose mtime did not advance,
/// mirroring Maven's (and the Kotlin plugin's) timestamp-incremental compilation.
fn fixture_timestamp_incremental(root: &Path) -> ide_build::BuildModel {
+1 -2
Переглянути файл
@@ -1092,8 +1092,7 @@ pub async fn lsp_resolve_code_action(
#[command(trust = trusted)]
pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action: CodeAction) -> IdeResult<()> {
let project = host.project(window)?;
// A lazy action may carry a follow-up command beside its unresolved edit (vtsls' refactorings).
let action = if action.edit.is_none() && (action.command.is_none() || action.data.is_some()) {
let action = if action.edit.is_none() && action.command.is_none() {
let documents = project.documents.clone();
let version = blocking(move || documents.version(doc)).await?;
let action = resolve_action(host, window, doc, action).await?;
+1 -74
Переглянути файл
@@ -128,70 +128,6 @@ pub fn project_roots(host: &Host, window: &str) -> IdeResult<ide_workspace::Proj
Ok(host.project(window)?.roots())
}
/// A project attached to the window's project, with its own Project Structure.
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceMember {
pub root: ide_core::IpcPath,
/// Its project settings' Project Structure (not merged with the user settings).
pub structure: ide_core::settings::ProjectStructureSettings,
/// Roots detected from its build files.
pub detected: Vec<ide_workspace::SourceFolder>,
}
/// The workspace projects outside the window's project folder, for Mark Directory as there.
#[command(trust = always)]
pub fn project_workspace_members(host: &Host, window: &str) -> IdeResult<Vec<WorkspaceMember>> {
let project = host.project(window)?;
Ok(project
.attached_roots()
.into_iter()
.map(|root| WorkspaceMember {
structure: project.settings.for_project(&root).layer(SettingsScope::Project).project_structure,
detected: ide_workspace::roots::detect(&root),
root: root.into(),
})
.collect())
}
/// Sets a `projectStructure.*` key in the settings of `root`, a project attached to the window's
/// project (Mark Directory as there). Every open window holding that project follows.
#[command(trust = always)]
pub fn project_workspace_member_set(
host: &Arc<Host>,
window: &str,
root: PathBuf,
key: String,
value: String,
) -> IdeResult<()> {
let project = host.project(window)?;
if !project.attached_roots().contains(&root) {
return Err(ide_core::IdeError::invalid("Not a project attached to this one"));
}
if !key.starts_with("projectStructure.") {
return Err(ide_core::IdeError::invalid(format!("{key} is not a Project Structure setting")));
}
let value: serde_json::Value =
serde_json::from_str(&value).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
project.settings.for_project(&root).set(SettingsScope::Project, &key, value)?;
let affected: Vec<_> = host
.projects()
.into_iter()
.filter(|p| p.root == root || p.member_excludes.read().contains_key(&root))
.collect();
host.runtime.spawn_blocking(move || {
for p in affected {
if p.root == root {
p.settings.reload();
p.sink.emit(IdeEvent::SettingsChanged { key: key.clone() });
}
p.refresh_index_scope();
p.sink.emit(IdeEvent::ProjectRootsChanged { root: p.root.clone().into() });
}
});
Ok(())
}
#[command(trust = always)]
pub fn cancel_request(host: &Host, id: RequestId) {
host.cancel_request(id);
@@ -442,14 +378,7 @@ pub fn set_settings(
// Content roots and excludes (files.exclude, ignored names, excluded folders) reach the
// index and the watchers without reopening the project (the rescan runs in the background).
if roots_changed || key == "files" || key.starts_with("files.") {
let mut affected = affected();
// A workspace open in another window may hold this project: its excluded folders apply there.
if roots_changed
&& project_scope
&& let Some(own) = &current
{
affected.extend(host.projects().into_iter().filter(|p| p.member_excludes.read().contains_key(&own.root)));
}
let affected = affected();
host.runtime.spawn_blocking(move || {
for project in affected {
project.refresh_index_scope();
@@ -472,8 +401,6 @@ ide_command::domain!(
project_trust_remove_location,
project_trust_set,
project_trust_status,
project_workspace_member_set,
project_workspace_members,
settings_get,
settings_get_global,
settings_removed_theme,
+3 -127
Переглянути файл
@@ -3,14 +3,10 @@
use crate::Host;
use ide_command::command;
use ide_core::{FileEdit, IdeResult, RequestId, WorkspaceEdit};
use ide_language::Syntax;
use ide_core::{IdeResult, RequestId, WorkspaceEdit};
use ide_lsp::types::FileRenameEdits;
use ide_workspace::file_moves::moved_path;
use ide_workspace::roots::{ProjectRoots, RootKind};
use ide_workspace::{FileMove, UndoOutcome};
use parking_lot::Mutex;
use std::path::{Path, PathBuf};
use std::path::PathBuf;
use super::doc::blocking;
@@ -28,110 +24,16 @@ pub async fn refactor_file_move_edits(
) -> IdeResult<FileRenameEdits> {
let project = host.project(window)?;
let token = host.begin_request(request);
let result = project.lsp.will_rename_files(&pairs(&moves), token.clone()).await;
let result = project.lsp.will_rename_files(&pairs(&moves), token).await;
host.end_request(request);
let mut result = result?;
let syntax = host.syntax();
blocking(move || {
// basedpyright has no `workspace/willRenameFiles`; a Python server that answered wins.
if !result.edit.files.iter().any(|f| matches!(f, FileEdit::Edit { path, .. } if is_python(path))) {
let python = python_import_edits(&project, &syntax, &moves, &|| token.is_cancelled());
result.edit.files.extend(python.files);
}
project.documents.prepare_workspace_edit(&mut result.edit)?;
Ok(result)
})
.await
}
fn is_python(path: &Path) -> bool {
path.extension().is_some_and(|e| e == "py" || e == "pyi")
}
/// The dotted name of a Python module file or package folder, from its project's Python roots
/// (`src/a/b.py` → `a.b` in a `src` layout).
fn python_module(root: &Path, roots: &ProjectRoots, path: &Path, is_dir: bool) -> Option<String> {
let rel = path.strip_prefix(root).ok()?.to_string_lossy().replace('\\', "/");
let base = roots
.root_for(&rel)
.filter(|r| matches!(r.kind, RootKind::Source | RootKind::Test))
.map_or("", |r| r.path.as_str());
let inner = if base.is_empty() { rel.as_str() } else { rel.strip_prefix(base)?.trim_start_matches('/') };
let inner = if is_dir { inner } else { inner.strip_suffix(".py").or_else(|| inner.strip_suffix(".pyi"))? };
let inner = inner.strip_suffix("/__init__").unwrap_or(inner);
let valid = |s: &str| {
s.chars().next().is_some_and(|c| !c.is_ascii_digit()) && s.chars().all(|c| c == '_' || c.is_alphanumeric())
};
(!inner.is_empty() && inner.split('/').all(valid)).then(|| inner.replace('/', "."))
}
/// The package relative imports in `file` start from.
fn python_package(root: &Path, roots: &ProjectRoots, file: &Path) -> String {
let Some(module) = python_module(root, roots, file, false) else { return String::new() };
if file.file_stem().is_some_and(|s| s == "__init__") {
module
} else {
module.rsplit_once('.').map_or(String::new(), |(p, _)| p.to_owned())
}
}
/// Import updates in the project's Python files for `moves` (paths before the move).
fn python_import_edits(
project: &crate::project::Project,
syntax: &Syntax,
moves: &[FileMove],
cancelled: &(dyn Fn() -> bool + Sync),
) -> WorkspaceEdit {
let root = &project.root;
let roots = project.roots();
let renames: Vec<(String, String)> = moves
.iter()
.filter_map(|m| {
let is_dir = m.from.is_dir();
if !is_dir && (!is_python(&m.from) || m.from.file_stem().is_some_and(|s| s == "__init__")) {
return None;
}
let old = python_module(root, &roots, &m.from, is_dir)?;
let new = python_module(root, &roots, &m.to, is_dir)?;
(old != new).then_some((old, new))
})
.collect();
if renames.is_empty() {
return WorkspaceEdit::default();
}
let names: Vec<&str> = renames.iter().map(|(old, _)| old.rsplit('.').next().unwrap_or(old)).collect();
let found: Mutex<Vec<(PathBuf, Vec<ide_core::TextEdit>)>> = Mutex::new(Vec::new());
ide_vfs::walk_files(root, &project.exclude_globs(), |path| {
if cancelled() || !is_python(path) {
return;
}
let moved = moved_path(path, moves);
let text = match project.documents.text_of(path) {
Some(t) => t,
None => match std::fs::read_to_string(path) {
Ok(t) => t,
Err(_) => return,
},
};
if moved == path && !names.iter().any(|n| text.contains(n)) {
return;
}
let edits = syntax.python_import_edits(
&text,
&python_package(root, &roots, path),
&python_package(root, &roots, &moved),
&renames,
);
if !edits.is_empty() {
found.lock().push((path.to_path_buf(), edits));
}
});
let mut files = found.into_inner();
files.sort_by(|a, b| a.0.cmp(&b.0));
let files = files.into_iter().map(|(path, edits)| FileEdit::Edit { path: path.into(), edits, version: None });
WorkspaceEdit { files: files.collect(), ..Default::default() }
}
/// Applies `edit` (from [`refactor_file_move_edits`], possibly empty), moves the
/// files and notifies the servers. Returns the id for [`refactor_undo_file_move`].
#[command(trust = always)]
@@ -209,29 +111,3 @@ ide_command::domain!(
refactor_move_files,
refactor_undo_file_move,
);
#[cfg(test)]
mod tests {
use super::*;
use ide_workspace::roots::SourceFolder;
#[test]
fn python_module_names_follow_the_roots() {
let root = Path::new("/p");
let folder = |path: &str, kind| SourceFolder { path: path.into(), kind, detected_from: None };
let roots = ProjectRoots::compute(
vec![folder("src", RootKind::Source), folder("tests", RootKind::Test)],
&Default::default(),
);
let name = |p: &str, dir| python_module(root, &roots, &root.join(p), dir);
assert_eq!(name("src/tasks/models.py", false).as_deref(), Some("tasks.models"));
assert_eq!(name("src/tasks/__init__.py", false).as_deref(), Some("tasks"));
assert_eq!(name("src/tasks", true).as_deref(), Some("tasks"));
assert_eq!(name("tests/test_models.py", false).as_deref(), Some("test_models"));
assert_eq!(name("scripts/run.pyi", false).as_deref(), Some("scripts.run"));
assert_eq!(name("my-scripts/run.py", false), None);
assert_eq!(name("src/tasks/notes.txt", false), None);
assert_eq!(python_package(root, &roots, &root.join("src/tasks/cli.py")), "tasks");
assert_eq!(python_package(root, &roots, &root.join("src/tasks/__init__.py")), "tasks");
}
}
+3 -2
Переглянути файл
@@ -70,14 +70,15 @@ fn scan_roots(root: &Path, content_roots: Vec<PathBuf>) -> Vec<PathBuf> {
/// Every mapping source of the project, for the request-path index.
pub fn spring_route_sources(host: &Host, window: &str) -> IdeResult<Vec<RouteSource>> {
let project = host.project(window)?;
let excludes = project.search_excludes();
let mut out = Vec::new();
for root in scan_roots(&project.root, project.content_roots()) {
out.extend(sources_in(&root, &project.search_excludes_in(&root)));
out.extend(sources_in(&root, &excludes));
}
out.sort_by(|a, b| a.path.cmp(&b.path));
out.dedup_by(|a, b| a.path == b.path);
match out.len() {
0 => tracing::warn!("spring routes: no mapping source under {:?}", project.root),
0 => tracing::warn!("spring routes: no mapping source under {:?} (excludes: {})", project.root, excludes.len()),
n => tracing::info!("spring routes: {n} mapping sources under {:?}", project.root),
}
Ok(out)
-16
Переглянути файл
@@ -6,7 +6,6 @@ use ide_command::command;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_scaffold::{CreateRequest, Field, GeneratorInfo, Requirement, ScaffoldEvent, Values};
use std::path::PathBuf;
fn join_err(e: impl std::fmt::Display) -> IdeError {
IdeError::internal(e.to_string())
@@ -42,19 +41,6 @@ pub async fn scaffold_requirements(generator: String, values: Values) -> IdeResu
tokio::task::spawn_blocking(move || ide_scaffold::requirements(&generator, &values)).await.map_err(join_err)?
}
/// Whether a project named `name` cannot be created in `location`: something other than an
/// empty folder is already there.
#[command(trust = always)]
pub async fn scaffold_target_taken(location: PathBuf, name: String) -> IdeResult<bool> {
tokio::task::spawn_blocking(move || ide_scaffold::target_taken(&location.join(name.trim()))).await.map_err(join_err)
}
/// The first of `base`, `base1`, `base2`, … that names nothing in `location` yet.
#[command(trust = always)]
pub async fn scaffold_free_name(location: PathBuf, base: String) -> IdeResult<String> {
tokio::task::spawn_blocking(move || ide_scaffold::free_name(&location, &base)).await.map_err(join_err)
}
/// Creates a project, streaming progress through `on_event`, and returns its directory,
/// trusted. Cancellable with `cancel_request(request)`; a failed or cancelled run leaves nothing.
#[command(trust = always)]
@@ -83,8 +69,6 @@ ide_command::domain!(
scaffold:
scaffold_catalog,
scaffold_create,
scaffold_free_name,
scaffold_options,
scaffold_requirements,
scaffold_target_taken,
);
+24 -31
Переглянути файл
@@ -120,33 +120,6 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
.map_err(join_err)?
}
/// The interpreter of the workspace member `near` belongs to, else the project's.
pub(crate) fn effective_python(
config_dir: &std::path::Path,
project: &crate::Project,
near: Option<&std::path::Path>,
) -> Option<PathBuf> {
let project_root = &project.root;
let member = ide_workspace::workspace::Workspace::load(project_root).ok().flatten().and_then(|w| {
let near = near?;
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.
ide_sdk::apply::python_interpreter_near(&root, near, &settings).or_else(|| {
(&root != project_root)
.then(|| ide_sdk::apply::python_interpreter(project_root, &project.settings.effective()))
.flatten()
})
}
/// The interpreter the project uses: the configured one, else its virtualenv.
#[command(trust = trusted)]
pub async fn sdk_python_effective(
@@ -156,11 +129,31 @@ pub async fn sdk_python_effective(
) -> IdeResult<Option<ide_core::IpcPath>> {
host.require_trust(window)?;
let project = host.project(window)?;
let config_dir = host.config_dir.clone();
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 || Ok(effective_python(&config_dir, &project, near.as_deref()).map(Into::into)))
.await
.map_err(join_err)?
tokio::task::spawn_blocking(move || {
let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
let near = near.as_deref()?;
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
});
let (root, settings) = match member {
Some(root) => {
let settings = ide_workspace::SettingsStore::load(&config_dir, Some(&root)).effective();
(root, settings)
}
None => (project_root.clone(), project.settings.effective()),
};
// A member with no Python of its own falls back to the primary project's
// (the same chain run configurations use), so every answer names one interpreter.
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
(root != project_root)
.then(|| ide_sdk::apply::python_interpreter(&project_root, &project.settings.effective()))
.flatten()
});
Ok(interpreter.map(Into::into))
})
.await
.map_err(join_err)?
}
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
-4
Переглянути файл
@@ -123,10 +123,6 @@ pub(crate) fn search_project(
if let Some(prefix) = &prefix {
remaining.include = rebase_masks(&query.include, prefix);
remaining.exclude = rebase_masks(&query.exclude, prefix);
// An attached project's own excluded folders: the project's were rebased away.
if !query.include_excluded && project.member_excludes.read().contains_key(dir) {
remaining.exclude.extend(project.search_excludes_in(dir));
}
// Only paths elsewhere were asked for.
if remaining.include.is_empty() && !query.include.is_empty() {
continue;
+4 -23
Переглянути файл
@@ -151,8 +151,6 @@ impl LogAccess {
pub struct VcsRoot {
/// Worktree root.
pub root: ide_core::IpcPath,
/// Root representing all mapped worktrees of the same Git repository in branch lists.
pub branch_root: ide_core::IpcPath,
/// Merge / rebase / cherry-pick / revert in progress.
pub operation: Option<String>,
/// Current branch; `None` when HEAD is detached (or unreadable).
@@ -350,28 +348,11 @@ pub fn vcs_roots(host: &Host, window: &str) -> IdeResult<Vec<VcsRoot>> {
let primary = repos.primary().map(|r| r.root().to_path_buf());
let mut all: Vec<&std::sync::Arc<Repo>> = repos.all().iter().collect();
all.sort_by_key(|r| Some(r.root()) != primary.as_deref());
let roots: Vec<_> = all.into_iter().map(|repo| (repo, repo.metadata_dirs().ok())).collect();
let mut branch_roots = std::collections::HashMap::new();
for (repo, dirs) in &roots {
if let Some([git_dir, common_dir]) = dirs {
let first = branch_roots.entry(common_dir).or_insert(repo.root());
if git_dir == common_dir {
*first = repo.root();
}
}
}
Ok(roots
.iter()
.map(|(r, dirs)| {
Ok(all
.into_iter()
.map(|r| {
let (head, head_commit) = r.head().unwrap_or_default();
let branch_root = dirs.as_ref().and_then(|[_, common_dir]| branch_roots.get(common_dir));
VcsRoot {
root: r.root().into(),
branch_root: branch_root.copied().unwrap_or_else(|| r.root()).into(),
operation: r.operation().ok().flatten(),
head,
head_commit,
}
VcsRoot { root: r.root().to_path_buf().into(), operation: r.operation().ok().flatten(), head, head_commit }
})
.collect())
}
+29 -398
Переглянути файл
@@ -10,7 +10,7 @@ use ide_extension::ledger::{Ledger, Subject};
use ide_language::ProgramPin;
use ide_plugin::{
CommitChange, CommitDraft, EventKind, HostApi, HostError, HttpRequest, HttpResponse, NotificationLevel,
ProcessChunk, ProcessCommand, ProcessOptions, ProcessOutput, Prompt, RepositoryStatus, StatusItem,
ProcessChunk, ProcessCommand, ProcessOutput, Prompt, RepositoryStatus, StatusItem,
};
use parking_lot::{Mutex, RwLock};
use std::collections::{BTreeMap, BTreeSet, HashMap};
@@ -200,14 +200,8 @@ impl SecretStore for FileSecretStore {
/// Largest response body a plugin receives.
const MAX_RESPONSE: usize = 16 << 20;
/// Largest stdout / stderr kept from a process by default.
/// Largest stdout / stderr kept from a process.
const MAX_OUTPUT: usize = 16 << 20;
/// Hard ceiling for configurable process output capture.
const MAX_ALLOWED_OUTPUT: usize = 128 << 20;
/// Default in-flight stream buffer for lossless streaming backpressure.
const DEFAULT_STREAM_BUFFER: usize = 256 << 10;
/// Default total lifetime stream output limit for lossless streaming.
const DEFAULT_STREAM_MAX_TOTAL: usize = 32 << 20;
/// Most processes one plugin keeps running at once.
const MAX_PROCESSES: usize = 8;
/// Most output one stream of a handle holds until the plugin reads it.
@@ -323,18 +317,11 @@ fn clipboard_content(answer: super::ClipboardAnswer) -> Result<ide_plugin::Clipb
Ok(ide_plugin::ClipboardContent { text: text.filter(|t| !t.is_empty()), image })
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum StreamMode {
Tail,
Lossless,
}
/// A process a plugin started and has not released (API 1.3 `process.start`, API 1.15 `process.start-stream`).
/// A process a plugin started and has not released (API 1.3 `process.start`).
/// Two reader threads copy its output into bounded buffers; the handle lives
/// as long as the plugin instance that started it.
struct Proc {
client: Option<String>,
can_read: parking_lot::Condvar,
state: Mutex<ProcState>,
}
@@ -348,29 +335,6 @@ struct ProcState {
status: Option<i32>,
/// Reader threads still copying its pipes into the buffers above.
readers: usize,
/// Active wait_process callers. While positive, reader threads buffer up to
/// max_total instead of buffer_limit so producers emitting more than the chunk
/// buffer do not deadlock waiting for process exit.
waiters: usize,
mode: StreamMode,
buffer_limit: usize,
max_total: usize,
total_stdout: usize,
total_stderr: usize,
overflow_err: Option<String>,
stopped: bool,
}
impl ProcState {
/// Ends a child whose output went over the limit. `kill_tree` reaps it, so its status
/// is noted here: a later reap must not wait on a process id that is already gone.
fn stop_overflowed(&mut self) {
self.stdin = None;
ide_core::process::kill_tree(&mut self.child);
if self.status.is_none() {
self.status = Some(self.child.try_wait().ok().flatten().and_then(|s| s.code()).unwrap_or(-1));
}
}
}
/// Which pipe a reader thread drains.
@@ -382,100 +346,34 @@ enum Stream {
impl Proc {
/// Copies `pipe` into the matching buffer until it closes, keeping the last
/// [`MAX_PENDING`] bytes (in tail mode) or pausing on backpressure (in lossless mode),
/// then notes that the reader finished.
/// [`MAX_PENDING`] bytes, then notes that the reader finished.
fn read(self: &Arc<Self>, mut pipe: impl Read + Send + 'static, stream: Stream) {
self.state.lock().readers += 1;
let this = Arc::clone(self);
std::thread::spawn(move || {
let mut buf = [0u8; 8 << 10];
loop {
{
let mut state = this.state.lock();
while state.mode == StreamMode::Lossless
&& !state.stopped
&& state.overflow_err.is_none()
&& match stream {
Stream::Out => {
// While wait_process is active, allow readers to buffer up to max_total
// to prevent pipe write backpressure from hanging the child process.
if state.waiters > 0 {
state.stdout.len() >= state.max_total
} else {
state.stdout.len() >= state.buffer_limit
}
}
Stream::Err => {
if state.waiters > 0 {
state.stderr.len() >= state.max_total
} else {
state.stderr.len() >= state.buffer_limit
}
}
}
{
this.can_read.wait(&mut state);
}
if state.stopped || state.overflow_err.is_some() {
break;
}
}
match pipe.read(&mut buf) {
Ok(0) => break,
Ok(n) => {
let mut state = this.state.lock();
if state.stopped || state.overflow_err.is_some() {
break;
}
if state.mode == StreamMode::Lossless {
match stream {
Stream::Out => {
state.total_stdout = state.total_stdout.saturating_add(n);
if state.total_stdout > state.max_total {
let limit_mib = (state.max_total + (1 << 20) - 1) >> 20;
state.overflow_err =
Some(format!("process stdout exceeded {limit_mib} MiB limit"));
state.stop_overflowed();
this.can_read.notify_all();
break;
}
state.stdout.extend_from_slice(&buf[..n]);
}
Stream::Err => {
state.total_stderr = state.total_stderr.saturating_add(n);
if state.total_stderr > state.max_total {
let limit_mib = (state.max_total + (1 << 20) - 1) >> 20;
state.overflow_err =
Some(format!("process stderr exceeded {limit_mib} MiB limit"));
state.stop_overflowed();
this.can_read.notify_all();
break;
}
state.stderr.extend_from_slice(&buf[..n]);
}
}
} else {
let out = match stream {
Stream::Out => &mut state.stdout,
Stream::Err => &mut state.stderr,
};
out.extend_from_slice(&buf[..n]);
let over = out.len().saturating_sub(MAX_PENDING);
if over > 0 {
out.drain(..over);
let continuation = out.iter().take_while(|b| (**b & 0xC0) == 0x80).count();
out.drain(..continuation);
}
let out = match stream {
Stream::Out => &mut state.stdout,
Stream::Err => &mut state.stderr,
};
out.extend_from_slice(&buf[..n]);
let over = out.len().saturating_sub(MAX_PENDING);
if over > 0 {
out.drain(..over);
let continuation = out.iter().take_while(|b| (**b & 0xC0) == 0x80).count();
out.drain(..continuation);
}
}
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
Err(_) => break,
}
}
let mut state = this.state.lock();
state.readers -= 1;
this.can_read.notify_all();
this.state.lock().readers -= 1;
});
}
@@ -499,7 +397,6 @@ impl Proc {
/// does nothing.
fn kill(&self) {
let mut state = self.state.lock();
state.stopped = true;
state.stdin = None;
if state.status.is_none() {
ide_core::process::kill_tree(&mut state.child);
@@ -507,23 +404,18 @@ impl Proc {
state.status = Some(status.code().unwrap_or(-1));
}
}
self.can_read.notify_all();
}
/// What it printed since the last call, each stream at most `max` bytes. The status
/// comes with the last chunk only: once it ended, its pipes reached the end and
/// nothing is left to read, so a caller can stop at the first chunk that has one.
fn chunk(&self, max: usize) -> Result<ProcessChunk, HostError> {
fn chunk(&self, max: usize) -> ProcessChunk {
let mut state = self.state.lock();
if let Some(err) = state.overflow_err.clone() {
return Err(HostError::Failed(err));
}
let eof = state.readers == 0;
let stdout = take_text(&mut state.stdout, max, eof);
let stderr = take_text(&mut state.stderr, max, eof);
let drained = eof && state.stdout.is_empty() && state.stderr.is_empty();
self.can_read.notify_all();
Ok(ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) })
ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) }
}
}
@@ -2776,22 +2668,6 @@ impl HostApi for PluginApi {
cancel: &CancellationToken,
timeout: Duration,
) -> Result<ProcessOutput, HostError> {
self.run_process_with_options(cmd, cwd, stdin, cancel, timeout, None)
}
fn run_process_with_options(
&self,
cmd: ProcessCommand,
cwd: Option<&Path>,
stdin: Option<String>,
cancel: &CancellationToken,
timeout: Duration,
options: Option<ProcessOptions>,
) -> Result<ProcessOutput, HostError> {
let max_output = options
.and_then(|o| o.max_output_bytes)
.map(|b| (b as usize).clamp(1 << 10, MAX_ALLOWED_OUTPUT))
.unwrap_or(MAX_OUTPUT);
let binary = self.approved_program_in_project(&cmd.program, cwd.or(cmd.approval_root.as_deref()))?;
let cwd = self.spawn_dir(cwd);
let mut command = StdCommand::new(&binary);
@@ -2818,15 +2694,15 @@ impl HostApi for PluginApi {
let mut overflow = false;
if let Some(p) = pipe {
let mut p = p;
let _ = p.by_ref().take((max_output + 1) as u64).read_to_end(&mut out);
if out.len() > max_output {
let _ = p.by_ref().take((MAX_OUTPUT + 1) as u64).read_to_end(&mut out);
if out.len() > MAX_OUTPUT {
overflow = true;
out.truncate(max_output);
out.truncate(MAX_OUTPUT);
}
let _ = std::io::copy(&mut p, &mut std::io::sink());
}
let mut text = String::from_utf8_lossy(&out).into_owned();
let mut end = text.len().min(max_output);
let mut end = text.len().min(MAX_OUTPUT);
while !text.is_char_boundary(end) {
end -= 1;
}
@@ -2852,35 +2728,15 @@ impl HostApi for PluginApi {
std::thread::sleep(Duration::from_millis(10));
};
let (stdout, stdout_overflow) = stdout.join().unwrap_or_default();
let (stderr, stderr_overflow) = stderr.join().unwrap_or_default();
if options.is_some() {
// run_captured fails explicitly if either stdout or stderr exceeds the configured limit.
if stdout_overflow || stderr_overflow {
let stream = match (stdout_overflow, stderr_overflow) {
(true, true) => "stdout and stderr",
(true, false) => "stdout",
(false, true) => "stderr",
(false, false) => unreachable!(),
};
let limit_mib = (max_output + (1 << 20) - 1) >> 20;
tracing::warn!(
plugin = %self.id(),
program = %cmd.program,
limit_mib,
"process {stream} exceeded limit"
);
return Err(HostError::Failed(format!("{} {stream} exceeded {} MiB limit", cmd.program, limit_mib)));
}
} else if stdout_overflow {
// Documented legacy behavior for run / run-command: stdout overflow fails, but
// stderr overflow is silently truncated to 16 MiB.
let (stderr, _) = stderr.join().unwrap_or_default();
if stdout_overflow {
tracing::warn!(
plugin = %self.id(),
program = %cmd.program,
limit_mib = (max_output >> 20),
limit_mib = MAX_OUTPUT >> 20,
"process stdout exceeded limit"
);
return Err(HostError::Failed(format!("{} stdout exceeded 16 MiB limit", cmd.program)));
return Err(HostError::Failed(format!("{} stdout exceeded {} MiB limit", cmd.program, MAX_OUTPUT >> 20)));
}
Ok(ProcessOutput { status: status.code(), stdout, stderr })
}
@@ -2905,16 +2761,6 @@ impl HostApi for PluginApi {
}
}
fn start_process(&self, cmd: ProcessCommand, cwd: Option<&Path>, client: Option<&str>) -> Result<u64, HostError> {
self.start_process_stream(cmd, cwd, client, None)
}
fn start_process_stream(
&self,
cmd: ProcessCommand,
cwd: Option<&Path>,
client: Option<&str>,
options: Option<ProcessOptions>,
) -> Result<u64, HostError> {
let binary = self.approved_program_in_project(&cmd.program, cwd.or(cmd.approval_root.as_deref()))?;
let cwd = self.spawn_dir(cwd);
if client.is_some_and(|c| self.shared.closed_clients.lock().contains(c)) {
@@ -2944,21 +2790,8 @@ impl HostApi for PluginApi {
.spawn()
.map_err(|e| HostError::Failed(format!("{}: {e}", binary.display())))?;
let (stdout, stderr) = (child.stdout.take(), child.stderr.take());
let (mode, buffer_limit, max_total) = match options {
Some(opts) => {
let buf =
opts.buffer_bytes.map(|b| (b as usize).clamp(4 << 10, 4 << 20)).unwrap_or(DEFAULT_STREAM_BUFFER);
let total = opts
.max_output_bytes
.map(|b| (b as usize).clamp(1 << 20, MAX_ALLOWED_OUTPUT))
.unwrap_or(DEFAULT_STREAM_MAX_TOTAL);
(StreamMode::Lossless, buf, total)
}
None => (StreamMode::Tail, MAX_PENDING, usize::MAX),
};
let proc = Arc::new(Proc {
client: client.map(str::to_owned),
can_read: parking_lot::Condvar::new(),
state: Mutex::new(ProcState {
stdin: child.stdin.take(),
child,
@@ -2966,14 +2799,6 @@ impl HostApi for PluginApi {
stderr: Vec::new(),
status: None,
readers: 0,
waiters: 0,
mode,
buffer_limit,
max_total,
total_stdout: 0,
total_stderr: 0,
overflow_err: None,
stopped: false,
}),
});
if let Some(pipe) = stdout {
@@ -2997,7 +2822,7 @@ impl HostApi for PluginApi {
fn poll_process(&self, id: u64, max: usize) -> Result<ProcessChunk, HostError> {
let proc = self.process(id)?;
proc.reap()?;
proc.chunk(max)
Ok(proc.chunk(max))
}
fn write_process(
@@ -3077,32 +2902,13 @@ impl HostApi for PluginApi {
cancel: &CancellationToken,
) -> Result<ProcessChunk, HostError> {
let proc = self.process(id)?;
// Track active waiters and wake reader threads so lossless streams continue
// draining into the retained buffer up to max_total without pipe deadlock.
struct WaitGuard<'a>(&'a Proc);
impl Drop for WaitGuard<'_> {
fn drop(&mut self) {
let mut state = self.0.state.lock();
state.waiters = state.waiters.saturating_sub(1);
self.0.can_read.notify_all();
}
}
let _guard = {
let mut state = proc.state.lock();
state.waiters += 1;
proc.can_read.notify_all();
WaitGuard(&proc)
};
let deadline = Instant::now() + timeout;
loop {
proc.reap()?;
let (ended, readers, overflow) = {
let (ended, readers) = {
let state = proc.state.lock();
(state.status.is_some(), state.readers, state.overflow_err.clone())
(state.status.is_some(), state.readers)
};
if let Some(err) = overflow {
return Err(HostError::Failed(err));
}
// Its output is only complete once its pipes reached the end too.
if ended && readers == 0 {
break;
@@ -3115,7 +2921,7 @@ impl HostApi for PluginApi {
}
std::thread::sleep(Duration::from_millis(10));
}
proc.chunk(max)
Ok(proc.chunk(max))
}
fn task_begin(&self, client: Option<&str>, title: String, cancellable: bool, cancel: CancellationToken) -> u64 {
@@ -4359,181 +4165,6 @@ mod tests {
api.release_process(id);
}
fn test_proc_api(dir: &Path) -> (PluginApi, impl Fn(&str, &str) -> ProcessCommand) {
let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
#[cfg(unix)]
let (prog, path) = ("sh", PathBuf::from("/bin/sh"));
#[cfg(windows)]
let (prog, path) = {
let sysroot = std::env::var("SystemRoot").unwrap_or_else(|_| "C:\\Windows".into());
("powershell", PathBuf::from(sysroot).join(r"System32\WindowsPowerShell\v1.0\powershell.exe"))
};
pins.write().insert(("acme.lint".into(), format!("process:{prog}")), ProgramPin::approve(&path).unwrap());
let api = api(dir, pins);
let cmd = move |unix_script: &str, win_script: &str| {
#[cfg(unix)]
{
let _ = win_script;
ProcessCommand {
program: prog.into(),
args: vec!["-c".into(), unix_script.into()],
env: Vec::new(),
approval_root: None,
}
}
#[cfg(windows)]
{
let _ = unix_script;
ProcessCommand {
program: prog.into(),
args: vec!["-NoProfile".into(), "-Command".into(), win_script.into()],
env: Vec::new(),
approval_root: None,
}
}
};
(api, cmd)
}
#[test]
fn start_stream_lossless_backpressure_fast_producer() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd("head -c 65536 /dev/zero | tr '\\0' 'A'", "[Console]::Out.Write('A' * 65536)");
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let mut total_out = String::new();
let deadline = Instant::now() + Duration::from_secs(10);
let status = loop {
let chunk = api.poll_process(id, 1024).unwrap();
total_out.push_str(&chunk.stdout);
if let Some(status) = chunk.status {
break status;
}
assert!(Instant::now() < deadline, "timed out waiting for process completion");
std::thread::sleep(Duration::from_millis(5));
};
assert_eq!(status, 0);
assert_eq!(total_out.len(), 65536);
assert!(total_out.chars().all(|c| c == 'A'));
api.release_process(id);
}
#[test]
fn start_stream_dual_stream_concurrency() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd(
"head -c 10000 /dev/zero | tr '\\0' 'O'; head -c 10000 /dev/zero | tr '\\0' 'E' >&2",
"[Console]::Out.Write('O' * 10000); [Console]::Error.Write('E' * 10000)",
);
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let mut total_stdout = String::new();
let mut total_stderr = String::new();
let deadline = Instant::now() + Duration::from_secs(10);
let status = loop {
let chunk = api.poll_process(id, 1024).unwrap();
total_stdout.push_str(&chunk.stdout);
total_stderr.push_str(&chunk.stderr);
if let Some(status) = chunk.status {
break status;
}
assert!(Instant::now() < deadline, "timed out waiting for dual streams");
std::thread::sleep(Duration::from_millis(5));
};
assert_eq!(status, 0);
assert_eq!(total_stdout.len(), 10000);
assert_eq!(total_stderr.len(), 10000);
assert!(total_stdout.chars().all(|c| c == 'O'));
assert!(total_stderr.chars().all(|c| c == 'E'));
api.release_process(id);
}
#[test]
fn start_stream_total_limit_overflow() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd("head -c 2097152 /dev/zero | tr '\\0' 'X'", "[Console]::Out.Write('X' * 2097152)");
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let deadline = Instant::now() + Duration::from_secs(10);
let mut err = None;
while Instant::now() < deadline {
match api.poll_process(id, 65536) {
Ok(chunk) => {
if chunk.status.is_some() {
break;
}
}
Err(e) => {
err = Some(e);
break;
}
}
std::thread::sleep(Duration::from_millis(10));
}
let err = err.expect("expected overflow error");
assert!(matches!(err, HostError::Failed(ref msg) if msg.contains("exceeded 1 MiB limit")), "{err}");
api.release_process(id);
}
#[test]
fn run_captured_configurable_limits() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let token = CancellationToken::new();
let cmd = make_cmd("head -c 2097152 /dev/zero | tr '\\0' 'Z'", "[Console]::Out.Write('Z' * 2097152)");
let opts_ok = ProcessOptions { max_output_bytes: Some(4 << 20), buffer_bytes: None };
let out = api
.run_process_with_options(cmd.clone(), None, None, &token, Duration::from_secs(10), Some(opts_ok))
.unwrap();
assert_eq!(out.status, Some(0));
assert_eq!(out.stdout.len(), 2097152);
let opts_fail = ProcessOptions { max_output_bytes: Some(1 << 20), buffer_bytes: None };
let err = api
.run_process_with_options(cmd, None, None, &token, Duration::from_secs(10), Some(opts_fail))
.unwrap_err();
assert!(matches!(err, HostError::Failed(ref msg) if msg.contains("stdout exceeded 1 MiB limit")), "{err}");
// Stderr overflow in run_captured also fails explicitly
let cmd_err = make_cmd("head -c 2097152 /dev/zero >&2", "[Console]::Error.Write('E' * 2097152)");
let err = api
.run_process_with_options(cmd_err, None, None, &token, Duration::from_secs(10), Some(opts_fail))
.unwrap_err();
assert!(matches!(err, HostError::Failed(ref msg) if msg.contains("stderr exceeded 1 MiB limit")), "{err}");
}
#[test]
fn start_stream_wait_drains_producer_larger_than_buffer() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let token = CancellationToken::new();
// Emits 64 KiB, which is 16x larger than the 4 KiB buffer. Calling wait drains without blocking on pipe.
let cmd = make_cmd("head -c 65536 /dev/zero | tr '\\0' 'W'", "[Console]::Out.Write('W' * 65536)");
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let chunk = api.wait_process(id, 100_000, Duration::from_secs(10), &token).unwrap();
assert_eq!(chunk.status, Some(0));
assert_eq!(chunk.stdout.len(), 65536);
assert!(chunk.stdout.chars().all(|c| c == 'W'));
api.release_process(id);
}
#[test]
fn start_stream_cancellation_terminates_child() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd("sleep 60", "Start-Sleep -Seconds 60");
let id = api.start_process_stream(cmd, None, None, None).unwrap();
let proc = api.process(id).unwrap();
api.kill_process(id).unwrap();
assert!(proc.state.lock().child.try_wait().unwrap().is_some());
api.release_process(id);
}
#[test]
fn programs_run_only_as_approved() {
let tmp = tempfile::tempdir().unwrap();
+3 -9
Переглянути файл
@@ -110,16 +110,10 @@ pub fn plugin_answer_commit(plugins: &Arc<PluginHost>, request_id: String, answe
plugins.answer_commit(&request_id, answer)
}
/// The UI reports the focused editor's file (`editor-focused` events), with its
/// caret so plugins can scope line labels without re-reading the document.
/// The UI reports the focused editor's file (`editor-focused` events).
#[command(trust = always)]
pub fn plugin_set_active_file(
plugins: &Arc<PluginHost>,
window: &str,
path: Option<String>,
#[default] editor: Option<PluginEditor>,
) {
plugins.set_active_file(window, path, editor);
pub fn plugin_set_active_file(plugins: &Arc<PluginHost>, window: &str, path: Option<String>) {
plugins.set_active_file(window, path);
}
/// The invoking window's reply to a plugin command request.
+3 -22
Переглянути файл
@@ -53,7 +53,6 @@ mod run_detectors;
pub mod run_targets;
pub mod search;
mod semantic_tokens;
mod skills;
mod snippets;
mod theme;
mod types;
@@ -386,8 +385,6 @@ pub struct PluginHost {
run_detectors: Arc<run_detectors::RunDetectors>,
/// `[[contributes.javaAgents]]` of enabled plugins.
java_agents: Arc<java_agents::JavaAgents>,
/// `[[contributes.skills]]` of enabled plugins.
skills: Arc<skills::PluginSkills>,
/// `[[contributes.providers]]` of enabled plugins.
providers: Arc<providers::Providers>,
navigation: Mutex<navigation::NavigationIndex>,
@@ -414,8 +411,6 @@ pub struct PluginHost {
announced_theme: Mutex<Option<ActiveTheme>>,
/// [`PluginLanguages::revision`] last announced with `LanguagesChanged`.
announced_languages: AtomicU64,
/// [`skills::PluginSkills::revision`] last announced to open projects.
announced_skills: AtomicU64,
/// `PATH` used to resolve `process:` programs at grant time.
path_var: RwLock<PathVar>,
/// (plugin id, `process:` capability) → the approved program; read by the
@@ -475,8 +470,7 @@ impl PluginHost {
let run_detectors: Arc<run_detectors::RunDetectors> = Arc::default();
let providers: Arc<providers::Providers> = Arc::default();
let java_agents: Arc<java_agents::JavaAgents> = Arc::default();
let skills: Arc<skills::PluginSkills> = Arc::default();
register_builtin_points(&registry, &ui, &languages, &run_detectors, &java_agents, &providers, &skills)
register_builtin_points(&registry, &ui, &languages, &run_detectors, &java_agents, &providers)
.map_err(IdeError::internal)?;
let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
let policy_pins = pins.clone();
@@ -512,7 +506,6 @@ impl PluginHost {
languages,
run_detectors,
java_agents,
skills,
providers,
navigation: Mutex::default(),
endpoints: Mutex::default(),
@@ -528,7 +521,6 @@ impl PluginHost {
startup_finished: AtomicBool::new(false),
announced_theme: Mutex::new(None),
announced_languages: AtomicU64::new(0),
announced_skills: AtomicU64::new(0),
path_var: RwLock::new(Arc::new(|| std::env::var_os("PATH"))),
pins,
};
@@ -1737,9 +1729,8 @@ impl PluginHost {
}
/// The UI reports which file its focused editor shows (`editor-focused`).
/// The editor snapshot carries the caret so line-scoped features stay current.
pub fn set_active_file(&self, client: &str, path: Option<String>, editor: Option<PluginEditor>) {
self.post_window_events(client, vec![WorkbenchEvent::EditorFocused(path)], editor);
pub fn set_active_file(&self, client: &str, path: Option<String>) {
self.post_events(Some(client), vec![WorkbenchEvent::EditorFocused(path)]);
}
/// Where plugin secrets are kept (default: files under the plugins
@@ -2923,16 +2914,6 @@ impl PluginHost {
if self.announced_languages.swap(languages, Ordering::AcqRel) != languages {
self.emit(None, PluginEvent::LanguagesChanged);
}
let skills = self.skills.revision();
if self.announced_skills.swap(skills, Ordering::AcqRel) != skills
&& let Some(workspace) = self.shared.workspace.read().clone()
&& let Some(host) = workspace.database_host()
{
for p in host.projects() {
p.agents.notify_mcp_servers_changed();
p.sink.emit(ide_core::IdeEvent::SettingsChanged { key: "agents.skills".into() });
}
}
let active = self.active_theme();
let mut announced = self.announced_theme.lock();
if *announced != active {
-2
Переглянути файл
@@ -66,7 +66,6 @@ pub fn register_builtin_points(
run_detectors: &Arc<super::run_detectors::RunDetectors>,
java_agents: &Arc<super::java_agents::JavaAgents>,
providers: &Arc<super::providers::Providers>,
skills: &Arc<super::skills::PluginSkills>,
) -> Result<(), String> {
registry.register(Arc::new(UiPoint::new(COMMANDS, ui.clone(), command)))?;
registry.register(Arc::new(super::theme::ThemesPoint::new(ui.clone())))?;
@@ -74,7 +73,6 @@ pub fn register_builtin_points(
registry.register(Arc::new(UiPoint::new(super::icons::POINT_ID, ui.clone(), super::icons::icon_theme)))?;
registry.register(Arc::new(super::run_detectors::RunDetectorsPoint::new(run_detectors.clone())))?;
registry.register(Arc::new(super::java_agents::JavaAgentsPoint::new(java_agents.clone())))?;
registry.register(Arc::new(super::skills::SkillsPoint::new(skills.clone())))?;
registry.register(Arc::new(super::navigation::IndexersPoint))?;
registry.register(Arc::new(super::providers::ProvidersPoint::new(providers.clone())))?;
registry.register(Arc::new(UiPoint::new(super::providers::SECRETS_POINT, ui.clone(), super::providers::secret)))?;
-250
Переглянути файл
@@ -1,250 +0,0 @@
//! The `skills` extension point (API 1.15): declarative `SKILL.md` folders inside a
//! plugin package (`[[contributes.skills]]`), discovered directly from live plugins'
//! package directories and staged into agent sessions through [`ide_agent::skills`].
//!
//! ```toml
//! [[contributes.skills]]
//! path = "skills/release-notes/SKILL.md"
//! ```
//!
//! Invalid entries emit a plugin load warning (`Prepared::skipped`) rather than failing
//! the whole plugin; `engines.openidea` compatibility (`^1.15`) remains a manifest check.
use super::PluginHost;
use ide_extension::{Disposable, ExtensionPoint, Package, Placement, Prepared, decode};
use parking_lot::RwLock;
use serde::Deserialize;
use std::collections::HashSet;
use std::path::{Component, Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
pub const POINT_ID: &str = "skills";
/// Maximum total size of all files inside one contributed skill folder (2 MiB).
pub const MAX_SKILL_DIR_BYTES: u64 = 2 << 20;
const MAX_SKILL_FILES: usize = 256;
const MAX_SKILL_DEPTH: usize = 16;
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct Decl {
path: PathBuf,
}
#[derive(Clone, Debug)]
struct ContributedSkill {
plugin_id: String,
name: String,
/// Package-relative directory holding `SKILL.md` (e.g. `skills/release-notes`).
rel_dir: PathBuf,
}
/// Contributed skills of loaded plugins.
#[derive(Default)]
pub struct PluginSkills {
items: RwLock<Vec<(u64, ContributedSkill)>>,
seq: AtomicU64,
revision: AtomicU64,
}
impl PluginSkills {
pub fn revision(&self) -> u64 {
self.revision.load(Ordering::Acquire)
}
fn add(self: &Arc<Self>, item: ContributedSkill) -> Disposable {
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
self.items.write().push((seq, item));
self.revision.fetch_add(1, Ordering::AcqRel);
let weak = Arc::downgrade(self);
Disposable::new(move || {
if let Some(this) = weak.upgrade() {
this.items.write().retain(|(s, _)| *s != seq);
this.revision.fetch_add(1, Ordering::AcqRel);
}
})
}
}
pub struct SkillsPoint {
store: Arc<PluginSkills>,
}
impl SkillsPoint {
pub fn new(store: Arc<PluginSkills>) -> Self {
Self { store }
}
}
impl ExtensionPoint for SkillsPoint {
fn id(&self) -> &'static str {
POINT_ID
}
fn placement(&self) -> Placement {
Placement::Workspace
}
fn prepare(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
pkg.manifest.needs_api("contributes.skills", 15)?;
match self.prepare_entry(pkg, decl) {
Ok(prepared) => Ok(prepared),
Err(warning) => Ok(Prepared::skipped(warning)),
}
}
}
impl SkillsPoint {
fn prepare_entry(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
let d: Decl = decode(POINT_ID, decl)?;
if d.path.as_os_str().is_empty() || !d.path.components().all(|c| matches!(c, Component::Normal(_))) {
return Err(format!("{}: `path` must be a relative path inside the plugin", d.path.display()));
}
if d.path.file_name().and_then(|n| n.to_str()) != Some("SKILL.md") {
return Err(format!("{}: must point to `<dir>/SKILL.md`", d.path.display()));
}
let Some(rel_dir) = d.path.parent().filter(|p| !p.as_os_str().is_empty()) else {
return Err(format!("{}: must live inside a `<name>/SKILL.md` folder", d.path.display()));
};
let Some(folder) = rel_dir.file_name().and_then(|n| n.to_str()) else {
return Err(format!("{}: invalid skill folder name", d.path.display()));
};
// Reject duplicate skill folder names across distinct paths in the same plugin.
for other in pkg.manifest.declarations(POINT_ID) {
let Some(other_path) = other.get("path").and_then(|v| v.as_str()).map(Path::new) else { continue };
if other_path == d.path {
break;
}
if other_path.file_name().and_then(|n| n.to_str()) == Some("SKILL.md")
&& other_path.parent().and_then(|p| p.file_name()).and_then(|n| n.to_str()) == Some(folder)
{
return Err(format!("duplicate skill `{folder}` in plugin"));
}
}
let pkg_root = pkg.dir.canonicalize().map_err(|e| format!("plugin directory: {e}"))?;
let abs_dir = pkg.resolve(rel_dir)?;
if !abs_dir.is_dir() {
return Err(format!("{}: not a directory", rel_dir.display()));
}
let _ = pkg.resolve(&d.path)?;
let mut files = Vec::new();
let mut total_bytes = 0u64;
let mut visited_dirs = HashSet::new();
visited_dirs.insert(abs_dir.clone());
collect_skill_files(
&pkg_root,
&pkg.dir.join(rel_dir),
rel_dir,
0,
&mut visited_dirs,
&mut files,
&mut total_bytes,
folder,
)?;
files.sort();
let text = pkg.read_text(&d.path)?;
ide_agent::skills::validate_plugin_skill(&abs_dir, folder, &text)
.map_err(|e| format!("{}: {e}", d.path.display()))?;
let label = format!("/{folder}");
let key = folder.to_owned();
let item = ContributedSkill {
plugin_id: pkg.id().to_owned(),
name: folder.to_owned(),
rel_dir: rel_dir.to_path_buf(),
};
let store = self.store.clone();
let mut prepared = Prepared::new(label, move || Ok(store.add(item))).key(key);
prepared.files = files;
Ok(prepared)
}
}
#[allow(clippy::too_many_arguments)]
fn collect_skill_files(
pkg_root: &Path,
abs_dir: &Path,
rel_dir: &Path,
depth: usize,
visited_dirs: &mut HashSet<PathBuf>,
files: &mut Vec<PathBuf>,
total_bytes: &mut u64,
skill_name: &str,
) -> Result<(), String> {
if depth > MAX_SKILL_DEPTH {
return Err(format!("{}: directory nesting exceeds {MAX_SKILL_DEPTH} levels", rel_dir.display()));
}
let entries = std::fs::read_dir(abs_dir).map_err(|e| format!("{}: {e}", rel_dir.display()))?;
for entry in entries {
let entry = entry.map_err(|e| format!("{}: {e}", rel_dir.display()))?;
let name = entry.file_name();
let entry_abs = entry.path();
let entry_rel = rel_dir.join(&name);
let sym_meta = std::fs::symlink_metadata(&entry_abs).map_err(|e| format!("{}: {e}", entry_rel.display()))?;
let canon = entry_abs
.canonicalize()
.map_err(|_| format!("{}: broken symlink or unreadable entry", entry_rel.display()))?;
if !canon.starts_with(pkg_root) {
return Err(format!("{}: points outside the plugin", entry_rel.display()));
}
let meta = if sym_meta.file_type().is_symlink() {
std::fs::metadata(&entry_abs).map_err(|e| format!("{}: {e}", entry_rel.display()))?
} else {
sym_meta
};
if meta.is_dir() {
if !visited_dirs.insert(canon.clone()) {
return Err(format!("{}: cyclic directory link", entry_rel.display()));
}
collect_skill_files(
pkg_root,
&entry_abs,
&entry_rel,
depth + 1,
visited_dirs,
files,
total_bytes,
skill_name,
)?;
visited_dirs.remove(&canon);
} else if meta.is_file() {
if files.len() >= MAX_SKILL_FILES {
return Err(format!("skill `{skill_name}` exceeds {MAX_SKILL_FILES} files"));
}
*total_bytes = total_bytes.saturating_add(meta.len());
if *total_bytes > MAX_SKILL_DIR_BYTES {
return Err(format!("skill `{skill_name}` exceeds {} MiB", MAX_SKILL_DIR_BYTES >> 20));
}
files.push(entry_rel);
} else {
return Err(format!("{}: unsupported file type in skill folder", entry_rel.display()));
}
}
Ok(())
}
impl PluginHost {
/// Skill directories (`<plugin_dir>/<rel_dir>`) contributed by live plugins for `root`.
/// Project-local `.openidea/plugins/` packages only apply to their own trusted project.
pub fn skill_dirs(&self, root: Option<&Path>, workspace_trusted: bool) -> Vec<PathBuf> {
let mut entries: Vec<(String, String, PathBuf)> = Vec::new();
for (_, item) in self.skills.items.read().iter() {
let Ok(plugin) = self.get(&item.plugin_id) else { continue };
if !plugin.status().is_live() {
continue;
}
if let Some(dev_root) = plugin.dev_root.as_deref()
&& (!workspace_trusted || root != Some(dev_root))
{
continue;
}
entries.push((item.plugin_id.clone(), item.name.clone(), plugin.dir().join(&item.rel_dir)));
}
entries.sort_by(|a, b| a.0.cmp(&b.0).then_with(|| a.1.cmp(&b.1)));
entries.into_iter().map(|(_, _, path)| path).collect()
}
}
+1 -2
Переглянути файл
@@ -4,8 +4,7 @@ use super::theme::ThemeDef;
use ide_extension::package::PluginIcon;
use ide_extension::{CapabilityInfo, ContributionInfo, UiContribution};
pub use ide_plugin::{
ActionPerformed, ActionSource, CaretMoved, EventKind, NotificationLevel, PickItem, Prompt, StatusItem,
WorkbenchEvent,
ActionPerformed, ActionSource, EventKind, NotificationLevel, PickItem, Prompt, StatusItem, WorkbenchEvent,
};
use serde::{Deserialize, Serialize};
use specta::Type;
+17 -197
Переглянути файл
@@ -47,14 +47,10 @@ pub struct Project {
pub structure: Arc<StructureService>,
/// Roots auto-detected from build files; see [`Project::roots`].
pub detected_roots: Arc<RwLock<Vec<SourceFolder>>>,
/// The excluded folders of the workspace's other projects; see [`member_excludes`].
pub(crate) member_excludes: MemberExcludes,
/// Per-project cache directory (build tool sync results…).
pub cache_dir: PathBuf,
/// Superseded launch snapshots retained until this project session ends.
pub(crate) java_launch_snapshots: Mutex<crate::ops::java::cache::Session>,
/// Java launches waiting for their build, which can share one Maven run.
pub(crate) java_launches_waiting: crate::ops::java::cache::Waiting,
/// Reasons this window was already told why Kotlin is debugged with kotlin-debug-adapter.
pub(crate) kotlin_debug_notices: Mutex<HashSet<&'static str>>,
/// Database tool window: data sources and their connections.
@@ -125,8 +121,7 @@ impl Host {
}
let settings = SettingsStore::load(&self.config_dir, Some(&root));
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
let member_excludes: MemberExcludes = Arc::new(RwLock::new(member_excludes(&settings, &root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read(), &member_excludes.read());
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
let build_cache = self.local_data_dir.join("cache").join(project_key(&root)).join("build");
let extra_roots = content_roots(&settings.effective(), &root, &build_cache, trusted.load(Ordering::Acquire));
mark("roots");
@@ -150,7 +145,7 @@ impl Host {
let index = ProjectIndex::open(
&root,
&self.local_data_dir.join("index").join(&project_key),
index_roots(&root, extra_roots.clone(), &settings.effective(), &member_excludes.read()),
index_roots(&root, extra_roots.clone()),
excludes.clone(),
languages.clone(),
self.syntax(),
@@ -390,7 +385,6 @@ impl Host {
let sink = sink.clone();
let root = root.clone();
let detected_roots = detected_roots.clone();
let member_excludes = member_excludes.clone();
let history = history.clone();
let remote = self.remote.clone();
let runtime = self.runtime.clone();
@@ -453,15 +447,12 @@ impl Host {
if *detected_roots.read() != fresh {
// Detected excluded folders (`target`, `build`) leave the index too.
let effective = settings.effective();
let members = member_excludes.read();
index.set_scope(
index_roots(
&root,
content_roots(&effective, &root, &build_cache, trusted.load(Ordering::Acquire)),
&effective,
&members,
),
exclude_globs(&root, &effective, &fresh, &members),
exclude_globs(&root, &effective, &fresh),
);
*detected_roots.write() = fresh;
sink.emit(IdeEvent::ProjectRootsChanged { root: root.clone().into() });
@@ -578,10 +569,9 @@ impl Host {
let content_watchers = extra_roots
.iter()
.filter_map(|r| {
let globs = root_globs(&settings.effective(), &member_excludes.read(), r);
let w = content_root_watcher(
r,
globs.as_deref().unwrap_or(&excludes),
&excludes,
&sink,
&index,
&documents,
@@ -635,12 +625,10 @@ impl Host {
structure: Arc::new(StructureService::new(syntax.clone())),
syntax,
detected_roots,
member_excludes,
cache_dir: self.local_data_dir.join("cache").join(&project_key),
java_launch_snapshots: Mutex::new(crate::ops::java::cache::Session::new(
self.local_data_dir.join("cache").join(&project_key).join("build"),
)),
java_launches_waiting: Default::default(),
kotlin_debug_notices: Mutex::default(),
db,
http_history,
@@ -682,16 +670,6 @@ impl Host {
weak.upgrade().map(|p| p.settings.effective().agent_security).unwrap_or_default()
}));
}
{
let weak = Arc::downgrade(&project);
let trust = self.trust.clone();
project.agents.set_workspace_roots_hook(Arc::new(move || {
let Some(p) = weak.upgrade() else { return Vec::new() };
let mut roots = vec![p.root.clone()];
roots.extend(crate::mcp::trusted_attachments(&trust, &p.root));
roots
}));
}
self.insert_project(window, project.clone());
for (key, text, dirty) in &carried {
let _ = project.documents.restore_untitled_buffer(key, text, *dirty);
@@ -765,20 +743,12 @@ impl Host {
let skill_settings = settings.clone();
let skill_root = root.clone();
let trust = self.trust.clone();
let plugin_host = self.plugin_host.read().clone();
agents.set_skills_policy_hook(Box::new(move || {
let layer = |scope| skill_settings.layer(scope).agents.skills.clone();
let workspace_trusted = trust.window_trusted(&skill_root).unwrap_or(false);
let plugin_dirs = plugin_host
.upgrade()
.map(|plugins| plugins.skill_dirs(Some(&skill_root), workspace_trusted))
.unwrap_or_default();
ide_agent::SkillsPolicy {
user: layer(ide_workspace::settings::SettingsScope::Global),
workspace: layer(ide_workspace::settings::SettingsScope::Project),
workspace_trusted,
workspace_roots: crate::ops::agent::workspace_skill_roots(&skill_root),
plugin_dirs,
workspace_trusted: trust.trusted(&skill_root).unwrap_or(false),
}
}));
agents.set_mcp_servers_hook(Box::new(move || {
@@ -881,12 +851,10 @@ impl Host {
structure: Arc::new(StructureService::new(syntax.clone())),
syntax,
detected_roots: Arc::default(),
member_excludes: Arc::default(),
cache_dir: self.local_data_dir.join("cache").join(&project_key),
java_launch_snapshots: Mutex::new(crate::ops::java::cache::Session::new(
self.local_data_dir.join("cache").join(&project_key).join("build"),
)),
java_launches_waiting: Default::default(),
kotlin_debug_notices: Mutex::default(),
db,
http_history,
@@ -1276,23 +1244,8 @@ impl Project {
/// excluded roots, the ignored names and the "Exclude files" patterns (files,
/// and everything under such folders).
pub fn search_excludes(&self) -> Vec<String> {
let mut folders = self.roots().excluded_globs();
folders.extend(nested_member_globs(&self.root, &self.member_excludes.read()));
self.search_masks(&folders)
}
/// [`Self::search_excludes`] for paths below `dir` (the project folder or a content root),
/// relative to it: an attached project's own excluded folders apply there, not this project's.
pub fn search_excludes_in(&self, dir: &Path) -> Vec<String> {
let own = self.member_excludes.read().get(dir).cloned();
match own {
Some(own) => self.search_masks(&own),
None => self.search_excludes(),
}
}
fn search_masks(&self, folders: &[String]) -> Vec<String> {
let mut out: Vec<String> = folders.iter().map(|d| format!("{}/**", d.trim_start_matches('/'))).collect();
let mut out: Vec<String> =
self.roots().excluded_globs().iter().map(|d| format!("{}/**", d.trim_start_matches('/'))).collect();
let settings = self.settings.effective();
let names =
settings.files.ignored_names.iter().cloned().chain(settings.project_structure.exclude_file_patterns());
@@ -1324,7 +1277,7 @@ impl Project {
let Some(root) = root else {
return ide_lsp::CandidateFiles::default();
};
let mut exclude = self.search_excludes_in(&root);
let mut exclude = self.search_excludes();
// Directories the server analyses fully: their files are never read.
exclude.extend(q.skip.iter().filter_map(|dir| {
let rel = dir.strip_prefix(&root).ok()?.to_str()?.replace('\\', "/");
@@ -1343,28 +1296,7 @@ impl Project {
/// `files.exclude`, the ignored names and the effective excluded roots (user-marked and detected).
pub fn exclude_globs(&self) -> Vec<String> {
exclude_globs(&self.root, &self.settings.effective(), &self.detected_roots.read(), &self.member_excludes.read())
}
/// The exclude globs below `dir` (the project folder or a content root), relative to it: a
/// project attached to this one has its own excluded folders, the other roots share these.
pub fn exclude_globs_in(&self, dir: &Path) -> Vec<String> {
let own = root_globs(&self.settings.effective(), &self.member_excludes.read(), dir);
own.unwrap_or_else(|| self.exclude_globs())
}
/// The workspace projects outside this one's folder, which have exclusions of their own.
pub fn attached_roots(&self) -> Vec<PathBuf> {
self.member_excludes.read().keys().filter(|r| !r.starts_with(&self.root)).cloned().collect()
}
/// Where `path`'s exclusions are matched from: the workspace project outside this one holding
/// it, else the project folder (whose globs cover the projects inside it, anchored there).
pub fn root_of(&self, path: &Path) -> PathBuf {
let members = self.member_excludes.read();
let outside = members.keys().filter(|r| !r.starts_with(&self.root) && path.starts_with(r));
let member = outside.max_by_key(|r| r.components().count());
member.cloned().unwrap_or_else(|| self.root.clone())
exclude_globs(&self.root, &self.settings.effective(), &self.detected_roots.read())
}
/// Project Structure content roots besides the project folder (existing directories).
@@ -1389,7 +1321,6 @@ impl Project {
if self.light {
return;
}
*self.member_excludes.write() = member_excludes(&self.settings, &self.root);
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
@@ -1398,16 +1329,12 @@ impl Project {
&self.settings.effective().languages.java.maven,
self.is_trusted(),
));
let settings = self.settings.effective();
self.index.set_scope(
index_roots(&self.root, roots.clone(), &settings, &self.member_excludes.read()),
excludes.clone(),
);
self.index.set_scope(index_roots(&self.root, roots.clone()), excludes.clone());
self.watcher.set_excludes(&excludes);
let mut watchers = self.content_watchers.lock();
watchers.retain(|(p, _)| roots.contains(p));
for (p, w) in watchers.iter() {
w.set_excludes(&self.exclude_globs_in(p));
for (_, w) in watchers.iter() {
w.set_excludes(&excludes);
}
for r in roots {
if watchers.iter().any(|(p, _)| *p == r) {
@@ -1415,7 +1342,7 @@ impl Project {
}
if let Some(w) = content_root_watcher(
&r,
&self.exclude_globs_in(&r),
&excludes,
&self.sink,
&self.index,
&self.documents,
@@ -1499,68 +1426,10 @@ pub fn history_retention(settings: &ide_core::settings::Settings) -> ide_workspa
}
/// Only explicit workspace containers exclude their root from indexed content.
fn index_roots(
root: &Path,
folders: Vec<PathBuf>,
settings: &ide_core::settings::Settings,
members: &BTreeMap<PathBuf, Vec<String>>,
) -> ide_index::IndexRoots {
fn index_roots(root: &Path, folders: Vec<PathBuf>) -> ide_index::IndexRoots {
let container =
ide_workspace::workspace::Workspace::load(root).ok().flatten().is_some_and(|w| w.is_container(root));
let folders: Vec<PathBuf> = folders.into_iter().filter(|p| p != root).collect();
let excludes = folders.iter().filter_map(|f| Some((f.clone(), root_globs(settings, members, f)?))).collect();
ide_index::IndexRoots { include_root: !container, folders, excludes }
}
/// Excluded folders (as `/`-anchored globs) by workspace project.
type MemberExcludes = Arc<RwLock<BTreeMap<PathBuf, Vec<String>>>>;
/// The excluded folders of the workspace's projects besides `root`, each from its own Project
/// Structure settings and build files (as when it is opened alone), relative to its folder.
fn member_excludes(settings: &SettingsStore, root: &Path) -> BTreeMap<PathBuf, Vec<String>> {
let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) else { return BTreeMap::new() };
// A workspace folder is no project of its own: its excluded folders apply in every member.
let shared = match workspace.is_container(root) {
true => linked_roots(root, &settings.effective(), &[]).excluded_globs(),
false => Vec::new(),
};
workspace
.projects
.into_iter()
.filter(|p| p != root && p.is_dir())
.map(|p| {
let own = settings.for_project(&p).effective();
let mut globs = shared.clone();
globs.extend(linked_roots(&p, &own, &ide_workspace::roots::detect(&p)).excluded_globs());
(p, globs)
})
.collect()
}
/// The exclude globs below the workspace project `dir`: the ignored names and "Exclude files"
/// patterns apply everywhere, excluded folders only in the project that marked them.
fn root_globs(
settings: &ide_core::settings::Settings,
members: &BTreeMap<PathBuf, Vec<String>>,
dir: &Path,
) -> Option<Vec<String>> {
let own = members.get(dir)?;
let mut globs = settings.file_excludes();
globs.extend(own.iter().cloned());
Some(globs)
}
/// The excluded folders of the workspace projects inside `root` (those its walk covers),
/// anchored at `root`.
fn nested_member_globs(root: &Path, members: &BTreeMap<PathBuf, Vec<String>>) -> Vec<String> {
let mut out = Vec::new();
for (dir, own) in members {
if let Ok(rel) = dir.strip_prefix(root) {
let rel = rel.to_string_lossy().replace('\\', "/");
out.extend(own.iter().map(|g| format!("/{rel}{g}")));
}
}
out
ide_index::IndexRoots { include_root: !container, folders: folders.into_iter().filter(|p| p != root).collect() }
}
/// The member roots of an explicit workspace container (empty for a plain
@@ -1959,15 +1828,9 @@ fn linked_roots(root: &Path, settings: &ide_core::settings::Settings, detected:
ProjectRoots::compute(detected, &settings.project_structure)
}
fn exclude_globs(
root: &Path,
settings: &ide_core::settings::Settings,
detected: &[SourceFolder],
members: &BTreeMap<PathBuf, Vec<String>>,
) -> Vec<String> {
fn exclude_globs(root: &Path, settings: &ide_core::settings::Settings, detected: &[SourceFolder]) -> Vec<String> {
let mut globs = settings.file_excludes();
globs.extend(linked_roots(root, settings, detected).excluded_globs());
globs.extend(nested_member_globs(root, members));
globs
}
@@ -2453,8 +2316,7 @@ mod composer_tests {
#[cfg(test)]
mod content_roots_tests {
use super::{SettingsStore, content_roots, exclude_globs, member_excludes, root_globs};
use std::path::Path;
use super::content_roots;
#[test]
#[cfg(windows)]
@@ -2543,46 +2405,4 @@ mod content_roots_tests {
// ... while its files go to a language server of its own.
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
}
#[test]
fn each_workspace_project_excludes_its_own_folders() {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
let (config, root, nested, other) =
(base.join("config"), base.join("app"), base.join("app/mod"), base.join("lib"));
for dir in [&nested, &other] {
std::fs::create_dir_all(dir).unwrap();
}
let store = |dir: &Path| SettingsStore::load(&config, Some(dir));
let exclude = |dir: &Path, folders: serde_json::Value| {
store(dir)
.set(ide_workspace::settings::SettingsScope::Project, "projectStructure.excluded", folders)
.unwrap();
};
exclude(&root, serde_json::json!(["target"]));
exclude(&nested, serde_json::json!(["out"]));
exclude(&other, serde_json::json!(["gen/"]));
assert!(member_excludes(&store(&root), &root).is_empty(), "a plain project has no members");
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
.unwrap();
let members = member_excludes(&store(&root), &root);
assert_eq!(members[&other], ["/gen"]);
let settings = store(&root).effective();
let globs = exclude_globs(&root, &settings, &[], &members);
// The project's own folders, and those of the project its walk covers, anchored there.
assert!(globs.contains(&"/target".to_owned()) && globs.contains(&"/mod/out".to_owned()));
assert!(!globs.contains(&"/gen".to_owned()));
let own = root_globs(&settings, &members, &other).unwrap();
assert!(own.contains(&"/gen".to_owned()) && !own.contains(&"/target".to_owned()));
assert_eq!(root_globs(&settings, &members, &root), None, "the project folder has the project's");
// A workspace folder's own excluded folders apply in every member, as before.
let ws = base.join("ws");
ide_workspace::workspace::Workspace::save(&ws, "ws", vec![root.clone(), other.clone()], true).unwrap();
exclude(&ws, serde_json::json!(["dist"]));
let members = member_excludes(&store(&ws), &ws);
assert_eq!(members[&other], ["/dist", "/gen"]);
assert_eq!(members[&root], ["/dist", "/target"]);
}
}
-160
Переглянути файл
@@ -1,160 +0,0 @@
//! Each project of a workspace keeps its own excluded folders: they apply below that project only.
use ide_core::{NullSink, RequestId};
use ide_host::{Host, HostConfig, ops};
use ide_workspace::settings::SettingsScope;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use std::time::Duration;
fn host(base: &Path) -> Host {
Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |window| window,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
})
}
/// Files containing `needle` that Find in Files reports, by path.
async fn found(host: &Host) -> Vec<PathBuf> {
let hits = Arc::new(Mutex::new(Vec::new()));
let out = hits.clone();
let query = serde_json::from_value(serde_json::json!({"pattern": "needle", "isRegex": false, "caseSensitive": false, "wholeWord": false, "include": [], "exclude": [], "scope": {"kind": "project"}, "maxMatches": 100})).unwrap();
let channel = ops::Channel::new(move |event| {
if let ops::search::SearchEvent::File { file } = event {
out.lock().unwrap().push(file.path.0);
}
});
ops::search::search_start(host, "main", RequestId::next(), query, channel).await.unwrap();
let mut paths = std::mem::take(&mut *hits.lock().unwrap());
paths.sort();
paths
}
/// The folders of `dir` the Project view shows as excluded.
async fn excluded(host: &Host, dir: &Path) -> Vec<String> {
let entries = ops::fs::fs_read_dir(host, "main", dir.to_path_buf()).await.unwrap();
entries.into_iter().filter(|e| e.excluded).map(|e| e.name).collect()
}
fn indexed(host: &Host, name: &str) -> Vec<PathBuf> {
let project = host.project("main").unwrap();
assert!(project.index.wait_idle(Duration::from_secs(20)));
project.index.files_named(name)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn attached_projects_keep_their_own_excluded_folders() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let (app, lib) = (base.join("app"), base.join("lib"));
// Both projects have a `gen` and a `dist` folder.
for root in [&app, &lib] {
for dir in ["gen", "dist", "src"] {
std::fs::create_dir_all(root.join(dir)).unwrap();
std::fs::write(root.join(dir).join(format!("{dir}.txt")), "needle\n").unwrap();
}
}
let config = base.join("config");
// `lib` excluded its `dist` when it was opened on its own.
ide_workspace::SettingsStore::load(&config, Some(&lib))
.set(SettingsScope::Project, "projectStructure.excluded", serde_json::json!(["dist"]))
.unwrap();
ide_workspace::workspace::Workspace::attach(&app, "app", vec![app.clone(), lib.clone()]).unwrap();
let host = host(&base);
host.trust.decide(&app, true, false).unwrap();
host.trust.decide(&lib, true, false).unwrap();
host.open_project("main", &app).unwrap();
ops::project::set_settings(&host, "main", SettingsScope::Project, "projectStructure.excluded", r#"["gen"]"#)
.unwrap();
host.project("main").unwrap().refresh_index_scope();
let expect = |paths: &[&str]| paths.iter().map(|p| base.join(p)).collect::<Vec<_>>();
// `app` excludes its `gen`, `lib` its `dist`: neither reaches into the other project.
assert_eq!(
found(&host).await,
expect(&["app/dist/dist.txt", "app/src/src.txt", "lib/gen/gen.txt", "lib/src/src.txt"])
);
assert_eq!(excluded(&host, &app).await, ["gen"]);
assert_eq!(excluded(&host, &lib).await, ["dist"]);
assert_eq!(indexed(&host, "gen.txt"), expect(&["lib/gen/gen.txt"]));
assert_eq!(indexed(&host, "dist.txt"), expect(&["app/dist/dist.txt"]));
// `lib` changes its exclusions in its own window: the workspace follows.
host.open_project("lib", &lib).unwrap();
ops::project::set_settings(&host, "lib", SettingsScope::Project, "projectStructure.excluded", "[]").unwrap();
let project = host.project("main").unwrap();
for _ in 0..100 {
if project.exclude_globs_in(&lib).iter().all(|g| g != "/dist") {
break;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
assert!(excluded(&host, &lib).await.is_empty());
assert_eq!(indexed(&host, "dist.txt"), expect(&["app/dist/dist.txt", "lib/dist/dist.txt"]));
ops::project::set_settings(&host, "lib", SettingsScope::Project, "projectStructure.excluded", r#"["dist"]"#)
.unwrap();
host.shutdown().await;
// Reopened: each project's exclusions come back from its own settings.
let host = self::host(&base);
host.open_project("main", &app).unwrap();
assert_eq!(
found(&host).await,
expect(&["app/dist/dist.txt", "app/src/src.txt", "lib/gen/gen.txt", "lib/src/src.txt"])
);
assert_eq!(indexed(&host, "dist.txt"), expect(&["app/dist/dist.txt"]));
host.shutdown().await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn mark_directory_as_excluded_writes_the_attached_projects_settings() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let (app, lib, other) = (base.join("app"), base.join("lib"), base.join("other"));
for dir in [app.join("gen"), lib.join("gen"), other.clone()] {
std::fs::create_dir_all(dir).unwrap();
}
ide_workspace::workspace::Workspace::attach(&app, "app", vec![app.clone(), lib.clone()]).unwrap();
let host = Arc::new(host(&base));
host.trust.decide(&app, true, false).unwrap();
host.open_project("main", &app).unwrap();
let members = ops::project::project_workspace_members(&host, "main").unwrap();
assert_eq!(members.iter().map(|m| &m.root.0).collect::<Vec<_>>(), [&lib]);
assert!(members[0].structure.excluded.is_empty());
let set = |root: &Path, key: &str, value: &str| {
ops::project::project_workspace_member_set(&host, "main", root.to_path_buf(), key.into(), value.into())
};
set(&lib, "projectStructure.excluded", r#"["gen"]"#).unwrap();
// Only Project Structure keys of the workspace's attached projects.
assert!(set(&other, "projectStructure.excluded", r#"["gen"]"#).is_err());
assert!(set(&lib, "editor.fontSize", "20").is_err());
let saved = ide_workspace::SettingsStore::load(&base.join("config"), Some(&lib));
assert_eq!(saved.effective().project_structure.excluded, ["gen"]);
let project = host.project("main").unwrap();
for _ in 0..100 {
if project.exclude_globs_in(&lib).contains(&"/gen".to_owned()) {
break;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
assert_eq!(excluded(&host, &lib).await, ["gen"]);
assert!(excluded(&host, &app).await.is_empty(), "the open project keeps its own");
assert!(
ide_workspace::SettingsStore::load(&base.join("config"), Some(&app))
.effective()
.project_structure
.excluded
.is_empty()
);
host.shutdown().await;
}
-112
Переглянути файл
@@ -1,112 +0,0 @@
use ide_core::{NullSink, RequestId};
use ide_host::{
Host, HostConfig,
ops::{Channel, fs::fs_synchronize_directories},
};
use ide_vfs::{DirectorySyncAction as Action, DirectorySyncOperation, DirectorySyncProgress};
use parking_lot::Mutex;
use std::{fs, path::Path, sync::Arc};
fn put(root: &Path, path: &str, content: &str) {
let path = root.join(path);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, content).unwrap();
}
fn op(path: &str, action: Action, overwrite: bool) -> DirectorySyncOperation {
DirectorySyncOperation { path: path.into(), action, overwrite }
}
fn host(base: &Path) -> 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,
})
}
#[tokio::test(flavor = "multi_thread")]
async fn runs_every_operation_reports_failures_and_stops_when_cancelled() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
let (left, right) = (root.join("left"), root.join("right"));
put(&left, "only-left/deep/nested/a.txt", "nested");
put(&left, "changed.txt", "left");
put(&right, "changed.txt", "right");
put(&left, "kept.txt", "left");
put(&right, "kept.txt", "right");
put(&right, "shared/new.txt", "right");
fs::create_dir_all(left.join("shared")).unwrap();
let host = host(&base);
host.trust.decide(&root, true, false).unwrap();
host.open_project("main", &root).unwrap();
let progress = Arc::new(Mutex::new(Vec::<DirectorySyncProgress>::new()));
let seen = progress.clone();
let channel = Channel::new(move |p| seen.lock().push(p));
let failures = fs_synchronize_directories(
&host,
"main",
left.clone(),
right.clone(),
vec![
op("only-left", Action::CopyToRight, false),
// Not confirmed: the destination exists, so this one fails and the rest still run.
op("kept.txt", Action::CopyToRight, false),
op("changed.txt", Action::CopyToLeft, true),
op("shared", Action::CopyToLeft, false),
// A real delete would go to this machine's Trash; a missing entry still fails the same way.
op("missing.txt", Action::DeleteLeft, false),
],
RequestId::next(),
channel.clone(),
)
.await
.unwrap();
assert_eq!(fs::read_to_string(right.join("only-left/deep/nested/a.txt")).unwrap(), "nested");
assert_eq!(fs::read_to_string(right.join("kept.txt")).unwrap(), "right");
assert_eq!(fs::read_to_string(left.join("changed.txt")).unwrap(), "right");
assert_eq!(fs::read_to_string(left.join("shared/new.txt")).unwrap(), "right");
let failed: Vec<_> = failures.iter().map(|f| (f.path.as_str(), f.action)).collect();
assert_eq!(failed, [("kept.txt", Action::CopyToRight), ("missing.txt", Action::DeleteLeft)]);
let done: Vec<_> = progress.lock().iter().map(|p| (p.done, p.total)).collect();
assert_eq!(done, (0..=5).map(|d| (d, 5)).collect::<Vec<_>>());
// A path outside the roots rejects the whole batch before anything runs.
let error = fs_synchronize_directories(
&host,
"main",
left.clone(),
right.clone(),
vec![op("kept.txt", Action::CopyToRight, true), op("../escape", Action::DeleteLeft, false)],
RequestId::next(),
channel.clone(),
)
.await
.unwrap_err();
assert_eq!(error.kind, ide_core::error::ErrorKind::InvalidInput);
assert_eq!(fs::read_to_string(right.join("kept.txt")).unwrap(), "right");
let request = RequestId::next();
host.cancel_request(request);
let error = fs_synchronize_directories(
&host,
"main",
left.clone(),
right.clone(),
vec![op("kept.txt", Action::CopyToRight, true)],
request,
channel,
)
.await
.unwrap_err();
assert_eq!(error.kind, ide_core::error::ErrorKind::Cancelled);
assert_eq!(fs::read_to_string(right.join("kept.txt")).unwrap(), "right");
}
+2 -2
Переглянути файл
@@ -742,8 +742,8 @@ const PYTHON: Checks = Checks {
typed("src/tasks/models.py", "from enum import IntEnum", "import abc"),
Imports::Before("import os"),
)),
// basedpyright has no `workspace/willRenameFiles`: the IDE rewrites the imports.
file_move: Some(("src/tasks/models.py", "src/tasks/domain.py", "src/tasks/cli.py", "from .domain import")),
// basedpyright has no `workspace/willRenameFiles`.
file_move: None,
};
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-4
Переглянути файл
@@ -297,10 +297,6 @@ async fn trusted_attached_projects_are_writable_and_reach_the_window_they_are_at
.unwrap();
h.host.trust.decide(&attached, true, false).unwrap();
// The workspace's roots: the project and the attached project it trusts.
let roots: serde_json::Value = serde_json::from_str(&h.call("get_workspace_roots", json!({})).await).unwrap();
assert_eq!(roots, json!({ "projectRoot": h.root, "roots": [h.root, attached] }));
// Outside the project folder, by absolute path.
let file = attached.join("new.txt");
h.call("create_new_file", json!({"pathInProject": file, "text": "hello"})).await;
+1 -124
Переглянути файл
@@ -824,11 +824,6 @@ fn plugin_processes_end_with_their_owner() {
String::from_utf8_lossy(&ps.stdout).lines().any(|line| line.contains(&marker))
};
f.run("misbehave", "childkeep", marker.strip_prefix("--path=")).unwrap();
// fork+exec is not atomic: `ps` can still report the owner until the child execs.
let started = Instant::now() + Duration::from_secs(5);
while !alive() && Instant::now() < started {
std::thread::sleep(Duration::from_millis(10));
}
assert!(alive(), "{mode}: the process started");
match mode {
"disable" => f.host.set_enabled("misbehave", false).unwrap(),
@@ -6471,7 +6466,6 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
mode: "visual".into(),
sub: Some("linewise".into()),
}),
E::CaretMoved(ide_plugin::CaretMoved { path: path.clone(), line: 4, col: 2, settled: true }),
],
Some(PluginEditor {
path: path.clone(),
@@ -6483,7 +6477,7 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert_eq!(events.len(), 5, "{received}");
assert_eq!(events.len(), 4, "{received}");
// The first synthetic post hands over the current keys ("enabled": false);
// the second is a real diff to true. Keys come from the recomputed
// snapshot, never from the event payload ("another-plugin-key").
@@ -6492,14 +6486,6 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
assert_eq!(events[1]["kind"], "settings-changed");
assert_eq!(events[1]["data"], "[\"enabled\"]");
assert_eq!(events[3]["kind"], "input-mode-changed");
assert_eq!(events[4]["kind"], "caret-moved");
let caret: serde_json::Value =
serde_json::from_str(events[4]["data"].as_str().expect("caret data is JSON")).unwrap();
assert_eq!(caret["path"], path.as_str());
assert_eq!(caret["line"], 4);
assert_eq!(caret["col"], 2);
assert_eq!(caret["settled"], true);
assert_eq!(events[4]["editor"][0], path.as_str());
assert_eq!(events[2]["editor"][0], path);
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
}
@@ -7313,112 +7299,3 @@ fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
"freshly installed plugin got no post-install event: {received}"
);
}
#[test]
fn contributes_skills_installs_discovers_and_tracks_plugin_lifecycle() {
let f = fixture(Limits::default());
let info = f.install(&sample("agent-skills"));
assert_eq!(info.status, PluginStatus::Static);
assert!(info.warnings.is_empty(), "{:?}", info.warnings);
assert!(info.contributions.iter().any(|c| c.point == "skills" && c.label == "/release-notes"));
let dirs = f.host.skill_dirs(Some(&f.project), true);
assert_eq!(dirs.len(), 1);
assert!(dirs[0].join("SKILL.md").is_file(), "SKILL.md copied to install dir");
assert!(
dirs[0].join("references/template.md").is_file(),
"bundled supporting files in the skill folder copied to install dir"
);
let discovered = ide_agent::skills::discover_skills_with_plugins(std::slice::from_ref(&f.project), None, &dirs);
assert_eq!(discovered.len(), 1);
assert_eq!(discovered[0].name, "release-notes");
assert_eq!(discovered[0].source, ide_agent::AgentSkillSource::Plugin);
assert_eq!(discovered[0].hint.as_deref(), Some("[tag]"));
// Workspace skill with the same name wins; the plugin skill is never silently renamed.
let ws_skill = f.project.join(".agents/skills/release-notes");
std::fs::create_dir_all(&ws_skill).unwrap();
std::fs::write(ws_skill.join("SKILL.md"), "---\nname: release-notes\ndescription: workspace override\n---\n")
.unwrap();
let clashed = ide_agent::skills::discover_skills_with_plugins(std::slice::from_ref(&f.project), None, &dirs);
assert_eq!(clashed.len(), 1);
assert_eq!(clashed[0].source, ide_agent::AgentSkillSource::Workspace);
assert_eq!(clashed[0].description, "workspace override");
// Disabling or uninstalling removes the plugin's skill directories immediately.
f.host.set_enabled("test.agent-skills", false).unwrap();
assert!(f.host.skill_dirs(Some(&f.project), true).is_empty());
f.host.set_enabled("test.agent-skills", true).unwrap();
assert_eq!(f.host.skill_dirs(Some(&f.project), true).len(), 1);
f.host.uninstall("test.agent-skills").unwrap();
assert!(f.host.skill_dirs(Some(&f.project), true).is_empty());
}
#[test]
fn contributes_skills_needs_api_1_15_and_warns_without_failing_plugin_on_bad_entries() {
let f = fixture(Limits::default());
let tmp = tempfile::tempdir().unwrap();
// Older `engines.openidea` is refused at the manifest check.
let old_api = tmp.path().join("old-api");
copy_dir(&sample("agent-skills"), &old_api);
let manifest = std::fs::read_to_string(old_api.join("plugin.toml")).unwrap();
std::fs::write(old_api.join("plugin.toml"), manifest.replace("\"^1.15\"", "\"^1.14\"")).unwrap();
let err = f.host.install_from_dir(&old_api, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.15"), "{err:?}");
// Invalid skill entries emit load warnings while valid skills and the plugin itself still load.
let pkg = tmp.path().join("mixed-skills");
std::fs::create_dir_all(pkg.join("skills/good-skill")).unwrap();
std::fs::write(pkg.join("skills/good-skill/SKILL.md"), "---\nname: good-skill\ndescription: valid skill\n---\n")
.unwrap();
std::fs::create_dir_all(pkg.join("skills/wrong-name")).unwrap();
std::fs::write(
pkg.join("skills/wrong-name/SKILL.md"),
"---\nname: mismatched\ndescription: bad frontmatter name\n---\n",
)
.unwrap();
std::fs::create_dir_all(pkg.join("skills/not-skill-md")).unwrap();
std::fs::write(pkg.join("skills/not-skill-md/README.md"), "nope\n").unwrap();
std::fs::create_dir_all(pkg.join("skills/oversize")).unwrap();
std::fs::write(pkg.join("skills/oversize/SKILL.md"), "---\nname: oversize\ndescription: too big\n---\n").unwrap();
std::fs::write(pkg.join("skills/oversize/blob.bin"), vec![b'x'; (2 << 20) + 16]).unwrap();
#[allow(unused_mut)]
let mut manifest = String::from(
"id = \"acme.mixed-skills\"\n\
name = \"Mixed Skills\"\n\
version = \"1.0.0\"\n\
engines.openidea = \"^1.15\"\n\n\
[[contributes.skills]]\npath = \"skills/good-skill/SKILL.md\"\n\
[[contributes.skills]]\npath = \"../outside/SKILL.md\"\n\
[[contributes.skills]]\npath = \"skills/not-skill-md/README.md\"\n\
[[contributes.skills]]\npath = \"skills/wrong-name/SKILL.md\"\n\
[[contributes.skills]]\npath = \"skills/oversize/SKILL.md\"\n",
);
#[cfg(unix)]
{
let outside = tmp.path().join("outside.txt");
std::fs::write(&outside, "secret\n").unwrap();
std::fs::create_dir_all(pkg.join("skills/escape-link")).unwrap();
std::fs::write(
pkg.join("skills/escape-link/SKILL.md"),
"---\nname: escape-link\ndescription: has escaping symlink\n---\n",
)
.unwrap();
std::os::unix::fs::symlink(&outside, pkg.join("skills/escape-link/leak.txt")).unwrap();
manifest.push_str("[[contributes.skills]]\npath = \"skills/escape-link/SKILL.md\"\n");
}
std::fs::write(pkg.join("plugin.toml"), manifest).unwrap();
let info = f.install(&pkg);
assert_eq!(info.status, PluginStatus::Static, "bad skill entries must not fail the plugin");
let expected_warnings = if cfg!(unix) { 5 } else { 4 };
assert_eq!(info.warnings.len(), expected_warnings, "{:?}", info.warnings);
assert!(info.warnings.iter().all(|w| w.starts_with("contributes.skills[")), "{:?}", info.warnings);
let dirs = f.host.skill_dirs(Some(&f.project), true);
assert_eq!(dirs.len(), 1);
assert!(dirs[0].ends_with("skills/good-skill"), "{dirs:?}");
}
-47
Переглянути файл
@@ -1081,53 +1081,6 @@ async fn cancelling_one_request_does_not_interrupt_another_running_command() {
plugins.host().shutdown();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn remote_focus_preserves_the_editor_for_following_plugin_events() {
let (tmp, plugins, peer, _client) = command_rpc_fixture().await;
plugins.host().install_from_dir(&fixture("api14"), &Consent::all()).unwrap();
let path = tmp.path().join("project/notes.txt").to_string_lossy().into_owned();
let selection = json!({"start":{"line":4,"col":2},"end":{"line":4,"col":5}});
invoke(
&peer,
"plugin_set_active_file",
json!({"path":path,"editor":{"path":path,"language":"text","selections":[selection]}}),
)
.await
.unwrap();
for focused in [true, false] {
if !focused {
invoke(&peer, "plugin_set_active_file", json!({"path":null,"editor":null})).await.unwrap();
}
plugins.host().post_events(
Some("main"),
vec![WorkbenchEvent::InputModeChanged(ide_plugin::InputMode {
path: path.clone(),
mode: "visual".into(),
sub: None,
})],
);
plugins.host().flush_events_at(std::time::Instant::now() + Duration::from_secs(2));
assert!(plugins.host().wait_events(Duration::from_secs(5)));
let received = invoke(
&peer,
"plugin_run_command",
json!({"pluginId":"api14","commandId":"events","arg":null,"editor":null}),
)
.await
.unwrap();
let events: Value = serde_json::from_str(received.as_str().unwrap()).unwrap();
let event = events.as_array().unwrap().iter().rev().find(|e| e["kind"] == "input-mode-changed").unwrap();
if focused {
assert_eq!(event["editor"], json!([path, [[4, 2, 4, 5]]]));
} else {
assert!(event["editor"].is_null(), "lost focus must clear the previous editor: {event}");
}
}
// Older callers may omit the optional editor payload.
invoke(&peer, "plugin_set_active_file", json!({"path":path})).await.unwrap();
plugins.host().shutdown();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn a_remote_command_reads_the_clipboard_of_the_desktop_window() {
let (_tmp, plugins, peer, client) = command_rpc_fixture().await;
+2 -1
Переглянути файл
@@ -184,7 +184,8 @@ async fn serves_projects_files_documents_search_and_runs() {
std::fs::write(right.join("中文.bin"), [0, 254, 1]).unwrap();
assert_eq!(invoke(&peer, "fs_entry_kind", json!({"path": left})).await.unwrap(), "dir");
assert_eq!(invoke(&peer, "fs_entry_kind", json!({"path": left.join("中文.bin")})).await.unwrap(), "file");
let compare_args = |request| json!({"left": left, "right": right, "mode": "content", "request": request, "onProgress": {"$channel": 520}});
let compare_args =
|request| json!({"left": left, "right": right, "request": request, "onProgress": {"$channel": 520}});
let rows = invoke(&peer, "fs_compare_directories", compare_args(520)).await.unwrap();
assert_eq!(rows[0]["status"], "different");
assert!(client.channels.lock().iter().any(|c| c.id == 520 && c.data["compared"] == 1));
-7
Переглянути файл
@@ -70,13 +70,6 @@ async fn command_added_worktree_joins_the_repository_set() {
let roots = f.project.repos().roots();
assert!(roots.contains(&linked), "worktree below the project did not join the repository set: {roots:?}");
assert_eq!(roots.len(), 2);
let roots = vcs::vcs_roots(&f.host, "main").unwrap();
assert_eq!(roots[0].root, f.root);
assert_eq!(roots[0].branch_root, f.root);
assert_eq!(roots[0].head.as_deref(), Some("main"));
assert_eq!(roots[1].root, linked);
assert_eq!(roots[1].branch_root, f.root);
assert_eq!(roots[1].head.as_deref(), Some("topic"));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+27 -72
Переглянути файл
@@ -30,8 +30,6 @@ struct ExtraRoot {
path: PathBuf,
/// Shown before the paths inside it (`shared-lib/src/x.rs`).
name: String,
/// Its own exclude globs (an attached project's); `None` shares the project's.
excludes: Option<GlobSet>,
}
/// Whether an ignore-aware content walk of `root` leaves out `dir` or an ancestor.
@@ -57,32 +55,6 @@ pub fn walk_skips(root: &Path, dir: &Path) -> bool {
!walker.flatten().any(|e| e.path() == dir)
}
/// Exclude globs as gitignore reads them: a leading `/` anchors at the root, a bare name matches at any depth.
fn glob_set(exclude_globs: &[String]) -> GlobSet {
let mut set = GlobSetBuilder::new();
for raw in exclude_globs {
let p = raw.trim().trim_end_matches('/');
let anchored = p.starts_with('/');
let p = p.trim_start_matches("./").trim_start_matches('/');
if p.is_empty() {
continue;
}
let mut patterns = vec![p.to_owned()];
if !anchored && !p.contains('/') {
patterns.push(format!("**/{p}"));
}
for pat in patterns {
match GlobBuilder::new(&pat).literal_separator(true).build() {
Ok(g) => {
set.add(g);
}
Err(e) => tracing::warn!("invalid exclude glob {raw:?}: {e}"),
}
}
}
set.build().unwrap_or_else(|_| GlobSet::empty())
}
fn rel_string(rel: &Path) -> String {
let mut out = String::new();
for c in rel.components() {
@@ -121,7 +93,28 @@ pub(crate) fn mtime_of(meta: &std::fs::Metadata) -> u64 {
impl PathFilter {
pub(crate) fn new(root: &Path, extra_roots: &crate::IndexRoots, exclude_globs: &[String]) -> Self {
let excludes = glob_set(exclude_globs);
let mut set = GlobSetBuilder::new();
for raw in exclude_globs {
let p = raw.trim().trim_end_matches('/');
let anchored = p.starts_with('/');
let p = p.trim_start_matches("./").trim_start_matches('/');
if p.is_empty() {
continue;
}
let mut patterns = vec![p.to_owned()];
if !anchored && !p.contains('/') {
patterns.push(format!("**/{p}"));
}
for pat in patterns {
match GlobBuilder::new(&pat).literal_separator(true).build() {
Ok(g) => {
set.add(g);
}
Err(e) => tracing::warn!("invalid exclude glob {raw:?}: {e}"),
}
}
}
let excludes = set.build().unwrap_or_else(|_| GlobSet::empty());
let mut extra: Vec<ExtraRoot> = Vec::new();
for r in &extra_roots.folders {
let path = dunce::canonicalize(r).unwrap_or_else(|_| r.clone());
@@ -137,8 +130,7 @@ impl PathFilter {
Ok(rel) if extra_roots.include_root => rel_string(rel),
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
};
let excludes = extra_roots.excludes.get(r).map(|globs| glob_set(globs));
extra.push(ExtraRoot { name, path, excludes });
extra.push(ExtraRoot { name, path });
}
Self {
root: root.to_owned(),
@@ -167,13 +159,6 @@ impl PathFilter {
stamp.push_str(exclude);
stamp.push('\n');
}
for (folder, excludes) in &self.config.0.excludes {
stamp.push_str(&format!("-- {}\n", folder.to_string_lossy()));
for exclude in excludes {
stamp.push_str(exclude);
stamp.push('\n');
}
}
stamp
}
@@ -244,9 +229,8 @@ impl PathFilter {
})
}
/// The exclude globs below `base` (a root): its own, or the project's.
fn excludes_of(&self, base: &Path) -> &GlobSet {
self.extra.iter().find(|e| e.path == base).and_then(|e| e.excludes.as_ref()).unwrap_or(&self.excludes)
fn excluded_rel(&self, rel: &str) -> bool {
self.excludes.is_match(rel)
}
fn skip_name(name: &str) -> bool {
@@ -261,7 +245,6 @@ impl PathFilter {
if rel.is_empty() {
return true;
}
let excludes = self.excludes_of(base);
let mut prefix = String::new();
for seg in rel.split('/') {
if Self::skip_name(seg) {
@@ -271,7 +254,7 @@ impl PathFilter {
prefix.push('/');
}
prefix.push_str(seg);
if excludes.is_match(&prefix) {
if self.excluded_rel(&prefix) {
return true;
}
}
@@ -285,8 +268,8 @@ impl PathFilter {
if dir != root && self.is_excluded(dir) {
return None;
}
let excludes = self.excludes_of(root).clone();
let root = root.to_path_buf();
let excludes = self.excludes.clone();
let extra: Vec<PathBuf> = self.extra.iter().filter(|e| e.path != dir).map(|e| e.path.clone()).collect();
let mut builder = WalkBuilder::new(dir);
builder.standard_filters(false).follow_links(false).filter_entry(move |e| {
@@ -541,34 +524,6 @@ src/local/
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
}
#[test]
fn each_root_applies_its_own_excluded_folders() {
let dir = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(dir.path()).unwrap();
let (root, attached, shared) = (base.join("app"), base.join("lib"), base.join("shared"));
for f in ["app/target/a.rs", "app/gen/b.rs", "lib/target/c.rs", "lib/gen/d.rs", "shared/target/e.rs"] {
touch(&base, f);
}
let roots = crate::IndexRoots {
include_root: true,
folders: vec![attached.clone(), shared.clone()],
excludes: [(attached.clone(), vec!["/gen".to_owned()])].into(),
};
let filter = PathFilter::new(&root, &roots, &["/target".into()]);
let mut found: Vec<String> = filter
.roots()
.flat_map(|r| filter.walk(r, &AtomicBool::new(false)))
.filter_map(|f| filter.rel(&f.path))
.collect();
found.sort();
// `lib` has exclusions of its own; `shared` shares the project's.
assert_eq!(found, ["gen/b.rs", "lib/target/c.rs"]);
assert!(filter.is_excluded(&attached.join("gen/new.rs")));
assert!(!filter.is_excluded(&root.join("gen/new.rs")));
assert!(filter.stamp().contains("/gen"));
assert!(!filter.same_config(&vec![attached, shared].into(), &["/target".into()]));
}
#[test]
fn an_ignored_folder_inside_the_root_is_a_root_with_its_own_rules() {
let dir = tempfile::tempdir().unwrap();
+2 -5
Переглянути файл
@@ -92,18 +92,15 @@ pub struct ProjectIndex {
}
/// Folders indexed alongside the internal state root.
#[derive(Clone, Default, PartialEq)]
#[derive(Clone, PartialEq)]
pub struct IndexRoots {
pub include_root: bool,
pub folders: Vec<PathBuf>,
/// Folders with exclude globs of their own (an attached project's), relative to the folder;
/// the other folders share the project's.
pub excludes: std::collections::BTreeMap<PathBuf, Vec<String>>,
}
impl From<Vec<PathBuf>> for IndexRoots {
fn from(folders: Vec<PathBuf>) -> Self {
Self { include_root: true, folders, ..Default::default() }
Self { include_root: true, folders }
}
}
+3 -3
Переглянути файл
@@ -825,7 +825,7 @@ fn workspace_scope_excludes_state_from_scans_updates_and_cached_results() {
let idx = ProjectIndex::open(
&fx.root,
&fx.cache,
crate::IndexRoots { include_root: false, folders: vec![member.clone()], ..Default::default() },
crate::IndexRoots { include_root: false, folders: vec![member.clone()] },
Vec::new(),
Arc::new(LanguageRegistry::load(None).unwrap()),
Arc::new(Syntax::new()),
@@ -841,7 +841,7 @@ fn workspace_scope_excludes_state_from_scans_updates_and_cached_results() {
assert!(idx.wait_idle(WAIT));
assert!(symbols(&idx, "hidden", SymbolFilter::All).is_empty());
assert_eq!(symbols(&idx, "visible", SymbolFilter::All), ["visible"]);
idx.set_scope(crate::IndexRoots { include_root: false, folders: Vec::new(), ..Default::default() }, Vec::new());
idx.set_scope(crate::IndexRoots { include_root: false, folders: Vec::new() }, Vec::new());
assert!(idx.wait_idle(WAIT));
assert!(idx.find_files("", 100).is_empty());
}
@@ -1104,7 +1104,7 @@ fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
let idx = ProjectIndex::open(
&fx.root,
&fx.cache,
IndexRoots { include_root: false, folders: vec![fx.root.join("member")], ..Default::default() },
IndexRoots { include_root: false, folders: vec![fx.root.join("member")] },
vec![],
Arc::new(LanguageRegistry::load(None).unwrap()),
Arc::new(Syntax::new()),
-1
Переглянути файл
@@ -12,7 +12,6 @@ mod literals;
mod outline;
mod php_align;
mod python_facts;
mod python_imports;
mod rst;
mod selection;
mod sfc;
-404
Переглянути файл
@@ -1,404 +0,0 @@
//! Import updates for moved Python modules and packages, which basedpyright leaves to the
//! client (no `workspace/willRenameFiles`). Works on dotted module names; the caller maps
//! files to them from the project's roots.
use super::lines::LineIndex;
use crate::{LanguageId, Syntax};
use ide_core::TextEdit;
use tree_sitter::{Node, Tree};
impl Syntax {
/// Edits that keep the imports of a Python `text` resolving after `moves` (old → new
/// dotted names; a package covers its submodules). `package` is the package relative
/// imports start from (`a.b` for `a/b/c.py` and `a/b/__init__.py`), `new_package` the
/// same after the move.
pub fn python_import_edits(
&self,
text: &str,
package: &str,
new_package: &str,
moves: &[(String, String)],
) -> Vec<TextEdit> {
self.analyze(&LanguageId::new("python"), text, |_, tree, text| {
Some(Rewrite { text, idx: LineIndex::new(text), package, new_package, moves, edits: Vec::new() }.run(tree))
})
.unwrap_or_default()
}
}
struct Rewrite<'a> {
text: &'a str,
idx: LineIndex<'a>,
package: &'a str,
new_package: &'a str,
moves: &'a [(String, String)],
edits: Vec<TextEdit>,
}
impl Rewrite<'_> {
fn run(mut self, tree: &Tree) -> Vec<TextEdit> {
let mut imports = Vec::new();
let mut chains = Vec::new();
collect(tree.root_node(), &mut |n| match n.kind() {
"import_statement" | "import_from_statement" => imports.push(n),
"attribute" if !inside_import(n) => chains.push(n),
_ => {}
});
let mut renamed: Vec<(String, String)> = Vec::new();
for node in imports {
if node.kind() == "import_statement" {
self.import(node, &mut renamed);
} else {
self.import_from(node);
}
}
// `import a.b` is used as `a.b.x`: those chains follow the import.
for node in chains {
let t = self.src(node);
if let Some((_, new)) = renamed.iter().find(|(old, _)| *old == t) {
self.edit(node, new.clone());
}
}
self.edits.sort_by_key(|e| (e.range.start.line, e.range.start.col));
self.edits
}
fn src(&self, n: Node) -> &str {
self.text.get(n.byte_range()).unwrap_or_default()
}
fn edit(&mut self, n: Node, new_text: String) {
self.edits.push(TextEdit { range: self.idx.range(n.start_byte(), n.end_byte()), new_text });
}
/// `import a.b`, `import a.b as c`.
fn import(&mut self, node: Node, renamed: &mut Vec<(String, String)>) {
let mut cursor = node.walk();
for item in node.children_by_field_name("name", &mut cursor) {
let (name, aliased) = match item.kind() {
"aliased_import" => match item.child_by_field_name("name") {
Some(n) => (n, true),
None => continue,
},
_ => (item, false),
};
let old = self.src(name).to_owned();
let Some(new) = map_module(&old, self.moves) else { continue };
if aliased {
self.edit(name, new);
} else if old.contains('.') {
renamed.push((old, new.clone()));
self.edit(name, new);
} else {
// The bound name stays, so the rest of the file needs no change.
self.edit(name, format!("{new} as {old}"));
}
}
}
/// `from m import x`, `from .m import x as y`, `from . import m`.
fn import_from(&mut self, node: Node) {
let Some(module) = node.child_by_field_name("module_name") else { return };
let relative = (module.kind() == "relative_import").then(|| {
let mut cursor = module.walk();
let dots = module
.children(&mut cursor)
.find(|c| c.kind() == "import_prefix")
.map_or(0, |p| self.src(p).matches('.').count());
let rest = module.child(1).filter(|c| c.kind() == "dotted_name").map_or("", |c| self.src(c));
(dots, rest.to_owned())
});
let source = match &relative {
Some((dots, rest)) => match resolve(*dots, rest, self.package) {
Some(s) => s,
None => return,
},
None => self.src(module).to_owned(),
};
let target = map_module(&source, self.moves).unwrap_or_else(|| source.clone());
// Imported submodules that moved on their own (`from pkg import models`).
let mut cursor = node.walk();
let names: Vec<Node> = node.children_by_field_name("name", &mut cursor).collect();
let mut moved: Vec<(Node, String, String, String)> = Vec::new(); // (item, parent, name, bound)
for &item in &names {
let (name, alias) = match item.kind() {
"aliased_import" => (item.child_by_field_name("name"), item.child_by_field_name("alias")),
_ => (Some(item), None),
};
let Some(name) = name else { continue };
let n = self.src(name).to_owned();
let full = join(&source, &n);
let Some(new) = map_module(&full, self.moves) else { continue };
if new == join(&target, &n) {
continue;
}
let (parent, last) =
new.rsplit_once('.').map_or((String::new(), new.clone()), |(p, l)| (p.into(), l.into()));
let bound = alias.map_or(n, |a| self.src(a).to_owned());
moved.push((item, parent, last, bound));
}
let as_name =
|last: &str, bound: &str| if last == bound { last.to_owned() } else { format!("{last} as {bound}") };
// Renamed inside the same package: only the name changes.
let in_place: Vec<(Node, String)> =
moved.iter().filter(|m| m.1 == target).map(|m| (m.0, as_name(&m.2, &m.3))).collect();
moved.retain(|m| m.1 != target);
let render = |module: &str, rw: &Self| match &relative {
Some((dots, rest)) if resolve(*dots, rest, rw.new_package).as_deref() == Some(module) => None,
Some(_) => Some(relative_to(module, rw.new_package).unwrap_or_else(|| module.to_owned())),
None => Some(module.to_owned()),
};
let all_one_parent = !moved.is_empty()
&& moved.len() == names.len()
&& moved.iter().all(|m| m.1 == moved[0].1 && !m.1.is_empty());
if all_one_parent {
let parent = moved[0].1.clone();
if let Some(m) = render(&parent, self).filter(|m| m != self.src(module)) {
self.edit(module, m);
}
for (item, _, last, bound) in moved {
let new = as_name(&last, &bound);
if new != self.src(item) {
self.edit(item, new);
}
}
return;
}
if moved.is_empty() {
if let Some(m) = render(&target, self).filter(|m| m != self.src(module)) {
self.edit(module, m);
}
for (item, text) in in_place {
self.edit(item, text);
}
return;
}
// ponytail: a split statement loses a multi-line names list's layout; fine for the rare
// "some names of one `from` moved elsewhere" case.
let indent = line_indent(self.text, node.start_byte());
let mut parents: Vec<&str> = Vec::new();
for m in &moved {
if !parents.contains(&m.1.as_str()) {
parents.push(&m.1);
}
}
let mut added: Vec<String> = Vec::new();
for parent in parents {
let items: Vec<String> = moved.iter().filter(|m| m.1 == parent).map(|m| as_name(&m.2, &m.3)).collect();
added.push(if parent.is_empty() {
format!("import {}", items.join(", "))
} else {
let from = render(parent, self).unwrap_or_else(|| self.src(module).to_owned());
format!("from {from} import {}", items.join(", "))
});
}
let kept: Vec<String> = names
.iter()
.filter(|n| !moved.iter().any(|m| m.0 == **n))
.map(|n| in_place.iter().find(|(i, _)| i == n).map_or_else(|| self.src(*n).to_owned(), |(_, t)| t.clone()))
.collect();
let sep = format!("\n{indent}");
if kept.is_empty() {
self.edit(node, added.join(&sep));
return;
}
if let Some(m) = render(&target, self).filter(|m| m != self.src(module)) {
self.edit(module, m);
}
let (first, last) = (names[0], names[names.len() - 1]);
let range = self.idx.range(first.start_byte(), last.end_byte());
self.edits.push(TextEdit { range, new_text: kept.join(", ") });
let end = self.idx.pos(node.end_byte());
self.edits.push(TextEdit {
range: ide_core::Range { start: end, end },
new_text: format!("{sep}{}", added.join(&sep)),
});
}
}
fn collect<'t>(node: Node<'t>, f: &mut impl FnMut(Node<'t>)) {
f(node);
let mut cursor = node.walk();
for child in node.children(&mut cursor) {
collect(child, f);
}
}
fn inside_import(mut n: Node) -> bool {
while let Some(p) = n.parent() {
if matches!(p.kind(), "import_statement" | "import_from_statement" | "future_import_statement") {
return true;
}
n = p;
}
false
}
fn line_indent(text: &str, byte: usize) -> &str {
let start = text[..byte].rfind('\n').map_or(0, |i| i + 1);
&text[start..byte]
}
fn join(a: &str, b: &str) -> String {
match (a.is_empty(), b.is_empty()) {
(true, _) => b.to_owned(),
(_, true) => a.to_owned(),
_ => format!("{a}.{b}"),
}
}
/// `name` after `moves` (the longest moved prefix wins), if it changed.
fn map_module(name: &str, moves: &[(String, String)]) -> Option<String> {
moves
.iter()
.filter(|(from, _)| name == from || name.strip_prefix(from.as_str()).is_some_and(|r| r.starts_with('.')))
.max_by_key(|(from, _)| from.len())
.map(|(from, to)| format!("{to}{}", &name[from.len()..]))
.filter(|new| new != name)
}
/// The absolute module `from <dots><rest> import` names inside `package`.
fn resolve(dots: usize, rest: &str, package: &str) -> Option<String> {
let segs: Vec<&str> = package.split('.').filter(|s| !s.is_empty()).collect();
let keep = segs.len().checked_sub(dots.checked_sub(1)?)?;
if keep == 0 {
return None;
}
Some(join(&segs[..keep].join("."), rest))
}
/// The shortest relative form of `module` from `package`, if they share a top-level package.
fn relative_to(module: &str, package: &str) -> Option<String> {
let segs: Vec<&str> = package.split('.').filter(|s| !s.is_empty()).collect();
(1..=segs.len()).find_map(|dots| {
let base = segs[..segs.len() + 1 - dots].join(".");
let rest = if module == base { "" } else { module.strip_prefix(&base)?.strip_prefix('.')? };
Some(format!("{}{rest}", ".".repeat(dots)))
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::lines::byte_at;
fn apply(text: &str, package: &str, new_package: &str, moves: &[(&str, &str)]) -> String {
let moves: Vec<(String, String)> = moves.iter().map(|(a, b)| (a.to_string(), b.to_string())).collect();
let mut edits = Syntax::new().python_import_edits(text, package, new_package, &moves);
edits.sort_by_key(|e| std::cmp::Reverse((e.range.start.line, e.range.start.col)));
let mut out = text.to_owned();
for e in edits {
let (s, t) = (byte_at(&out, e.range.start).unwrap(), byte_at(&out, e.range.end).unwrap());
out.replace_range(s..t, &e.new_text);
}
out
}
const RENAME: &[(&str, &str)] = &[("pkg.models", "pkg.domain")];
#[test]
fn absolute_imports() {
let src = "import pkg.models\nimport pkg.models as m\nfrom pkg.models import Task, Priority\nimport pkg.modelsx\n\nx = pkg.models.Task()\ny = m.Task\n";
assert_eq!(
apply(src, "app", "app", RENAME),
"import pkg.domain\nimport pkg.domain as m\nfrom pkg.domain import Task, Priority\nimport pkg.modelsx\n\nx = pkg.domain.Task()\ny = m.Task\n"
);
}
#[test]
fn bound_names_keep_their_alias() {
let src = "from pkg import models\nfrom pkg import models as mo, cli\nimport models\n";
let moves = &[("pkg.models", "pkg.domain"), ("models", "domain")];
assert_eq!(
apply(src, "app", "app", moves),
"from pkg import domain as models\nfrom pkg import domain as mo, cli\nimport domain as models\n"
);
}
#[test]
fn relative_imports() {
let src = "from .models import Task\nfrom . import models\nfrom . import cli\n";
assert_eq!(
apply(src, "pkg", "pkg", RENAME),
"from .domain import Task\nfrom . import domain as models\nfrom . import cli\n"
);
let src = "from ..models import Task\nfrom .. import models, cli\n";
assert_eq!(
apply(src, "pkg.sub", "pkg.sub", RENAME),
"from ..domain import Task\nfrom .. import domain as models, cli\n"
);
}
#[test]
fn module_moved_to_another_package() {
let moves = &[("pkg.models", "core.models")];
assert_eq!(apply("from .models import Task\n", "pkg", "pkg", moves), "from core.models import Task\n");
assert_eq!(apply("from pkg import models\n", "app", "app", moves), "from core import models\n");
assert_eq!(
apply("def f():\n from pkg import cli, models\n", "app", "app", moves),
"def f():\n from pkg import cli\n from core import models\n"
);
let moves = &[("pkg.models", "core.models"), ("pkg.cli", "pkg.main"), ("pkg.util", "util")];
assert_eq!(
apply("from pkg import cli, models, util, other\n", "app", "app", moves),
"from pkg import main as cli, other\nfrom core import models\nimport util\n"
);
assert_eq!(
apply("from . import models\n", "pkg.sub", "pkg.sub", &[("pkg.sub.models", "pkg.models")]),
"from .. import models\n"
);
}
#[test]
fn the_moved_file_keeps_its_relative_imports_resolving() {
// pkg/cli.py → other/cli.py: `.models` (pkg.models) did not move.
let moves = &[("pkg.cli", "other.cli")];
assert_eq!(apply("from .models import Task\n", "pkg", "other", moves), "from pkg.models import Task\n");
// pkg/sub/cli.py → pkg/cli.py
let moves = &[("pkg.sub.cli", "pkg.cli")];
assert_eq!(apply("from ..models import Task\n", "pkg.sub", "pkg", moves), "from .models import Task\n");
}
#[test]
fn package_moves() {
let moves = &[("pkg", "lib.pkg")];
let src =
"import pkg\nimport pkg.models\nfrom pkg.models import Task\nfrom pkg import models\n\npkg.models.Task()\n";
assert_eq!(
apply(src, "", "", moves),
"import lib.pkg as pkg\nimport lib.pkg.models\nfrom lib.pkg.models import Task\nfrom lib.pkg import models\n\nlib.pkg.models.Task()\n"
);
// Inside the moved package, relative imports still resolve.
assert_eq!(
apply("from .models import Task\nfrom . import cli\n", "pkg", "lib.pkg", moves),
"from .models import Task\nfrom . import cli\n"
);
// Absolute self-imports follow it.
assert_eq!(
apply("from pkg.models import Task\n", "pkg", "lib.pkg", moves),
"from lib.pkg.models import Task\n"
);
}
#[test]
fn unrelated_imports_are_untouched() {
let src = "from __future__ import annotations\nimport os\nfrom datetime import date\nfrom pkgx import models\nfrom . import *\n";
assert_eq!(apply(src, "pkg", "pkg", RENAME), src);
}
#[test]
fn helpers() {
assert_eq!(resolve(1, "m", "a.b").as_deref(), Some("a.b.m"));
assert_eq!(resolve(2, "", "a.b").as_deref(), Some("a"));
assert_eq!(resolve(3, "m", "a.b"), None);
assert_eq!(relative_to("a.b.m", "a.b").as_deref(), Some(".m"));
assert_eq!(relative_to("a.c", "a.b").as_deref(), Some("..c"));
assert_eq!(relative_to("x.c", "a.b"), None);
assert_eq!(map_module("pkg.models.sub", RENAME_OWNED.as_slice()).as_deref(), Some("pkg.domain.sub"));
}
static RENAME_OWNED: std::sync::LazyLock<Vec<(String, String)>> =
std::sync::LazyLock::new(|| vec![("pkg.models".into(), "pkg.domain".into())]);
}
+5 -46
Переглянути файл
@@ -670,34 +670,21 @@ pub fn workspace_edit(conv: &Conv, e: lsp::WorkspaceEdit) -> WorkspaceEdit {
for op in ops {
match op {
lsp::DocumentChangeOperation::Edit(e) => doc_edit(&mut files, e),
// An operation its `ignoreIfExists` / `ignoreIfNotExists` makes a no-op is
// left out (vtsls' extractions "create" the file they then edit).
lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Create(c)) => {
if let Some(path) = uri_path(&c.uri) {
let overwrite = c.options.as_ref().and_then(|o| o.overwrite).unwrap_or(false);
let ignore = c.options.and_then(|o| o.ignore_if_exists).unwrap_or(false);
if !(ignore && !overwrite && path.exists()) {
files.push(FileEdit::Create { path: path.into(), overwrite });
}
let overwrite = c.options.and_then(|o| o.overwrite).unwrap_or(false);
files.push(FileEdit::Create { path: path.into(), overwrite });
}
}
lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Rename(r)) => {
if let (Some(from), Some(to)) = (uri_path(&r.old_uri), uri_path(&r.new_uri)) {
let o = r.options.as_ref();
let overwrite = o.and_then(|o| o.overwrite).unwrap_or(false);
let ignore = o.and_then(|o| o.ignore_if_exists).unwrap_or(false);
if !(ignore && !overwrite && to.exists()) {
files.push(FileEdit::Rename { from: from.into(), to: to.into() });
}
files.push(FileEdit::Rename { from: from.into(), to: to.into() });
}
}
lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Delete(d)) => {
if let Some(path) = uri_path(&d.uri) {
let recursive = d.options.as_ref().and_then(|o| o.recursive).unwrap_or(false);
let ignore = d.options.and_then(|o| o.ignore_if_not_exists).unwrap_or(false);
if !(ignore && !path.exists()) {
files.push(FileEdit::Delete { path: path.into(), recursive });
}
let recursive = d.options.and_then(|o| o.recursive).unwrap_or(false);
files.push(FileEdit::Delete { path: path.into(), recursive });
}
}
}
@@ -1439,34 +1426,6 @@ mod tests {
assert_eq!(out[1].name, "f");
}
#[test]
fn workspace_edit_leaves_out_operations_their_ignore_options_make_no_ops() {
let conv = Conv::utf16();
let dir = tempfile::tempdir().unwrap();
let existing = dir.path().join("e.ts");
std::fs::write(&existing, "").unwrap();
let missing = dir.path().join("m.ts");
let uri = |p: &Path| crate::uri::path_to_uri_string(p);
let e: lsp::WorkspaceEdit = serde_json::from_value(json!({
"documentChanges": [
{ "kind": "create", "uri": uri(&existing), "options": { "ignoreIfExists": true } },
{ "kind": "create", "uri": uri(&missing), "options": { "ignoreIfExists": true } },
{ "kind": "rename", "oldUri": uri(&missing), "newUri": uri(&existing), "options": { "ignoreIfExists": true } },
{ "kind": "delete", "uri": uri(&dir.path().join("gone.ts")), "options": { "ignoreIfNotExists": true } },
{ "kind": "delete", "uri": uri(&existing), "options": { "ignoreIfNotExists": true } }
]
}))
.unwrap();
let w = workspace_edit(&conv, e);
assert_eq!(
w.files,
[
FileEdit::Create { path: missing.into(), overwrite: false },
FileEdit::Delete { path: existing.into(), recursive: false },
]
);
}
#[test]
fn workspace_edit_document_changes() {
let conv = Conv::utf16();
+1 -3
Переглянути файл
@@ -167,9 +167,7 @@ impl Session<'_> {
"serverInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
"instructions": format!(
"Built-in OpenIDEA tools for {about}: they see the files as the IDE has them and, \
for a project open in a window, its editors. The project's workspace can include other \
projects attached to it: call `get_workspace_roots` to list them before answering about \
workspace directories or planning a change across projects."
for a project open in a window, its editors."
),
})
}
+1 -35
Переглянути файл
@@ -58,7 +58,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.15";
pub const API_VERSION: &str = "1.14";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
@@ -583,19 +583,6 @@ pub trait HostApi: Send + Sync {
cancel: &CancellationToken,
timeout: Duration,
) -> Result<ProcessOutput, HostError>;
/// Runs `cmd` with configurable capture options (API 1.15).
fn run_process_with_options(
&self,
cmd: ProcessCommand,
cwd: Option<&Path>,
stdin: Option<String>,
cancel: &CancellationToken,
timeout: Duration,
options: Option<crate::types::ProcessOptions>,
) -> Result<ProcessOutput, HostError> {
let _ = options;
self.run_process(cmd, cwd, stdin, cancel, timeout)
}
/// Delivers every event of `kind`, dropping its path filter.
fn subscribe(&self, kind: EventKind);
/// Delivers `kind` (`file-opened`, `file-saved`, `files-changed`) only for matching paths.
@@ -603,17 +590,6 @@ pub trait HostApi: Send + Sync {
fn unsubscribe(&self, kind: &str);
/// Starts `cmd` and returns the handle to it without waiting.
fn start_process(&self, cmd: ProcessCommand, cwd: Option<&Path>, client: Option<&str>) -> Result<u64, HostError>;
/// Starts `cmd` with streaming options (API 1.15).
fn start_process_stream(
&self,
cmd: ProcessCommand,
cwd: Option<&Path>,
client: Option<&str>,
options: Option<crate::types::ProcessOptions>,
) -> Result<u64, HostError> {
let _ = options;
self.start_process(cmd, cwd, client)
}
/// What process `id` printed since the last call, each stream at most
/// `max` bytes (the rest waits for the next call), and its status once it
/// ended.
@@ -1133,16 +1109,6 @@ fn event_to_wit(e: WorkbenchEvent) -> wit_events::Event {
kind: "input-mode-changed".into(),
data: serde_json::to_string(&mode).expect("mode serializes"),
}),
WorkbenchEvent::CaretMoved(caret) => wit_events::Event::Other(wit_types::Extension {
kind: "caret-moved".into(),
data: serde_json::json!({
"path": caret.path,
"line": caret.line,
"col": caret.col,
"settled": caret.settled,
})
.to_string(),
}),
WorkbenchEvent::FileOpened(p) => wit_events::Event::FileOpened(p),
WorkbenchEvent::FileSaved(p) => wit_events::Event::FileSaved(p),
WorkbenchEvent::FilesChanged(batch) => wit_events::Event::Other(wit_types::Extension {
+1 -28
Переглянути файл
@@ -155,7 +155,6 @@ pub enum EventKind {
FileSaved,
FilesChanged,
EditorFocused,
CaretMoved,
ActionPerformed,
VcsChanged,
/// Problems of the window's files changed (a language server or a report).
@@ -164,7 +163,7 @@ pub enum EventKind {
}
impl EventKind {
pub const ALL: [Self; 18] = [
pub const ALL: [Self; 17] = [
Self::DocumentChanged,
Self::WebsocketReady,
Self::FileClosed,
@@ -178,7 +177,6 @@ impl EventKind {
Self::FileSaved,
Self::FilesChanged,
Self::EditorFocused,
Self::CaretMoved,
Self::ActionPerformed,
Self::VcsChanged,
Self::ProblemsChanged,
@@ -200,7 +198,6 @@ impl EventKind {
Self::FileSaved => "file-saved",
Self::FilesChanged => "files-changed",
Self::EditorFocused => "editor-focused",
Self::CaretMoved => "caret-moved",
Self::ActionPerformed => "action-performed",
Self::VcsChanged => "vcs-changed",
Self::ProblemsChanged => "problems-changed",
@@ -278,19 +275,6 @@ pub struct InputMode {
pub sub: Option<String>,
}
/// The caret moved in the focused editor. Positions are 0-based; `col` counts
/// UTF-16 code units, as everywhere in the plugin API.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CaretMoved {
pub path: String,
pub line: u32,
pub col: u32,
/// The caret came to rest at this position; plugins may load what a hover needs.
#[serde(default)]
pub settled: bool,
}
/// One UTF-16 replacement in a locally edited editor document.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
pub struct DocumentTextChange {
@@ -353,7 +337,6 @@ pub enum WorkbenchEvent {
FileSaved(String),
FilesChanged(FilesChanged),
EditorFocused(Option<String>),
CaretMoved(CaretMoved),
ActionPerformed(ActionPerformed),
VcsChanged(String),
/// Problems of the window's files changed; plugins re-read `problems`.
@@ -377,7 +360,6 @@ impl WorkbenchEvent {
Self::FileSaved(_) => EventKind::FileSaved,
Self::FilesChanged(_) => EventKind::FilesChanged,
Self::EditorFocused(_) => EventKind::EditorFocused,
Self::CaretMoved(_) => EventKind::CaretMoved,
Self::ActionPerformed(_) => EventKind::ActionPerformed,
Self::VcsChanged(_) => EventKind::VcsChanged,
Self::ProblemsChanged => EventKind::ProblemsChanged,
@@ -560,15 +542,6 @@ pub struct ProcessChunk {
pub status: Option<i32>,
}
/// Options for process execution and streaming (API 1.15; WIT `process.process-options`).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ProcessOptions {
/// Maximum bytes captured per stream before returning an error (up to 128 MiB; default 16 MiB).
pub max_output_bytes: Option<u32>,
/// In-flight buffer size per stream for streaming backpressure (default 256 KiB, max 4 MiB).
pub buffer_bytes: Option<u32>,
}
/// Where `net:` requests may go: the URL's host when it is `https`, or
/// `http` to the loopback interface.
pub fn net_host(url: &str) -> Result<String, String> {
-45
Переглянути файл
@@ -1862,10 +1862,6 @@ fn to_output(output: crate::types::ProcessOutput) -> process::Output {
process::Output { status: output.status, stdout: output.stdout, stderr: output.stderr }
}
fn to_process_options(opts: process::ProcessOptions) -> crate::types::ProcessOptions {
crate::types::ProcessOptions { max_output_bytes: opts.max_output_bytes, buffer_bytes: opts.buffer_bytes }
}
impl process::Host for StoreData {
fn run(
&mut self,
@@ -1920,47 +1916,6 @@ impl process::Host for StoreData {
};
self.push(ChildRes { id, host: self.host.clone() }).map(Ok)
}
fn run_captured(
&mut self,
cmd: process::Command,
cwd: Option<Resource<ProjectRes>>,
stdin: Option<String>,
options: Option<process::ProcessOptions>,
) -> Fallible<process::Output> {
let cmd = match self.command(cmd) {
Ok(cmd) => cmd,
Err(e) => return Ok(Err(e)),
};
let cwd = self.cwd_of(cwd)?;
let token = self.cancel.token();
let timeout = self.io_timeout();
let opts = options.map(to_process_options);
let outcome = self.host.run_process_with_options(cmd, cwd.as_deref(), stdin, &token, timeout, opts);
if outcome.is_err() {
self.grant_io_error_grace();
}
Ok(outcome.map(to_output).map_err(to_wit))
}
fn start_stream(
&mut self,
cmd: process::Command,
cwd: Option<Resource<ProjectRes>>,
options: Option<process::ProcessOptions>,
) -> Fallible<Resource<ChildRes>> {
let cmd = match self.command(cmd) {
Ok(cmd) => cmd,
Err(e) => return Ok(Err(e)),
};
let cwd = self.cwd_of(cwd)?;
let opts = options.map(to_process_options);
let id = match self.host.start_process_stream(cmd, cwd.as_deref(), self.invocation.client.as_deref(), opts) {
Ok(id) => id,
Err(e) => return Ok(Err(to_wit(e))),
};
self.push(ChildRes { id, host: self.host.clone() }).map(Ok)
}
}
impl process::HostChild for StoreData {
+7 -11
Переглянути файл
@@ -93,7 +93,7 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.15.0");
let host = v("1.14.0");
for ok in [
"1.0.0",
"1.3.0",
@@ -108,16 +108,15 @@ fn the_version_check_runs_compatible_components_and_explains_the_rest() {
"1.12.0",
"1.13.0",
"1.14.0",
"1.15.0",
"1.0.0-rc.1",
] {
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.16.0"), &host).unwrap_err();
assert!(newer.contains("1.16") && newer.contains("update OpenIDEA"), "{newer}");
let newer = check_api(&v("1.15.0"), &host).unwrap_err();
assert!(newer.contains("1.15") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.15 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.14 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
@@ -145,17 +144,14 @@ fn shipped_components_are_built_for_this_api() {
}
#[test]
fn the_hover_actions_component_exports_the_optional_hover_actions_world() {
fn a_1_14_component_exports_the_optional_hover_actions_world() {
let engine = PluginEngine::new().unwrap();
let component =
engine.compile(&repo().join("crates/ide-plugin/tests/fixtures/hover-actions/dist/plugin.wasm")).unwrap();
let exports: Vec<String> =
component.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
assert!(
exports.iter().any(|name| name.starts_with(&format!("openidea:plugin/hover-actions@{API_VERSION}.0"))),
"{exports:?}"
);
// A plugin that does not export the optional world stays valid.
assert!(exports.iter().any(|name| name.starts_with("openidea:plugin/[email protected]")), "{exports:?}");
// A 1.13-compatible plugin that does not export the new world stays valid.
let old = engine.compile(&repo().join("plugins/official/test-runner/dist/plugin.wasm")).unwrap();
let old_exports: Vec<String> =
old.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
-9
Переглянути файл
@@ -1,9 +0,0 @@
id = "test.agent-skills"
name = "Agent Skills Fixture"
version = "1.0.0"
description = "Declarative plugin contributing an agent skill."
authors = ["OpenIDEA contributors"]
engines.openidea = "^1.15"
[[contributes.skills]]
path = "skills/release-notes/SKILL.md"
-7
Переглянути файл
@@ -1,7 +0,0 @@
---
name: release-notes
description: Draft concise release notes from merged commits and pull requests.
argument-hint: "[tag]"
---
Summarize user-visible changes since the given release tag using `references/template.md`.
-7
Переглянути файл
@@ -1,7 +0,0 @@
## Added
- Summary of user-facing features.
## Fixed
- Summary of resolved bugs.
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ef1aeca63e064ddd9c43126347fd69b39597230afe29c023effeecffb5dab627
d442e600d82cab0f79ad6decf95ca9d06c89dcd3119c500a11f48cdc54a5d5f4
+1 -1
Переглянути файл
@@ -3,7 +3,7 @@ name = "API 1.4 host tests"
version = "0.1.0"
engines.openidea = "^1.5"
wasm = "dist/plugin.wasm"
activation = ["on-command:*", "on-event:file-closed", "on-event:settings-changed", "on-event:input-mode-changed", "on-event:caret-moved"]
activation = ["on-command:*", "on-event:file-closed", "on-event:settings-changed", "on-event:input-mode-changed"]
[capabilities]
required = ["storage"]
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b5df63f7d04ab303ccf1c077187df063753a639670254c4bd64ced055e3bf806
af048639f57e86262543c3dcd18bca27d384b6ad99a625af869f0812bf8ac93c
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
52dfaac64cd496de1685d8412e4073e609a8cb4ab6e1776346aac8c18793550a
95b7263ca584c6b1b035be4dde64c7ae57b407c6a86b5ab6fe2736134e1d7754
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
0a30717897bc970afff38a916353510db23c90123b2dccc0d2b722e734dd83b3
1e5b10e8e77bdc7ed6bf002a415458caef7eee9a98123229dddf0d148af58f73
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
d41ca70e38b228af31d69302d0513db52311423f44ad5ef86e47e0f8a409a822
5b3d4ad737cde32fc808bcd8c93d9cdd7d53961985db0428ab567b4e97ed4ffb
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
e6ab772482157eae8b9bd558baf62f288899b335851e760bb4f2703dbbc52ede
04b1cbc2148cff8c0fa2d6a4f127a6a3c8ade5a7dc1541c1a16a656def299f33
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3c45e59462de19c2ebba63072d2600e8340fdb9aeafc1e0f736facb79d8f3bb9
918c44ee3a58a073dd65e2f7e32501cf9e84a59f24452c166e75457f7c232c89
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
fb64178b6cfa96e3b4c7ec03a6cf892467442c322f59d8441bc796e515607ad7
c980260c235249186f754e16597de9d49663771d711ce6873bf83ebaf2a0fc34
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
2fc18a5627776ab512afdb183ea8ea9aaf77b19496837c0f7b7287d03dc453d9
df5729d63b83fbc511e0ba8509f9d370c5124b5af4c70f286c8965d2b0d890ef
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
72d2ed671223b984982fc7740e3ea2febfadee0e37ab9490f21cd120abbd6316
305965c6cbf2fd2b331bf9e2c473cfa9a543ab39ff0d47317ee9e28be9ea5b0f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
49f428f9e258c0cc72ff6d4f85c573a1875d55a7d1cce9dc8246c950f08c2f5f
a1bb95a8a23ddd2d55bf64c724f73debfb503f252f57d8ae46afda8a0717fc20
Loaded 100 of 744 files, more files were not shown because too many files have changed in this diff. Show more