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

..
Автор SHA1 Повідомлення Дата
l0ng-ai fd2d916bfa test: fix five Windows-only test failures
- jdtls decompiled library class: the jdt handle uses the jar's portable
  path (forward slashes) as jdtls writes it on Windows.
- Plugin fuel budget: activation alone exceeded 6000 fuel on Windows. The
  budget is now 40000, and `patient` takes a per-step CPU workload so its
  whole run still exceeds the background budget without the refill.
- cpuprofile mapped sources: a Windows absolute path on Windows.
- Python member fallback: the saved command is the bare `python`, also on
  Windows.
- Checkout held by another worktree: compare with the path as git names it
  (no `\\?\` prefix).
2026-11-16 04:39:45 +08:00
126 змінених файлів з 413 додано та 4178 видалено

No files matched your search

+3 -7
Переглянути файл
@@ -208,15 +208,11 @@ jobs:
- run: pnpm build
e2e:
name: E2E (${{ matrix.shard }}/2)
name: E2E
needs: changes
if: needs.changes.outputs.frontend == 'true'
timeout-minutes: 30
runs-on: ubuntu-24.04
strategy:
fail-fast: false
matrix:
shard: [1, 2]
# Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
container: mcr.microsoft.com/playwright:v1.64.1-noble
steps:
@@ -226,12 +222,12 @@ jobs:
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm e2e --shard=${{ matrix.shard }}/2
- run: pnpm e2e
env:
HOME: /root
- uses: actions/upload-artifact@v6
if: failure()
with:
name: playwright-report-${{ matrix.shard }}
name: playwright-report
path: playwright-report/
retention-days: 7
+9 -29
Переглянути файл
@@ -262,46 +262,26 @@ jobs:
}
// The update's notes: the release body without its Download section. That
// section only matters on the release page, and What's new follows it.
// A translated section, "## 中文" added at the end of the draft before it is
// published (it runs to the next heading of its level, or the end), becomes
// `notes.zh-CN`: What's new shows it in that UI language and falls back to
// `notes`, the English rest of the body. HTML comments are dropped.
const { data: release } = await github.rest.repos.getRelease({ owner, repo, release_id });
const languages = { "中文": "zh-CN" };
const notesByLanguage = (body) => {
const parts = { "": [] };
let lang = "";
let langLevel = 0;
const withoutDownloadSection = (body) => {
const kept = [];
let skip = 0;
for (const line of body.replace(/<!--[\s\S]*?-->/g, "").split(/\r?\n/)) {
for (const line of body.split(/\r?\n/)) {
const heading = /^(#{1,6})\s+(.*)$/.exec(line);
if (heading) {
const level = heading[1].length;
const title = heading[2].trim();
if (skip && level <= skip) skip = 0;
if (lang && level <= langLevel) lang = "";
if (!skip && level <= 3 && /^download$/i.test(title)) {
if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
skip = level;
continue;
}
if (!skip && !lang && level <= 2 && languages[title]) {
lang = languages[title];
langLevel = level;
parts[lang] ??= [];
continue;
}
if (skip && level <= skip) skip = 0;
}
if (!skip) parts[lang].push(line);
if (!skip) kept.push(line);
}
return Object.fromEntries(Object.entries(parts).map(([key, lines]) => [key, lines.join("\n").trim()]));
};
const { "": notes, ...translated } = notesByLanguage(String(release.body ?? ""));
const translations = Object.fromEntries(
Object.entries(translated).filter(([, text]) => text).map(([lang, text]) => [`notes.${lang}`, text]),
);
const manifest = {
version: tag.replace(/^v/, ""), notes, ...translations, pub_date: new Date().toISOString(), platforms,
return kept.join("\n").trim();
};
const notes = withoutDownloadSection(String(release.body ?? ""));
const manifest = { version: tag.replace(/^v/, ""), notes, pub_date: new Date().toISOString(), platforms };
const old = assets.find((a) => a.name === "latest.json");
if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
await github.rest.repos.uploadReleaseAsset({
+2 -7
Переглянути файл
@@ -1204,10 +1204,7 @@ impl AgentManager {
}
/// What `provider` reports about itself, from `initialize` alone: no session is opened,
/// so no MCP server, hook or sign-in runs. A successful answer is remembered until
/// `refresh`; a failed one is not, so a transient startup failure (a CLI updating itself,
/// a busy machine) is retried on the next call instead of being shown for the rest of
/// the session.
/// so no MCP server, hook or sign-in runs. Remembered until `refresh`.
pub async fn probe(&self, provider: &str, refresh: bool) -> IdeResult<AgentProbe> {
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
return Ok(p.clone());
@@ -1269,9 +1266,7 @@ impl AgentManager {
}
Err(e) => probe.error = Some(e),
}
if probe.error.is_none() {
self.shared.probes.lock().insert(spec.id, probe.clone());
}
self.shared.probes.lock().insert(spec.id, probe.clone());
Ok(probe)
}
-34
Переглянути файл
@@ -2474,40 +2474,6 @@ async fn reload_providers_updates_registry_install_clears_stale_probes_and_notif
assert!(probe.error.is_none());
}
/// A probe that fails is not remembered, so the next new-task page tries the agent again
/// instead of showing the same startup failure until the IDE restarts.
#[tokio::test(flavor = "multi_thread")]
async fn a_failed_probe_is_retried_instead_of_remembered() {
let tmp = tempfile::tempdir().unwrap();
let calls = Arc::new(Mutex::new(0usize));
let connector: Connector = {
let calls = calls.clone();
Arc::new(move |_spec, _cwd, _client, _stderr| {
*calls.lock() += 1;
Err(std::io::Error::from(std::io::ErrorKind::NotFound))
})
};
let mgr = AgentManager::with_connector(
AgentPaths {
project_root: tmp.path().to_path_buf(),
store_dir: tmp.path().join("store"),
worktrees_dir: tmp.path().join("worktrees"),
models_file: tmp.path().join("models.json"),
custom_agents_dir: None,
home_dir: None,
env_secrets: None,
catalogs: Arc::default(),
},
tokio::runtime::Handle::current(),
connector,
);
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
assert_eq!(*calls.lock(), 2, "the second call must start the agent again");
assert!(!mgr.shared.probes.lock().contains_key("claude"));
}
/// A session report that changes the cached provider config notifies subscribers,
/// so the composer re-lists models without waiting for the next task (#1490).
/// Reports that change nothing stay silent.
-3
Переглянути файл
@@ -12,8 +12,6 @@ use std::collections::BTreeMap;
pub struct EditorGeneralSettings {
/// Change font size with ⌘ + mouse wheel.
pub wheel_zoom: bool,
/// Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors.
pub wheel_zoom_scope: String,
pub markdown_image_folder: String,
pub markdown_image_name_pattern: String,
/// Drag-and-drop of selected text inside the editor.
@@ -39,7 +37,6 @@ impl Default for EditorGeneralSettings {
fn default() -> Self {
Self {
wheel_zoom: false,
wheel_zoom_scope: "active".into(),
markdown_image_folder: "assets".into(),
markdown_image_name_pattern: "image-{timestamp}".into(),
drag_and_drop: true,
-4
Переглянути файл
@@ -69,9 +69,6 @@ pub struct GitSettings {
pub push_dialog_only_protected: bool,
/// Stashes and shelves share one tab.
pub combine_stash_and_shelf: bool,
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
/// stage and unstage instead of inclusion checkboxes, and no change lists.
pub staging_area: bool,
}
impl Default for GitSettings {
@@ -93,7 +90,6 @@ impl Default for GitSettings {
show_push_dialog: true,
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
}
}
}
-252
Переглянути файл
@@ -1,252 +0,0 @@
//! HTTP Client tools: list and run requests from project `.http` / `.rest` files.
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::path::Path;
/// Response body characters returned at most (keeps agent context bounded).
const MAX_BODY_CHARS: usize = 8_192;
pub fn tools() -> Vec<Tool> {
vec![http_list_requests(), http_run_request()]
}
fn is_http_file(path: &Path) -> bool {
path.extension()
.and_then(|e| e.to_str())
.is_some_and(|e| e.eq_ignore_ascii_case("http") || e.eq_ignore_ascii_case("rest"))
}
async fn resolve_http_file(call: &Call, path: &str) -> IdeResult<std::path::PathBuf> {
let path = call.resolve_inside(path)?;
if !is_http_file(&path) {
return Err(IdeError::invalid("path must be a .http or .rest file"));
}
if !path.is_file() {
return Err(IdeError::not_found(format!("No such file: {}", call.display(&path))));
}
Ok(path)
}
fn http_list_requests() -> Tool {
Tool::new(
"http_list_requests",
"Lists the HTTP requests in a project `.http` or `.rest` file (IntelliJ-style HTTP Client).
Returns each request's 0-based `index`, optional `name`, `method`, URL as written (variables not substituted), and `line`.
Use `http_run_request` with the same `path` and an `index` to send one.",
|call| async move {
let path = resolve_http_file(&call, &call.str("path")?).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
let requests: Vec<_> = ide_http::parse::requests(&text)
.into_iter()
.map(|b| {
json!({
"index": b.index,
"name": b.name,
"method": b.method,
"url": b.url,
"line": b.line,
})
})
.collect();
Output::json(json!({ "requests": requests }))
},
)
.param(Param::required(
"path",
ParamType::String,
"Project-relative path to a `.http` or `.rest` file",
))
.output(json!({
"type": "object",
"properties": {
"requests": {
"type": "array",
"items": {
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"line": { "type": "integer" },
},
"required": ["index", "method", "url", "line"],
},
},
},
"required": ["requests"],
}))
}
fn truncate_chars(text: &str, max: usize) -> (String, bool) {
let count = text.chars().count();
if count <= max {
return (text.to_owned(), false);
}
(text.chars().take(max).collect(), true)
}
/// Drop resolved URLs from transport errors so MCP JSON does not echo env-substituted targets.
fn redact_transport_error(error: Option<String>, resolved_url: &str) -> Option<String> {
let error = error?;
let mut out = error.replace(resolved_url, "<url>");
// reqwest often embeds `https://host/...` even when the primary URL string differs slightly.
out = redact_urls(&out);
Some(out)
}
fn redact_urls(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut rest = s;
loop {
// Prefer `https://` so we don't match the `http://` prefix inside it.
let start = match (rest.find("https://"), rest.find("http://")) {
(Some(a), Some(b)) => Some(a.min(b)),
(Some(a), None) => Some(a),
(None, Some(b)) => Some(b),
(None, None) => None,
};
let Some(start) = start else {
out.push_str(rest);
break;
};
out.push_str(&rest[..start]);
out.push_str("<url>");
let after = &rest[start..];
let end = after.find(|c: char| c.is_whitespace() || c == '\'' || c == '"' || c == ')').unwrap_or(after.len());
rest = &after[end..];
}
out
}
fn http_run_request() -> Tool {
Tool::new(
"http_run_request",
"Runs one request from a project `.http` or `.rest` file by 0-based `index`, using the IDE HTTP Client
(same as Run Request in the editor). Variables resolve from `http-client.env.json` / `http-client.private.env.json`
for the optional `env` name. Asks for confirmation with the resolved URL (and header names) first.
Returns status, timing and a truncated response body — not request headers or body (those may hold secrets).
The `url` field in the result is as written in the file (unsubstituted); transport errors redact URLs.",
|call| async move {
let rel = call.str("path")?;
let path = resolve_http_file(&call, &rel).await?;
let index =
call.opt_i64("index")?.ok_or_else(|| IdeError::invalid("missing or invalid argument `index`"))?;
if index < 0 {
return Err(IdeError::invalid("index must be >= 0"));
}
let index = index as u32;
let env = call.opt_str("env")?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
let blocks = ide_http::parse::requests(&text);
let block =
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
let input = ide_http::RunInput {
text: &text,
index,
file: Some(&path),
root: Some(call.root()),
env: env.as_deref(),
};
// Prepare before confirm so the dialog shows the real destination (after env substitution).
let prepared = ide_http::prepare(&input)?;
let subject = prepared.name.clone().unwrap_or_else(|| format!("{} {}", prepared.method, prepared.url));
let headers: Vec<_> = prepared.headers.iter().map(|(k, _)| k.as_str()).collect();
let mut detail = format!("{} {}\nFile: {rel}\nIndex: {index}", prepared.method, prepared.url);
if let Some(env) = &env {
detail.push_str(&format!("\nEnvironment: {env}"));
}
if !headers.is_empty() {
detail.push_str(&format!("\nHeaders: {}", headers.join(", ")));
}
if prepared.body.is_some() {
detail.push_str("\nBody: present");
}
call.confirm(&subject, Some(detail)).await?;
let exchange = ide_http::run(input, &call.cancel).await?;
let history = call.project().http_history.clone();
let saved = exchange.clone();
let _ = call.host().blocking(move || history.add(&saved)).await;
let (body, body_truncated) = match exchange.response.as_ref().and_then(|r| r.body.as_deref()) {
Some(b) => {
let (t, truncated) = truncate_chars(b, MAX_BODY_CHARS);
(Some(t), truncated)
}
None => (None, false),
};
let response = exchange.response.as_ref();
Output::json(json!({
"index": index,
"name": block.name,
"method": block.method,
"url": block.url,
"status": response.map(|r| r.status),
"statusText": response.map(|r| r.status_text.clone()),
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
"body": body,
"bodyTruncated": body_truncated,
}))
},
)
.write()
.param(Param::required("path", ParamType::String, "Project-relative path to a `.http` or `.rest` file"))
.param(Param::required("index", ParamType::Integer, "0-based request index from `http_list_requests`"))
.param(Param::optional(
"env",
ParamType::String,
"Environment name from `http-client.env.json` / `http-client.private.env.json`",
))
.output(json!({
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"status": { "type": ["integer", "null"] },
"statusText": { "type": ["string", "null"] },
"totalMs": { "type": ["number", "null"] },
"error": { "type": ["string", "null"] },
"body": { "type": ["string", "null"] },
"bodyTruncated": { "type": "boolean" },
},
"required": ["index", "method", "url", "bodyTruncated"],
}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_http_and_rest_extensions() {
assert!(is_http_file(Path::new("a.http")));
assert!(is_http_file(Path::new("a.REST")));
assert!(!is_http_file(Path::new("a.txt")));
}
#[test]
fn truncates_long_bodies() {
let long = "x".repeat(MAX_BODY_CHARS + 10);
let (t, truncated) = truncate_chars(&long, MAX_BODY_CHARS);
assert!(truncated);
assert_eq!(t.chars().count(), MAX_BODY_CHARS);
assert_eq!(truncate_chars("ok", MAX_BODY_CHARS), ("ok".into(), false));
}
#[test]
fn redacts_urls_in_transport_errors() {
let url = "https://secret.example/v1?token=abc";
assert_eq!(
redact_transport_error(Some(format!("error sending request for {url}")), url).as_deref(),
Some("error sending request for <url>")
);
assert_eq!(redact_urls("fail https://a.example/x and http://b/y"), "fail <url> and <url>");
}
}
-2
Переглянути файл
@@ -7,7 +7,6 @@ pub(crate) mod run;
mod vcs;
pub use requests::Requests;
mod files;
mod http;
mod page;
mod reports;
mod search;
@@ -40,7 +39,6 @@ fn tools() -> Vec<tool::Tool> {
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
tools.extend(http::tools());
tools
}
-48
Переглянути файл
@@ -1057,11 +1057,6 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
blocking(move || apply_edit(&documents, &edit)).await?;
}
open_plugin_action_target(&action, window);
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, None, command).await
{
return result;
}
if let Some(command) = action.command
&& !(action.edit.is_some() && is_client_follow_up(&project, doc, None, &command).await)
{
@@ -1613,47 +1608,9 @@ pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command:
return blocking(move || plugins.run_language_command(&plugin, &command_id, argument.as_deref(), invocation))
.await;
}
if let Some(result) = run_plugin_server_command(host, window, doc, None, &command).await {
return result;
}
host.project(window)?.lsp.execute_command(doc, command).await
}
/// Runs `command` through the plugin that claims it (`[[contributes.serverCommands]]`)
/// when no server of the document executes it itself: a code lens, code action or inlay
/// hint may carry a command the server leaves to the client. `None` when no plugin does.
async fn run_plugin_server_command(
host: &Host,
window: &str,
doc: DocId,
server: Option<ServerId>,
command: &Command,
) -> Option<IdeResult<()>> {
let plugins = crate::plugins::editor_plugin_host()?;
let project = host.project(window).ok()?;
if project.lsp.provides_command(doc, server, &command.command).await {
return None;
}
let (plugin, run) = plugins.server_command(&project.lsp.server_names(doc, server), &command.command)?;
let snap = match project.documents.snapshot(doc) {
Ok(snap) => snap,
Err(e) => return Some(Err(e)),
};
let invocation = ide_plugin::Invocation {
client: Some(window.into()),
workspace_root: Some(project.root.clone()),
editor: Some(ide_plugin::EditorContext {
path: snap.path.0.clone(),
language: snap.language.0,
selections: vec![],
}),
selected_paths: vec![snap.path.0],
..Default::default()
};
let arguments = serde_json::Value::Array(command.arguments.clone()).to_string();
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
}
/// Resolves an interactive command without applying edits or executing it.
pub async fn lsp_resolve_command(
host: &Host,
@@ -1695,11 +1652,6 @@ pub async fn lsp_execute_code_action(
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
}
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, Some(action.server), command).await
{
return result.map(|()| Vec::new());
}
match action.command {
Some(command) if edited && is_client_follow_up(&project, doc, Some(action.server), &command).await => {
Ok(Vec::new())
+9 -28
Переглянути файл
@@ -54,9 +54,8 @@ pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<Extensi
Ok(host.project(window)?.index.file_extensions())
}
pub async fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_files(&query, limit as usize))).await
pub fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_files(&query, limit as usize))
}
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
@@ -64,33 +63,18 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_dirs(&query, limit as usize))).await
pub fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_dirs(&query, limit as usize))
}
pub async fn find_symbols(
pub fn find_symbols(
host: &Host,
window: &str,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_symbols(&query, filter, limit as usize))).await
}
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder),
/// at most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
pub async fn find_symbols_named(
host: &Host,
window: &str,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
const SYMBOLS_PER_NAME: usize = 50;
let project = host.project(window)?;
blocking(move || Ok(project.index.symbols_named_any(&names, &PathBuf::from(within), SYMBOLS_PER_NAME))).await
Ok(host.project(window)?.index.find_symbols(&query, filter, limit as usize))
}
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
@@ -334,14 +318,11 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
pub(crate) fn register(d: &mut Dispatcher) {
d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_files_named", |c| async move { find_files_named(&c.host, &c.window, c.arg("name")?).await });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_symbols", |c| async move {
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?).await
});
d.add("find_symbols_named", |c| async move {
find_symbols_named(&c.host, &c.window, c.arg("names")?, c.arg("within")?).await
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
});
d.add("mark_recent", |c| async move { mark_recent(&c.host, &c.window, c.arg("path")?) });
d.add("remove_recent", |c| async move { remove_recent(&c.host, &c.window, c.arg("path")?) });
-29
Переглянути файл
@@ -313,35 +313,6 @@ impl PluginHost {
}
}
impl PluginHost {
/// The plugin command that runs `command`, which one of the language servers
/// `servers` handed to the client (`[[contributes.serverCommands]]`): the plugin
/// and its command id. A plugin counts while it holds `lsp:<server>`; when several
/// claim the same server and command, the first one loaded keeps it.
pub(crate) fn server_command(&self, servers: &[String], command: &str) -> Option<(String, String)> {
let mut claims = self.ui.items(super::ui_points::SERVER_COMMANDS, None).into_iter().filter_map(|item| {
let decl: super::ui_points::ServerCommandDecl = serde_json::from_value(item.decl).ok()?;
let claimed = decl.command == command && servers.contains(&decl.server);
let grant = ide_extension::Capability::Lsp(decl.server.clone());
let granted = claimed
&& self.get(&item.plugin_id).is_ok_and(|p| p.meta.lock().granted.iter().any(|g| g.covers(&grant)));
granted.then_some((item.plugin_id, decl.server, decl.run))
});
let (plugin, server, run) = claims.next()?;
for (other, _, _) in claims.filter(|(other, s, _)| *other != plugin && *s == server) {
static LOGGED: parking_lot::Mutex<std::collections::BTreeSet<(String, String, String)>> =
parking_lot::Mutex::new(std::collections::BTreeSet::new());
if LOGGED.lock().insert((other.clone(), server.clone(), command.to_owned())) {
tracing::warn!(
"plugins {plugin} and {other} both claim command `{command}` of language server {server}; \
{plugin} was loaded first and keeps it"
);
}
}
Some((plugin, run))
}
}
pub(crate) fn signature_help(h: SignatureHelp) -> ide_lsp::types::SignatureHelp {
let signatures: Vec<_> = h
.signatures
-1
Переглянути файл
@@ -93,7 +93,6 @@ pub fn register_builtin_points(
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
registry.register(Arc::new(UiPoint::new(p::COMMIT_CHECKS, ui.clone(), p::commit_check)))?;
registry.register(Arc::new(UiPoint::new(p::SERVER_COMMANDS, ui.clone(), p::server_command)))?;
registry.register(Arc::new(UiPoint::new(ide_extension::LOCALES_POINT, ui.clone(), p::locales)))?;
Ok(())
}
-37
Переглянути файл
@@ -46,11 +46,6 @@
//! id = "conventional"
//! title = "Conventional Commits" # Commit Options › Before Commit; `commit-checker.check` runs it
//!
//! [[contributes.serverCommands]]
//! server = "phoxite" # the language server whose results carry the command
//! command = "laravel.modelView" # a command the server leaves to the client
//! run = "model-view" # this plugin's command; needs `lsp:phoxite`
//!
//! [[contributes.fileTemplates]]
//! id = "drawing"
//! name = "Excalidraw Drawing"
@@ -77,7 +72,6 @@ pub const FILE_ICONS: &str = "fileIcons";
pub const MARKER_ICONS: &str = "markerIcons";
pub const FILE_TEMPLATES: &str = "fileTemplates";
pub const COMMIT_CHECKS: &str = "commitChecks";
pub const SERVER_COMMANDS: &str = "serverCommands";
const VIEW_ITEM_MENU: &str = "viewItem.context";
/// The toolbar above the commit message (Commit tool window and dialog).
@@ -970,37 +964,6 @@ pub(super) fn commit_check(pkg: &Package, decl: toml::Value) -> Result<UiDecl, S
Ok(UiDecl::new(d.id.clone(), d.title.clone(), json(&d)?))
}
/// A command a language server's code lens, code action or inlay hint carries and
/// leaves to the client, and the plugin command that runs it.
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub(super) struct ServerCommandDecl {
/// The server's name in its language definition.
pub(super) server: String,
pub(super) command: String,
/// The plugin's command (`[[contributes.commands]]`); it gets the arguments as JSON.
pub(super) run: String,
}
/// `[[contributes.serverCommands]]` (API 1.9): routes a command no server executes
/// itself to the plugin's own command.
pub(super) fn server_command(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
let d: ServerCommandDecl = decode(SERVER_COMMANDS, decl)?;
pkg.manifest.needs_api(&format!("contributes.{SERVER_COMMANDS}"), 9)?;
if d.command.is_empty() || d.command.len() > 256 {
return Err(format!("contributes.{SERVER_COMMANDS}: command names are 1–256 bytes"));
}
declared_command(pkg, SERVER_COMMANDS, &d.run)?;
let grant: ide_extension::Capability =
format!("lsp:{}", d.server).parse().map_err(|e| format!("contributes.{SERVER_COMMANDS}: {e}"))?;
if !pkg.manifest.capabilities.all().any(|c| *c == grant) {
return Err(format!(
"contributes.{SERVER_COMMANDS}: needs the `{grant}` capability (the command comes from that server)"
));
}
Ok(UiDecl::new(format!("{}:{}", d.server, d.command), d.command.clone(), json(&d)?))
}
const MAX_CATALOG_ENTRIES: usize = 20_000;
pub fn locale_asset(tag: &str) -> String {
-1
Переглянути файл
@@ -500,7 +500,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "find_files_named"
| "find_dirs"
| "find_symbols"
| "find_symbols_named"
| "mark_recent"
| "remove_recent"
| "recent_files"
-73
Переглянути файл
@@ -697,76 +697,3 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
let interrupted = h.json("wait_for_run", json!({"name": "interrupt", "timeout": 10000})).await;
assert_eq!(interrupted["state"], "stoppedByAgent", "{interrupted}");
}
#[tokio::test(flavor = "multi_thread")]
async fn http_list_and_run_require_confirmation() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let h = Harness::new();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut buf = [0u8; 1024];
let _ = socket.read(&mut buf).await;
let body = b"{\"ok\":true}";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
body.len(),
std::str::from_utf8(body).unwrap()
);
let _ = socket.write_all(response.as_bytes()).await;
});
std::fs::write(
h.root.join("api.http"),
format!(
"### Health\nGET http://{addr}/health\nAccept: application/json\n\n### Echo\n# @name echo\nGET http://{addr}/echo\n"
),
)
.unwrap();
std::fs::write(h.root.join("http-client.env.json"), r#"{"dev":{"unused":"x"}}"#).unwrap();
let listed = h.json("http_list_requests", json!({"path": "api.http"})).await;
assert_eq!(listed["requests"].as_array().unwrap().len(), 2, "{listed}");
assert_eq!(listed["requests"][0]["index"], 0);
assert_eq!(listed["requests"][0]["name"], "Health");
assert_eq!(listed["requests"][0]["method"], "GET");
assert_eq!(listed["requests"][1]["name"], "echo");
assert!(listed["requests"][0]["url"].as_str().unwrap().contains("/health"));
// Write tool is hidden until the project is trusted.
assert!(Registry::new(h.host.clone()).tools(&h.root).unwrap().iter().all(|t| t.name != "http_run_request"));
h.trust().await;
assert!(
Registry::new(h.host.clone())
.tools(&h.root)
.unwrap()
.iter()
.any(|t| t.name == "http_run_request" && !t.read_only)
);
h.host.mcp_requests.set_ready("main", true);
let denied = h.error("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let deny = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, false, None).unwrap();
};
let (error, ()) = tokio::join!(denied, deny);
assert!(error.contains("denied by the user"), "{error}");
h.events.lock().unwrap().clear();
let run = h.json("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let allow = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, true, None).unwrap();
};
let (result, ()) = tokio::join!(run, allow);
assert_eq!(result["status"], 200, "{result}");
assert_eq!(result["method"], "GET");
assert!(result["body"].as_str().unwrap().contains("ok"), "{result}");
assert_eq!(result["bodyTruncated"], false);
// Secrets must not appear as request headers/body in the tool payload.
assert!(result.get("headers").is_none(), "{result}");
assert!(result.get("request").is_none(), "{result}");
}
-184
Переглянути файл
@@ -1,184 +0,0 @@
//! `[[contributes.serverCommands]]` (plugin API 1.9): a command a language server hands to the
//! client runs the plugin command that claims it. The fixture's command sends its argument
//! back to the server (`mock/ran`), through the real component runtime and `language-servers`.
use ide_host::plugins::{Consent, HostWorkspace, PluginHost, set_editor_providers};
use ide_host::{Host, HostConfig, ops};
use ide_jsonrpc::{Handler, Peer};
use ide_lsp::types::Command;
use ide_plugin::Limits;
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::{path::Path, sync::Arc, time::Duration};
const ID: &str = "test.lsp-requests";
const SECOND: &str = "test.lsp-second";
fn fixture() -> std::path::PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/lsp-requests")
}
/// The fixture under `dir` with `edit` applied to its manifest.
fn variant(dir: &Path, edit: impl Fn(&str) -> String) -> std::path::PathBuf {
fn copy(from: &Path, to: &Path) {
std::fs::create_dir_all(to).unwrap();
for entry in std::fs::read_dir(from).unwrap() {
let entry = entry.unwrap();
match entry.file_type().unwrap().is_dir() {
true if entry.file_name() != "target" => copy(&entry.path(), &to.join(entry.file_name())),
true => {}
false => drop(std::fs::copy(entry.path(), to.join(entry.file_name())).unwrap()),
}
}
}
copy(&fixture(), dir);
let manifest = dir.join("plugin.toml");
std::fs::write(&manifest, edit(&std::fs::read_to_string(&manifest).unwrap())).unwrap();
dir.to_path_buf()
}
/// A language server named `mock`: it executes `mock.own` itself and records what it gets.
#[derive(Default)]
struct Mock {
requests: Mutex<Vec<(String, Value)>>,
notifications: Mutex<Vec<(String, Value)>>,
}
impl Mock {
fn ran(&self) -> Vec<Value> {
self.notifications.lock().iter().filter(|(m, _)| m == "mock/ran").map(|(_, p)| p.clone()).collect()
}
fn executed(&self) -> Vec<Value> {
let requests = self.requests.lock();
requests.iter().filter(|(m, _)| m == "workspace/executeCommand").map(|(_, p)| p["command"].clone()).collect()
}
}
impl Handler for Mock {
fn on_notification(&self, method: &str, p: Value) {
self.notifications.lock().push((method.to_owned(), p));
}
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
self.requests.lock().push((method.to_owned(), p));
Ok(match method {
"initialize" => json!({ "capabilities": {
"textDocumentSync": { "openClose": true, "change": 1 },
"executeCommandProvider": { "commands": ["mock.own"] },
} }),
_ => Value::Null,
})
}
}
async fn eventually(what: &str, mut f: impl FnMut() -> bool) {
for _ in 0..500 {
if f() {
return;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
panic!("timed out waiting for {what}");
}
fn command(name: &str, arguments: Vec<Value>) -> Command {
Command { title: "Lens".into(), command: name.into(), arguments }
}
#[tokio::test(flavor = "multi_thread")]
async fn a_command_the_server_leaves_to_the_client_runs_the_plugin_that_claims_it() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
let host = Arc::new(Host::new(HostConfig {
config_dir: tmp.path().join("config"),
data_dir: tmp.path().join("data"),
local_data_dir: tmp.path().join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(ide_core::NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
}));
// Language servers start only in a trusted project.
host.set_project_trust(&root, true, false).await.unwrap();
host.open_project("main", &root).unwrap();
let plugins = Arc::new(
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
);
plugins.set_workspace(Some(Arc::new(HostWorkspace(Arc::downgrade(&host)))));
set_editor_providers(Some(&plugins));
// The manifest must hold the grant of the server whose commands it claims.
let ungranted = variant(&tmp.path().join("ungranted"), |m| m.replace("optional = [\"lsp:mock\"]", "optional = []"));
let err = plugins.install_from_dir(&ungranted, &Consent::all()).unwrap_err();
assert!(err.message.contains("needs the `lsp:mock` capability"), "{err:?}");
plugins.install_from_dir(&fixture(), &Consent::all()).unwrap();
// The server `mock` serves the project's text files.
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let port = listener.local_addr().unwrap().port();
let mock = Arc::new(Mock::default());
let peers = Arc::new(Mutex::new(Vec::<Peer>::new()));
let (accepted, state) = (peers.clone(), mock.clone());
let server = tokio::spawn(async move {
while let Ok((stream, _)) = listener.accept().await {
let (r, w) = stream.into_split();
accepted.lock().push(Peer::connect(r, w, state.clone()));
}
});
let cfg: ide_language::LanguageServerConfig =
toml::from_str(&format!("name='mock'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
let project = host.project("main").unwrap();
project.lsp.set_servers_hook(Box::new(move |_, _| vec![cfg.clone()]));
let path = root.join("a.txt");
std::fs::write(&path, "class Post {}\n").unwrap();
let doc = ops::doc::open(&host, "main", path.clone()).await.unwrap().id;
project.lsp.did_open(
doc,
&path,
&ide_core::LanguageId::plain_text(),
0,
"class Post {}
",
);
eventually("the server to be ready", || {
project.lsp.servers().iter().any(|s| s.name == "mock" && s.status == ide_core::event::ServerStatus::Ready)
})
.await;
// A lens command the server does not execute: the plugin's command gets the arguments as JSON.
let lens = command("mock.modelView", vec![json!("App\\Models\\Post"), json!({ "line": 3 })]);
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the plugin's command", || !mock.ran().is_empty()).await;
assert_eq!(mock.ran(), [json!(["App\\Models\\Post", { "line": 3 }])]);
assert!(mock.executed().is_empty(), "the server was not asked to execute it");
// A command in the server's `executeCommandProvider` still goes to the server.
ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.own", vec![])).await.unwrap();
assert_eq!(mock.executed(), [json!("mock.own")]);
assert_eq!(mock.ran().len(), 1);
// A command nobody claims fails as before.
let err = ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.unclaimed", vec![])).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
// Two plugins claim the same server and command: the first one loaded keeps it.
let second = variant(&tmp.path().join("second"), |m| m.replace(ID, SECOND));
plugins.install_from_dir(&second, &Consent::all()).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the first plugin's command again", || mock.ran().len() == 2).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 0, "the second plugin never ran");
// A claim counts only while the plugin holds the server's grant.
plugins.set_capability(ID, "lsp:mock", false).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the second plugin's command", || mock.ran().len() == 3).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 1);
plugins.set_capability(SECOND, "lsp:mock", false).unwrap();
let err = ops::lsp::lsp_execute_command(&host, "main", doc, lens).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
assert_eq!(mock.ran().len(), 3);
set_editor_providers(None);
server.abort();
}
+14 -18
Переглянути файл
@@ -70,14 +70,10 @@ async fn open(fixture: &str) -> Opened {
}
/// Polls `check` until it holds; fails with its last answer.
async fn until<T: std::fmt::Debug, F, Fut>(what: &str, timeout: Duration, mut check: F)
where
F: FnMut() -> Fut,
Fut: std::future::Future<Output = Result<(), T>>,
{
async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: impl FnMut() -> Result<(), T>) {
let deadline = Instant::now() + timeout;
loop {
match check().await {
match check() {
Ok(()) => return,
Err(last) if Instant::now() > deadline => panic!("{what}: timed out after {timeout:?}; last: {last:?}"),
Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,
@@ -86,25 +82,25 @@ where
}
impl Opened {
async fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).await.unwrap();
fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).unwrap();
found.into_iter().map(|f| f.rel_path).collect()
}
async fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).await.unwrap();
fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).unwrap();
found.into_iter().map(|s| (s.name, s.rel_path)).collect()
}
async fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter).await;
fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter);
if found.iter().any(|(n, f)| n == name && f == file) { Ok(()) } else { Err(found) }
}
}
async fn smoke(f: Fixture) {
let p = open(f.dir).await;
until("indexing", Duration::from_secs(30), || async {
until("indexing", Duration::from_secs(30), || {
let s = ops::nav::index_status(&p.host, WINDOW).unwrap();
if !s.indexing && s.files > 0 && s.symbols > 0 { Ok(()) } else { Err(s) }
})
@@ -119,12 +115,12 @@ async fn smoke(f: Fixture) {
);
}
let files = p.files(f.file.0).await;
let files = p.files(f.file.0);
assert!(files.iter().any(|r| r == f.file.1), "{}: files for {:?}: {files:?}", f.dir, f.file.0);
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types).await {
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types) {
panic!("{}: Go to Class {:?}: {found:?}", f.dir, f.class.0);
}
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All).await {
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All) {
panic!("{}: Go to Symbol {:?}: {found:?}", f.dir, f.symbol.0);
}
@@ -134,8 +130,8 @@ async fn smoke(f: Fixture) {
until("a new file's class", Duration::from_secs(20), || p.has_symbol("FreshWidget", added, SymbolFilter::Types))
.await;
std::fs::remove_file(p.root.join(added)).unwrap();
until("a deleted file's class", Duration::from_secs(20), || async {
let found = p.symbols("FreshWidget", SymbolFilter::Types).await;
until("a deleted file's class", Duration::from_secs(20), || {
let found = p.symbols("FreshWidget", SymbolFilter::Types);
if found.is_empty() { Ok(()) } else { Err(found) }
})
.await;
+2 -10
Переглянути файл
@@ -646,16 +646,8 @@ impl IndexData {
}
}
/// Refreshes on-disk metadata of an unchanged-content file in place and
/// returns its persisted record.
pub(crate) fn refresh_metadata(&mut self, path: &Path, mtime: u64, size: u64, ignored: bool) -> Option<FileRecord> {
let slot = *self.by_path.get(path)?;
let e = self.files[slot as usize].as_mut()?;
e.mtime = mtime;
e.size = size;
e.ignored = ignored;
let e = self.files[slot as usize].as_ref()?;
Some(self.record(e))
pub(crate) fn record_of(&self, path: &Path) -> Option<FileRecord> {
self.get(path).map(|e| self.record(e))
}
/// The symbols of one file, in declaration order.
-5
Переглянути файл
@@ -323,11 +323,6 @@ impl ProjectIndex {
matching::symbols_named_within(&self.shared.data.read(), name, kind, roots, limit)
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per name.
pub fn symbols_named_any(&self, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
matching::symbols_named_any(&self.shared.data.read(), names, root, limit)
}
/// Incrementally re-indexes changed paths (called from the vfs watcher).
/// Cheap: the work is queued for the indexing thread.
pub fn update(&self, changed: &[PathBuf], removed: &[PathBuf]) {
-35
Переглянути файл
@@ -632,41 +632,6 @@ pub(crate) fn symbols_named_within(
out
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per
/// name, by path then position: one walk over the index for every name an agent reply shows.
pub(crate) fn symbols_named_any(data: &IndexData, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
let wanted: Vec<(u64, &str)> = names.iter().map(|name| (char_mask(name), name.as_str())).collect();
let syms = &data.syms;
let mut out: Vec<SymbolMatch> = data
.files
.iter()
.flatten()
.filter(|entry| entry.path.starts_with(root))
.flat_map(|entry| {
(entry.sym_start..entry.sym_start + entry.sym_len)
.filter(|&at| wanted.iter().any(|&(mask, name)| syms.mask(at) == mask && syms.name(at) == name))
.map(move |at| SymbolMatch {
name: syms.name(at).to_string(),
kind: syms.kind(at),
container: syms.container(at).map(str::to_owned),
path: entry.path.clone().into(),
rel_path: entry.rel.to_string(),
range: syms.range(at),
score: 0,
indices: Vec::new(),
})
})
.collect();
out.sort_by(|left, right| left.rel_path.cmp(&right.rel_path).then_with(|| left.range.cmp(&right.range)));
let mut kept: HashMap<String, usize> = HashMap::new();
out.retain(|symbol| {
let count = kept.entry(symbol.name.clone()).or_default();
*count += 1;
*count <= limit
});
out
}
#[cfg(test)]
mod tests {
use super::*;
+2 -107
Переглянути файл
@@ -549,24 +549,6 @@ fn symbols_named_within_keeps_out_of_root_matches_from_evicting_a_root() {
assert!(idx.symbols_named_within("Decoder", None, &[f.root.join("none")], 3).is_empty());
}
#[test]
fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
let fixture = Fixture::new(&[
("app/a.rs", "struct Config;\nfn load() {}\nfn load_all() {}\n"),
("app/b.rs", "fn load() {}\nfn load() {}\n"),
("other/c.rs", "struct Config;\n"),
]);
let idx = fixture.open();
let names = ["Config".to_string(), "load".to_string(), "missing".to_string()];
let found: Vec<(String, String)> = idx
.symbols_named_any(&names, &fixture.root.join("app"), 2)
.into_iter()
.map(|symbol| (symbol.name, symbol.rel_path))
.collect();
let expected = [("Config", "app/a.rs"), ("load", "app/a.rs"), ("load", "app/b.rs")];
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
}
#[test]
fn content_roots_and_excludes_change_without_reopening() {
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
@@ -797,13 +779,8 @@ fn incremental_changes_refresh_the_warm_start_snapshot() {
let changed = f.write("src/a.rs", "fn renamed() {}\n");
idx.update(&[changed], &[]);
assert!(idx.wait_idle(WAIT));
// The snapshot is written after a short delay, on the worker's next round.
let snapshot = f.cache.join("index.snapshot");
let deadline = std::time::Instant::now() + WAIT;
while !snapshot.exists() && std::time::Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(20));
}
assert!(snapshot.exists(), "a watcher update must regenerate the snapshot");
std::thread::sleep(Duration::from_millis(150));
assert!(f.cache.join("index.snapshot").exists(), "a watcher update must regenerate the snapshot");
}
#[test]
@@ -985,85 +962,3 @@ fn warm_start_sees_edits_deletions_and_renames_made_while_closed() {
assert_eq!(idx.status().files, 3);
assert_eq!(symbols(&idx, "zzzz", SymbolFilter::All), ["zzzz"]);
}
#[test]
fn queries_during_streaming_scan_do_not_deadlock() {
// More than `2 * SCAN_BATCH` (4,096) files so a scan both flushes mid-pass
// (`publish` -> `data.write()`) and fills the bounded parse channel while
// concurrent queries hold `data.read()` and dispatch onto Rayon.
const FILES: usize = 4_600;
let f = Fixture::new(&[]);
for m in 0..32 {
std::fs::create_dir_all(f.root.join(format!("mod{m}"))).unwrap();
}
for i in 0..FILES {
std::fs::write(
f.root.join(format!("mod{}/File{i}.rs", i % 32)),
format!("pub struct Type{i};\npub fn sym{i}() {{}}\n"),
)
.unwrap();
}
let (done_tx, done_rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let languages = Arc::new(LanguageRegistry::load(None).unwrap());
let syntax = Arc::new(Syntax::new());
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let idx =
ProjectIndex::open(&f.root, &f.cache, Vec::new(), vec![], languages, syntax, Arc::new(NullSink)).unwrap();
let readers: Vec<_> = (0..4usize)
.map(|r| {
let idx = idx.clone();
let stop = stop.clone();
std::thread::spawn(move || {
let mut n = r;
while !stop.load(Ordering::Relaxed) {
match n % 3 {
0 => {
let _ = idx.find_files("File1", 20);
}
1 => {
let _ = idx.find_dirs("mod", 20);
}
_ => {
let _ = idx.find_symbols("sym1", SymbolFilter::All, 20);
}
}
n = n.wrapping_add(1);
}
})
})
.collect();
assert!(idx.wait_idle(WAIT), "initial streaming scan did not finish");
let parsed_before = idx.shared.parsed.load(Ordering::SeqCst);
assert_eq!(parsed_before, FILES);
// Touch every file without changing its contents so `parse_found` takes
// the `Extracted::Unchanged` path across multiple `SCAN_BATCH` flushes.
let bumped = std::fs::FileTimes::new().set_modified(std::time::SystemTime::now() + Duration::from_secs(10));
for i in 0..FILES {
let path = f.root.join(format!("mod{}/File{i}.rs", i % 32));
std::fs::File::options().write(true).open(path).unwrap().set_times(bumped).unwrap();
}
idx.shared.enqueue(Job::Rescan);
assert!(idx.wait_idle(WAIT), "rescan of unchanged-content files did not finish");
assert_eq!(idx.shared.parsed.load(Ordering::SeqCst), parsed_before, "unchanged content is not re-parsed");
assert_eq!(symbols(&idx, "sym4599", SymbolFilter::All), ["sym4599"]);
stop.store(true, Ordering::Relaxed);
for h in readers {
h.join().unwrap();
}
assert_eq!(idx.status().files, FILES as u32);
drop(idx);
let reopened = f.open();
assert_eq!(reopened.shared.parsed.load(Ordering::SeqCst), 0);
assert_eq!(symbols(&reopened, "sym4599", SymbolFilter::All), ["sym4599"]);
let _ = done_tx.send(());
});
done_rx.recv_timeout(Duration::from_secs(60)).expect("concurrent index queries deadlocked with streaming scan");
}
+80 -145
Переглянути файл
@@ -11,21 +11,9 @@ use rayon::prelude::*;
use std::collections::{HashMap, HashSet, VecDeque};
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::LazyLock;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant, SystemTime};
/// Dedicated pool for background indexing and snapshot hydration: queries hold
/// `IndexData::read` while scanning on the global Rayon pool, so indexing work
/// (which may block on channel backpressure while the index thread waits for
/// `IndexData::write`) must never compete for the same workers.
static INDEX_POOL: LazyLock<rayon::ThreadPool> = LazyLock::new(|| {
rayon::ThreadPoolBuilder::new()
.thread_name(|i| format!("openidea-index-{i}"))
.build()
.expect("cannot build index thread pool")
});
/// Files larger than this are listed but not parsed for symbols.
pub const MAX_SYMBOL_FILE: u64 = 2 * 1024 * 1024;
const CHUNK: usize = 512;
@@ -266,19 +254,17 @@ impl Shared {
}
}
let build_started = Instant::now();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect()
});
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = (0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect();
let built = build_started.elapsed();
if entries.iter().any(Option::is_none) {
return false;
@@ -347,19 +333,17 @@ impl Shared {
let started = Instant::now();
match store.load_snapshot() {
Some(snapshot) => {
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect()
});
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = (0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect();
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -379,18 +363,16 @@ impl Shared {
Ok(records) => {
// Fallback for an index that changed since the snapshot: redb
// records are decoded one file at a time and filtered by the walk.
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect()
});
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect();
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -464,11 +446,10 @@ impl Shared {
}
let classify_started = Instant::now();
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
let (todo, stale) = {
let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
let d = self.data.read();
let todo: Vec<(&Found, Option<ContentHash>)> =
found.iter().filter_map(|f| prev_hash_if_stale(&d, f).map(|h| (f, h))).collect();
let stale: Vec<PathBuf> = d
let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
let stale = d
.paths()
.filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
.filter(|p| !seen.contains(p.as_path()))
@@ -489,7 +470,7 @@ impl Shared {
let total = todo.len();
let mut laps = ChunkLaps::default();
{
// One streaming parallel pass: parse on `INDEX_POOL` without
// One streaming parallel pass: parse on the rayon pool without
// per-chunk joins (a straggler file at a join's tail idles every
// other core), while parsed files flow to this thread to be
// inserted and persisted in batches. `filter` moves into the
@@ -504,14 +485,12 @@ impl Shared {
let pass_started = Instant::now();
std::thread::scope(|scope| -> () {
scope.spawn(move || {
INDEX_POOL.install(|| {
todo.par_iter().for_each(|&(f, prev_hash)| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, prev_hash, &filter) else { return };
let _ = tx.send(out);
});
todo.par_iter().for_each(|f| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, &filter, false) else { return };
let _ = tx.send(out);
});
// `tx` drops here: the consumer's loop ends with the channel.
});
@@ -591,13 +570,13 @@ impl Shared {
}
/// Extracts records in parallel, then publishes them to memory and disk.
fn index_files(&self, files: &[(Found, Option<ContentHash>)]) -> ChunkLaps {
/// `force` re-parses files whose content is unchanged (their language changed).
fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let files: Vec<&Found> = files.collect();
let filter = self.filter();
let started = Instant::now();
let extracted: Vec<ParsedFile> = INDEX_POOL.install(|| {
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
});
let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
laps.extract = started.elapsed();
if extracted.is_empty() {
return laps;
@@ -606,69 +585,49 @@ impl Shared {
laps
}
/// Reads and parses one file on `INDEX_POOL` without locking `self.data`,
/// serializing new records for the cache alongside the parse. `None` when
/// the file is outside the scope or the scan was cancelled.
fn parse_found(
&self,
f: &Found,
prev_hash: Option<ContentHash>,
filter: &std::sync::Arc<PathFilter>,
) -> Option<ParsedFile> {
/// Reads and parses one file (parallel-safe), serializing its record for
/// the cache alongside the parse. `None` when the file is outside the
/// scope or the scan was cancelled.
fn parse_found(&self, f: &Found, filter: &std::sync::Arc<PathFilter>, force: bool) -> Option<ParsedFile> {
if self.is_cancelled() {
return None;
}
let rel = filter.rel(&f.path)?;
let key = filter.store_key(&f.path);
let outcome = match self.extract(f, prev_hash) {
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
Extracted::New(rec) => {
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
ParsedOutcome::New { rec, bytes }
let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
let rec = match self.extract(f, prev_hash) {
Extracted::Unchanged => {
// Same content, new mtime: keep the symbols, refresh metadata.
let mut rec = self.data.read().record_of(&f.path)?;
rec.mtime = f.mtime;
rec.size = f.size;
rec.ignored = f.ignored;
rec
}
Extracted::New(rec) => rec,
};
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
let key = filter.store_key(&f.path);
let bytes = postcard::to_allocvec(&rec).ok();
Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
}
/// Inserts a parsed batch into the in-memory index and persists the records.
fn publish(&self, batch: impl Iterator<Item = ParsedFile>) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let started = Instant::now();
let mut inserts: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut refreshes: Vec<MetadataRefresh> = Vec::new();
let mut entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
for out in batch {
let ParsedFile { rel, key, outcome, path } = out;
match outcome {
ParsedOutcome::New { rec, bytes } => {
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
}
inserts.push(FileEntry::new(path, rel, rec));
}
ParsedOutcome::Unchanged { mtime, size, ignored } => {
refreshes.push(MetadataRefresh { path, key, mtime, size, ignored });
}
let ParsedFile { rel, rec, key, bytes, path } = out;
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
}
entries.push(FileEntry::new(path, rel, rec));
}
let mut refreshed_records: Vec<(String, FileRecord)> = Vec::new();
{
let mut d = self.data.write();
for (e, symbols) in inserts {
for (e, symbols) in entries {
d.insert(e, symbols);
}
for r in refreshes {
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
&& let Some(key) = r.key
{
refreshed_records.push((key, rec));
}
}
}
for (key, rec) in refreshed_records {
if let Ok(bytes) = postcard::to_allocvec(&rec) {
puts.push((key, bytes));
}
}
laps.insert = started.elapsed();
let started = Instant::now();
@@ -859,9 +818,9 @@ impl Shared {
for (dir, wanted) in by_dir {
files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));
}
let files: Vec<(Found, Option<ContentHash>)> = {
let files: Vec<Found> = {
let d = self.data.read();
files.into_iter().filter_map(|f| prev_hash_if_stale(&d, &f).map(|h| (f, h))).collect()
files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
};
if !files.is_empty() {
touched = true;
@@ -869,17 +828,17 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk);
self.index_files(chunk.iter(), false);
}
}
for before in reparse {
let affected: Vec<(Found, Option<ContentHash>)> = {
let affected: Vec<Found> = {
let d = self.data.read();
d.paths()
.filter(|p| before.detect(p, None) != self.languages.detect(p, None))
.filter_map(|p| {
let e = d.get(p)?;
Some((Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, None))
Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })
})
.collect()
};
@@ -889,7 +848,7 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk);
self.index_files(chunk.iter(), true);
}
}
}
@@ -907,18 +866,6 @@ impl Shared {
}
}
type ContentHash = [u8; 32];
/// `Some(prev_hash)` when `f` is missing or stale in `d` (`None` inner hash when
/// the file must be parsed fresh); `None` when `d` is already current for `f`.
fn prev_hash_if_stale(d: &IndexData, f: &Found) -> Option<Option<ContentHash>> {
match d.get(&f.path) {
None => Some(None),
Some(e) if e.stale_for(f) => Some((!e.ignored).then_some(e.hash)),
Some(_) => None,
}
}
/// The first line, capped at 256 bytes (for shebang / `<?xml` detection).
fn first_line(text: &str) -> &str {
let line = text.lines().next().unwrap_or_default();
@@ -951,26 +898,14 @@ impl ChunkLaps {
}
}
struct MetadataRefresh {
path: PathBuf,
key: Option<String>,
mtime: u64,
size: u64,
ignored: bool,
}
enum ParsedOutcome {
Unchanged { mtime: u64, size: u64, ignored: bool },
New { rec: FileRecord, bytes: Option<Vec<u8>> },
}
/// One file parsed off the index thread: its outcome ready to publish, with new
/// records already serialized for the cache in parallel with the parse.
/// One file parsed off the index thread: its record ready to publish, already
/// serialized for the cache (in parallel with the parse).
struct ParsedFile {
rel: String,
/// Cache key; `None` when outside the persisted root.
rec: FileRecord,
/// Cache key and postcard bytes; `None` when outside the persisted root.
key: Option<String>,
outcome: ParsedOutcome,
bytes: Option<Vec<u8>>,
path: PathBuf,
}
-3
Переглянути файл
@@ -194,9 +194,6 @@ pub mod codes {
pub const METHOD_NOT_FOUND: i64 = -32601;
pub const INVALID_PARAMS: i64 = -32602;
pub const INTERNAL_ERROR: i64 = -32603;
/// LSP `RequestFailed`: the request was understood and could not be carried out; the
/// message says why.
pub const REQUEST_FAILED: i64 = -32803;
/// LSP `ServerCancelled`.
pub const SERVER_CANCELLED: i64 = -32802;
/// LSP `ContentModified`.
+1 -8
Переглянути файл
@@ -1,6 +1,5 @@
//! Pull Members Up / Push Members Down through the app-owned JDT extension
//! (`java/java-usages`), or through Phoxite's own requests when the document's
//! server advertises them (`crate::phoxite`). The server checks the move and computes the edit; the UI
//! (`java/java-usages`). The server checks the move and computes the edit; the UI
//! shows its problems and applies the edit itself.
use super::COMMAND_TIMEOUT;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
@@ -76,9 +75,6 @@ impl LspManager {
kind: HierarchyRefactoring,
cancel: CancellationToken,
) -> IdeResult<HierarchyMembers> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_members(&phoxite, pos, kind, &cancel).await;
}
let (members, _, _) = self.hierarchy_command(doc, pos, kind, MEMBERS, &[], &cancel).await?;
Ok(members)
}
@@ -93,9 +89,6 @@ impl LspManager {
choices: Vec<HierarchyChoice>,
cancel: CancellationToken,
) -> IdeResult<HierarchyRefactored> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_refactor(&phoxite, pos, kind, target, &choices, &cancel).await;
}
let choices: Vec<Value> = choices.iter().map(|c| json!({ "id": c.id, "abstract": c.make_abstract })).collect();
let (refactored, _, t): (Refactored, _, _) =
self.hierarchy_command(doc, pos, kind, REFACTOR, &[json!(target), json!(choices)], &cancel).await?;
-1
Переглянути файл
@@ -26,7 +26,6 @@ mod launch;
mod library_source;
mod loading;
mod notebook;
mod phoxite;
mod plugin_requests;
mod pull;
mod scope;
-97
Переглянути файл
@@ -1,97 +0,0 @@
//! Pull Members Up / Push Members Down through Phoxite's own requests
//! (`phoxite/refactor/hierarchyMembers` and `phoxite/refactor/hierarchy`). A server says it
//! answers them with `experimental.phoxite.refactor` in its capabilities, so the server is
//! found by what it advertises, not by its name. As with the JDT extension, the server
//! checks the move and computes the edit; the UI shows its problems and applies the edit.
use crate::caps::ServerCaps;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
use crate::{DocSnap, LspManager, Target, convert, rpc_err};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
use ide_jsonrpc::RpcError;
use serde::Deserialize;
use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::time::Duration;
const MEMBERS: &str = "phoxite/refactor/hierarchyMembers";
const REFACTOR: &str = "phoxite/refactor/hierarchy";
/// The move is computed over the whole project.
const TIMEOUT: Duration = Duration::from_secs(120);
#[derive(Deserialize)]
struct Refactored {
problems: Vec<RefactoringProblem>,
edit: Option<lsp_types::WorkspaceEdit>,
}
/// Whether the server answers the `phoxite/refactor/*` requests.
fn refactors(caps: &ServerCaps) -> bool {
caps.raw.pointer("/experimental/phoxite/refactor").and_then(Value::as_bool) == Some(true)
}
impl LspManager {
/// The server of `doc` that answers `phoxite/refactor/*`, when one is attached.
pub(crate) async fn phoxite_refactor_target(&self, doc: DocId) -> Option<(DocSnap, Target)> {
let (snap, mut targets) = self.doc_targets(doc, "refactorings", refactors).await.ok()?;
Some((snap, targets.swap_remove(0)))
}
/// Sends one of the hierarchy requests. The server refuses a position it can't
/// refactor with LSP's `RequestFailed` and a message for the user: that is invalid
/// input, as the JDT extension's `refused` is. Any other error is the server failing.
async fn phoxite_hierarchy<R: DeserializeOwned>(
&self,
(snap, t): &(DocSnap, Target),
method: &str,
pos: Pos,
kind: HierarchyRefactoring,
extra: Value,
cancel: &CancellationToken,
) -> IdeResult<R> {
let mut params = json!({ "uri": snap.uri, "position": snap.position(t, pos), "kind": kind });
if let (Some(params), Value::Object(extra)) = (params.as_object_mut(), extra) {
params.extend(extra);
}
let request = t.run.peer.request::<Value, Value>(method, params, Some(cancel.clone()));
let answer = match tokio::time::timeout(TIMEOUT, request).await {
Ok(Ok(value)) => value,
Ok(Err(RpcError::Server { code, message, .. })) if code == ide_jsonrpc::codes::REQUEST_FAILED => {
return Err(IdeError::invalid(message));
}
Ok(Err(e)) => return Err(rpc_err(&t.server.name, method, e)),
Err(_) => return Err(rpc_err(&t.server.name, method, RpcError::Timeout)),
};
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
serde_json::from_value(answer).map_err(|e| rpc_err(&t.server.name, method, RpcError::Protocol(e.to_string())))
}
pub(crate) async fn phoxite_hierarchy_members(
&self,
target: &(DocSnap, Target),
pos: Pos,
kind: HierarchyRefactoring,
cancel: &CancellationToken,
) -> IdeResult<HierarchyMembers> {
self.phoxite_hierarchy(target, MEMBERS, pos, kind, Value::Null, cancel).await
}
pub(crate) async fn phoxite_hierarchy_refactor(
&self,
target: &(DocSnap, Target),
pos: Pos,
kind: HierarchyRefactoring,
destination: Option<String>,
choices: &[HierarchyChoice],
cancel: &CancellationToken,
) -> IdeResult<HierarchyRefactored> {
let extra = json!({ "target": destination, "choices": choices });
let refactored: Refactored = self.phoxite_hierarchy(target, REFACTOR, pos, kind, extra, cancel).await?;
let conv = self.conv(target.1.enc());
Ok(HierarchyRefactored {
problems: refactored.problems,
edit: refactored.edit.map(|e| convert::workspace_edit(&conv, e)),
})
}
}
-10
Переглянути файл
@@ -57,16 +57,6 @@ impl LspManager {
Ok(running.swap_remove(at))
}
/// Names (in the language definition) of the servers attached to `doc`, or of every
/// server of the project when the document is not open; only `server`'s when given.
pub fn server_names(&self, doc: ide_core::DocId, server: Option<ide_core::ServerId>) -> Vec<String> {
let servers = match self.snapshot(doc) {
Ok(snap) => snap.servers,
Err(_) => self.servers.lock().clone(),
};
servers.iter().filter(|s| server.is_none_or(|id| s.id == id)).map(|s| s.name.clone()).collect()
}
/// Sends a plugin's request to the running server named `server` (its name in the
/// language definition) and returns the result. `not_found` when it is not running,
/// `invalid` for a method that is not the server's own.
-88
Переглянути файл
@@ -7429,91 +7429,3 @@ async fn a_plugin_request_reaches_only_a_running_servers_own_methods() {
let e = h.mgr.server_request(&h.root, "main", "mock/routes", None, &cancel, timeout).await.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::Cancelled);
}
/// A server that advertises `experimental.phoxite.refactor` gets Pull Members Up / Push
/// Members Down as its own `phoxite/refactor/*` requests, whatever its name.
#[tokio::test(flavor = "multi_thread")]
async fn hierarchy_refactorings_use_phoxites_requests_when_the_server_advertises_them() {
let mut caps = incremental_caps();
caps["experimental"] = json!({ "phoxite": { "laravel": true, "refactor": true } });
let h = harness_for("php", "php", &[("any-name", caps)], &[]);
let s = h.launcher.state("any-name");
*s.responder.lock() = Some(Arc::new(|_, method, params| {
let uri = params["uri"].clone();
match (method, params["position"]["line"].as_u64()) {
("phoxite/refactor/hierarchyMembers", Some(0)) => Some(json!({
"className": "Dog",
"targets": [{ "id": "App\\Animal", "name": "Animal", "qualifiedName": "App\\Animal", "interface": false }],
"members": [
{ "id": "method:bark", "label": "bark(): string", "kind": "method", "selected": true, "abstractable": true },
{ "id": "constant:LEGS", "label": "LEGS", "kind": "field", "selected": false, "abstractable": false },
],
})),
("phoxite/refactor/hierarchy", _) => Some(json!({
"problems": [{ "severity": "warning", "message": "bark() uses $tail, which stays in Dog" }],
"edit": { "changes": { uri.as_str().unwrap(): [
{ "range": { "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 5 } }, "newText": "<?php" }
] } },
})),
_ => None,
}
}));
let text =
format!("<?php class Dog extends Animal {{ function bark(): string {{ return ''; }} }}{}", "\n".repeat(9));
let (doc, path) = h.open("Dog.php", &text);
h.wait_status("any-name", ServerStatus::Ready).await;
eventually(|| s.docs.lock().len() == 1).await;
let info =
h.mgr.hierarchy_members(doc, Pos::new(0, 40), HierarchyRefactoring::PullUp, Default::default()).await.unwrap();
assert_eq!((info.class_name.as_str(), info.targets[0].qualified_name.as_str()), ("Dog", "App\\Animal"));
assert!(info.members[0].selected && info.members[0].abstractable);
assert_eq!(
info.members.iter().map(|m| m.kind).collect::<Vec<_>>(),
[HierarchyMemberKind::Method, HierarchyMemberKind::Field]
);
assert_eq!(
s.requested("phoxite/refactor/hierarchyMembers"),
[json!({ "uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp" })]
);
let choices = vec![HierarchyChoice { id: "method:bark".into(), make_abstract: true }];
let done = h
.mgr
.hierarchy_refactor(
doc,
Pos::new(0, 40),
HierarchyRefactoring::PullUp,
Some("App\\Animal".into()),
choices,
Default::default(),
)
.await
.unwrap();
assert_eq!(done.problems[0].severity, ProblemSeverity::Warning);
let edit = done.edit.unwrap();
assert!(matches!(&edit.files[..], [FileEdit::Edit { path: p, edits, .. }] if p == &path && edits.len() == 1));
assert_eq!(
s.requested("phoxite/refactor/hierarchy"),
[json!({
"uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp",
"target": "App\\Animal", "choices": [{ "id": "method:bark", "makeAbstract": true }],
})]
);
assert!(s.requested("workspace/executeCommand").is_empty(), "not the JDT extension's commands");
// The server refuses a position with `RequestFailed` and a message for the user.
let refusal = (-32803, "'Dog' has no parent class or interface in the project".to_owned());
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), refusal);
let refused = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let e = refused.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::InvalidInput);
assert_eq!(e.message, "'Dog' has no parent class or interface in the project");
// Any other error is the server failing, not a reason to show as the user's mistake.
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), (-32603, "index out of bounds".to_owned()));
let failed = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let e = failed.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::Protocol);
assert_eq!(e.message, "any-name: index out of bounds");
}
-79
Переглянути файл
@@ -1022,82 +1022,3 @@ async fn basedpyright_and_ruff_serve_notebook_cells() {
mgr.close_notebook(&path);
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
}
/// Pull Members Up through Phoxite's own requests: the real server moves a method to
/// the parent class in another file.
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires phoxite-lsp on PATH (or OPENIDEA_TEST_PHOXITE_LSP)"]
async fn phoxite_pulls_a_member_up_end_to_end() {
use ide_core::FileEdit;
use ide_lsp::types::{HierarchyChoice, HierarchyRefactoring};
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
std::fs::create_dir(root.join("src")).unwrap();
std::fs::write(root.join("composer.json"), r#"{"autoload":{"psr-4":{"App\\":"src/"}}}"#).unwrap();
let animal = root.join("src").join("Animal.php");
std::fs::write(&animal, "<?php\n\nnamespace App;\n\nclass Animal\n{\n}\n").unwrap();
let path = root.join("src").join("Dog.php");
let source = "<?php\n\nnamespace App;\n\nclass Dog extends Animal\n{\n public function bark(): string\n {\n return 'woof';\n }\n}\n";
std::fs::write(&path, source).unwrap();
let mut php = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("php")).unwrap();
php.language_servers.retain(|s| s.name == "phoxite");
assert_eq!(php.language_servers.len(), 1);
php.language_servers[0].fallback = false;
if let Ok(bin) = std::env::var("OPENIDEA_TEST_PHOXITE_LSP") {
php.language_servers[0].command = bin;
}
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![php]));
let doc = DocId::next();
mgr.did_open(doc, &path, &LanguageId::new("php"), 1, source);
retry("phoxite ready", Duration::from_secs(30), || {
let status = last_status(&events, "phoxite");
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
panic!("phoxite failed: {msg:?}");
}
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
})
.await;
// On `bark`; the parent is known once the project is indexed.
let at = Pos::new(6, 22);
let info = retry("the movable members", Duration::from_secs(60), || {
let mgr = mgr.clone();
async move { mgr.hierarchy_members(doc, at, HierarchyRefactoring::PullUp, Default::default()).await.ok() }
})
.await;
assert_eq!(info.class_name, "Dog");
assert_eq!(
info.targets.iter().map(|t| t.qualified_name.trim_start_matches('\\')).collect::<Vec<_>>(),
["App\\Animal"]
);
let bark = info.members.iter().find(|m| m.label.starts_with("bark")).expect("bark is movable");
assert!(bark.selected, "{bark:?}");
let choices = vec![HierarchyChoice { id: bark.id.clone(), make_abstract: false }];
let done = mgr
.hierarchy_refactor(
doc,
at,
HierarchyRefactoring::PullUp,
Some(info.targets[0].id.clone()),
choices,
Default::default(),
)
.await
.unwrap();
let edit = done.edit.expect("an edit");
let mut edited: Vec<_> = edit
.files
.iter()
.filter_map(|f| match f {
FileEdit::Edit { path, edits, .. } if !edits.is_empty() => path.0.file_name()?.to_str().map(str::to_owned),
_ => None,
})
.collect();
edited.sort();
assert_eq!(edited, ["Animal.php", "Dog.php"], "the method leaves Dog and arrives in Animal");
// Outside any class the server refuses with `RequestFailed`: the reason reaches the user.
let refused = mgr.hierarchy_members(doc, Pos::new(0, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let refused = refused.unwrap_err();
assert_eq!(refused.kind, ide_core::error::ErrorKind::InvalidInput, "{refused:?}");
assert!(!refused.message.is_empty() && !refused.message.starts_with("phoxite:"), "{refused:?}");
mgr.shutdown_all().await;
}
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
6a36bd56db7148032c1fe101bec8c38e326528b1de1ee26b5d7c5b9dd80b3e94
4788f82b35966e155dbf51af520acb2d5e7773ddf9f36f4239b9bd51d51b0fb3
-10
Переглянути файл
@@ -22,13 +22,3 @@ title = "Send a method of LSP itself"
[[contributes.commands]]
id = "ungranted"
title = "Ask a server the manifest does not name"
[[contributes.commands]]
id = "ran"
title = "Run a command the mock server left to the client"
# The mock server's code lenses carry `mock.modelView` without executing it.
[[contributes.serverCommands]]
server = "mock"
command = "mock.modelView"
run = "ran"
-2
Переглянути файл
@@ -10,8 +10,6 @@ impl Plugin for LspRequests {
"request" => project.language_server_request("mock", "mock/routes", arg).map(Some),
"notify" => project.language_server_notify("mock", "mock/changed", arg).map(|()| None),
"standard" => project.language_server_request("mock", "textDocument/hover", arg).map(Some),
// Shows the server what arrived: the arguments of the command it handed to the client.
"ran" => project.language_server_notify("mock", "mock/ran", arg).map(|()| None),
"ungranted" => project.language_server_request("other", "other/status", arg).map(Some),
_ => Err(Error::NotFound(id.into())),
}
+1 -1
Переглянути файл
@@ -128,7 +128,7 @@ With tabs placed left or right, the tab column is as wide as its longest name, u
| **Scroll to Center** | `⌃L` | `Ctrl+M` |
- **View › Active Editor › Soft-Wrap** wraps long lines in the current editor. To wrap some file types by default, use **Settings › Editor › General**, section **Soft Wraps**.
- **View › Reset Font Size** undoes font zoom in the active editor or focused surface (**View › Reset Font Size in All Editors** resets every open editor). Changing the font size with `⌘` / `Ctrl` + mouse wheel (scoped to **Active editor** by default, or **All editors**) can be turned on in **Settings › Editor › General**, section **Mouse Control**.
- **View › Reset Font Size in All Editors** undoes font zoom. Changing the font size with `⌘` / `Ctrl` + mouse wheel can be turned on in **Settings › Editor › General**, section **Mouse Control**.
- **View › Appearance › Enter Distraction Free Mode** hides tool windows, tabs, the status bar and the gutter and centres the text. Run the same command again to leave.
- Line numbers, whitespace, indent guides, caret style and the intention bulb are in **Settings › Editor › General › Appearance**. Breadcrumbs and sticky lines (the enclosing declarations pinned at the top while you scroll) have their own pages under **Settings › Editor › General**.
+1 -3
Переглянути файл
@@ -94,7 +94,6 @@ While the server runs, OpenIDEA writes its port and token to `mcp/server.json` i
| Commands | `run_command`, `wait_for_run`, `send_run_input`, `stop_run` |
| Command state | `get_run_status`, `read_run_output`, `list_runs` |
| Git | `get_repositories`, `git_status`, `git_diff` |
| HTTP Client | `http_list_requests`, `http_run_request` |
Notes on what they do:
@@ -106,7 +105,6 @@ Notes on what they do:
- `rename_refactoring` renames through the language server, so references that a text search would miss are updated too. It can preview without writing.
- `apply_patch` accepts the Codex `apply_patch` format and unified diffs. Paths must stay inside the project.
- `git_diff` compares files on disk, so unsaved editor text is not included.
- `http_list_requests` lists requests in a project `.http` / `.rest` file; `http_run_request` sends one by index (optional `env` from `http-client.env.json`), asks first, and returns status plus a truncated body — not request headers or body.
## Commands in the Run tool window
@@ -124,7 +122,7 @@ Plugins can add more tools; they appear in the same list. A plugin tool marked a
## Safety
- **Untrusted projects** expose only the read-only tools. Tools that write files, rename, reformat, build or run need a project you have trusted.
- **Running and building ask first.** `execute_run_configuration`, `build_project`, `run_command` and `http_run_request` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
- **Running and building ask first.** `execute_run_configuration`, `build_project` and `run_command` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
- Tools that write refuse paths outside the project.
## Limits
+3 -3
Переглянути файл
@@ -27,8 +27,8 @@ The **Refactor** menu has IntelliJ IDEA's refactorings with their usual shortcut
| **Inline…** | `⌥⌘N` | `Ctrl+Alt+N` | Language server |
| **Move…** | `F6` | `F6` | Language server (symbols); the IDE (files and folders) |
| **Safe Delete…** | `⌘⌦` | `Alt+Delete` | The IDE, using the server's references |
| **Pull Members Up…** | — | — | Java; PHP with Phoxite |
| **Push Members Down…** | — | — | Java; PHP with Phoxite |
| **Pull Members Up…** | — | — | Java only |
| **Push Members Down…** | — | — | Java only |
## Rename
@@ -80,7 +80,7 @@ In the editor, **Move…** on a symbol runs the server's move refactoring, where
## Pull Members Up and Push Members Down
These move fields and methods between a class and its superclasses or subclasses, in Java and, with Phoxite as the PHP server, in PHP (methods, properties and constants). A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. For Java they are provided by the extension bundled with OpenIDEA, for PHP by Phoxite; they are not available for other languages or other PHP servers.
These move fields and methods between a Java class and its superclasses or subclasses. A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. They are provided by the Java extension bundled with OpenIDEA, so they are not available for other languages.
## Undo
+1 -1
Переглянути файл
@@ -64,7 +64,7 @@ To create a theme or icon theme, see [Themes](/en/plugins/guides/themes) and [Ic
- **Enable ligatures** for fonts with programming ligatures.
- **Typography Settings**: **Main font weight**, **Bold font weight**, and a **Fallback font** for characters the main font lacks.
To change the size temporarily in the active editor, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size** (or **View › Reset Font Size in All Editors**) goes back. In **Settings › Editor › General**, **Change font size with Ctrl/Command+Mouse Wheel** enables wheel zoom for the **Active editor** (default) or **All editors**.
To change the size temporarily, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size in All Editors** goes back. On macOS, **Change font size with Command+Mouse Wheel** in **Settings › Editor › General** enables wheel zoom.
### UI font and zoom
+24 -25
Переглянути файл
@@ -100,31 +100,30 @@ The user approves **required** capabilities as a whole when installing. **Option
Each contribution point is a table (`[contributes.settings]`) or an array of tables (`[[contributes.commands]]`). Contributions are live as soon as the plugin is enabled, before its code loads.
| Point | Declaration | Code needed | Guide |
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `serverCommands` | `server`, `command`, `run` (API 1.9) | yes | [README: Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
| Point | Declaration | Code needed | Guide |
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
Item ids (commands, views, themes, …) match `[a-z0-9][a-z0-9._-]*`, at most 64 characters. Menus, shortcuts and status bar items refer to the plugin's own declared commands; inside the IDE a command's action id is `plugin.<plugin id>.<command id>`.
+1 -1
Переглянути файл
@@ -128,7 +128,7 @@ description: "多光标与选区、行编辑、剪贴板历史、代码折叠、
| **滚动到中央** | `⌃L` | `Ctrl+M` |
- **视图 › 活动编辑器 › 软换行** 让当前编辑器的长行自动折行。想让某些文件类型默认软换行,在 **设置 › 编辑器 › 常规** 的 **软换行** 一节中设置。
- **视图 › 重置字体大小** 撤销当前编辑器或焦点区域的字体缩放(**视图 › 重置所有编辑器中的字体大小** 会重置所有打开的编辑器)。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
- **视图 › 重置所有编辑器中的字体大小** 撤销字体缩放。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开。
- **视图 › 外观 › 进入无干扰模式** 隐藏工具窗口、标签页、状态栏和装订区域,并让正文居中。再执行一次即可退出。
- 行号、空白字符、缩进参考线、光标样式和意图灯泡在 **设置 › 编辑器 › 常规 › 外观** 中设置。痕迹导航和粘滞行(滚动时把所在的声明固定在顶部)在 **设置 › 编辑器 › 常规** 下各有单独的页面。
+12 -14
Переглянути файл
@@ -82,18 +82,17 @@ stdio 配置大致如下(路径以你机器上的为准):
## 工具
| 类别 | 工具 |
| ----------- | --------------------------------------------------------------------------- |
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
| Git | `get_repositories`、`git_status`、`git_diff` |
| HTTP 客户端 | `http_list_requests`、`http_run_request` |
| 类别 | 工具 |
| ---------- | --------------------------------------------------------------------------- |
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
| Git | `get_repositories`、`git_status`、`git_diff` |
几点说明:
@@ -105,7 +104,6 @@ stdio 配置大致如下(路径以你机器上的为准):
- `rename_refactoring` 通过语言服务器重命名,文本搜索找不到的引用也会一并更新;也可以只预览不写入。
- `apply_patch` 接受 Codex 的 `apply_patch` 格式和 unified diff,路径必须在项目内。
- `git_diff` 比较的是磁盘上的文件,不包含编辑器中尚未保存的内容。
- `http_list_requests` 列出项目中 `.http` / `.rest` 文件里的请求;`http_run_request` 按索引发送其中一个(可选 `env`,来自 `http-client.env.json`),会先询问,并返回状态和截断后的响应体——不含请求头或请求体。
## 在运行工具窗口中执行命令
@@ -123,7 +121,7 @@ stdio 配置大致如下(路径以你机器上的为准):
## 安全
- **未受信任的项目** 只开放只读工具。写文件、重命名、重新格式化、构建或运行的工具都要求项目已被信任。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project`、`run_command` 和 `http_run_request` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project` 和 `run_command` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- 会写入的工具拒绝项目之外的路径。
## 限制
+3 -3
Переглянути файл
@@ -27,8 +27,8 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
| **内联…** | `⌥⌘N` | `Ctrl+Alt+N` | 语言服务器 |
| **移动…** | `F6` | `F6` | 语言服务器(符号);IDE(文件和文件夹) |
| **安全删除…** | `⌘⌦` | `Alt+Delete` | IDE,借助服务器查找引用 |
| **上拉成员…** | — | — | Java;PHP(使用 Phoxite) |
| **下推成员…** | — | — | Java;PHP(使用 Phoxite) |
| **上拉成员…** | — | — | 仅 Java |
| **下推成员…** | — | — | 仅 Java |
## 重命名
@@ -73,7 +73,7 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
## 上拉成员与下推成员
用于在类和它的父类或子类之间移动字段和方法:支持 Java,以及使用 Phoxite 作为 PHP 服务器时的 PHP(方法、属性和常量)。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。Java 由 OpenIDEA 自带的扩展提供,PHP 由 Phoxite 提供;其他语言和其他 PHP 服务器不可用。
用于在 Java 类和它的父类或子类之间移动字段和方法。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。这两项由 OpenIDEA 自带的 Java 扩展提供,其他语言不可用。
## 撤销
+1 -1
Переглянути файл
@@ -64,7 +64,7 @@ OpenIDEA 会把主题(以及其中附带的编辑器配色方案)转换为
- **启用连字**:用于带编程连字的字体。
- **排版设置**:**主字重**、**粗体字重**,以及主字体缺少字符时使用的 **备用字体**。
在当前编辑器中临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置字体大小**(或 **视图 › 重置所有编辑器中的字体大小**)恢复。在 **设置 › 编辑器 › 常规** 中开启 **使用 Ctrl/Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置所有编辑器中的字体大小** 恢复。在 macOS 上,开启 **设置 › 编辑器 › 常规** 中的 **使用 Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放。
### 界面字体与缩放
+24 -25
Переглянути файл
@@ -100,31 +100,30 @@ optional = ["net:api.openai.com", "secrets"]
每个贡献点是一张表(`[contributes.settings]`)或一个表数组(`[[contributes.commands]]`)。插件启用后贡献立即生效,不需要等代码加载。
| 贡献点 | 声明字段 | 需要代码 | 指南 |
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `serverCommands` | `server`、`command`、`run`(API 1.9) | 是 | [README:Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
| 贡献点 | 声明字段 | 需要代码 | 指南 |
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
条目 id(命令、视图、主题等)匹配 `[a-z0-9][a-z0-9._-]*`,不超过 64 个字符。菜单、快捷键和状态栏项只能引用插件自己声明的命令;在 IDE 内部,命令的操作 id 是 `plugin.<plugin id>.<command id>`。
+1 -2
Переглянути файл
@@ -255,8 +255,7 @@ async function selectDraft(page: Page) {
}
async function chooseModel(page: Page, name: string) {
await modelButton(page).click();
// A model row also holds its Configure button, whose label joins the option's name.
await page.getByRole("option", { name: new RegExp(`^${name}\\b`) }).click();
await page.getByRole("option", { name, exact: true }).click();
await page.keyboard.press("Escape");
await box(page).focus();
}
-58
Переглянути файл
@@ -761,61 +761,3 @@ test("Find in Conversation skips user-select:none summaries and closed <details>
}));
expect(expandedHighlights).toEqual({ thoughtOpen: true, findCount: 2, currentCount: 1 });
});
test("keeps ordered, bulleted and task list markers unclipped inside measured rows when zoomed in", async ({
page,
}) => {
const numbered = Array.from({ length: 10 }, (_, i) => `${i + 1}. **Item ${i + 1}**\n - Nested bullet`).join("\n");
await openReply(page, `## Feature Gaps\n\n${numbered}\n\n- [x] Checked task\n- [ ] Open task`);
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const actionsPath = "/src/platform/actions.ts";
const store = await import(storePath);
const { executeAction } = await import(actionsPath);
store.openTaskInEditorLocation(task.id);
await new Promise((r) => setTimeout(r, 150));
const stream = document.querySelector<HTMLElement>("[class*='_stream_']");
stream?.focus();
for (let i = 0; i < 12; i++) await executeAction("editor.increaseFontSize");
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
const row = stream.locator("[class*='_conversationRow_'][data-measured]", { has: page.locator("ol") });
await expect(row).toBeVisible();
const bounds = await row.evaluate((rowEl) => {
const rowLeft = rowEl.getBoundingClientRect().left;
const items = [...rowEl.querySelectorAll<HTMLElement>("ol > li, ul > li")];
const markers = items
.filter((li) => getComputedStyle(li, "::before").content !== "none")
.map((li) => {
const rect = li.getBoundingClientRect();
const before = getComputedStyle(li, "::before");
const lineHeight = Number.parseFloat(getComputedStyle(li).lineHeight);
const markerRight = rect.right - Number.parseFloat(before.right);
const markerLeft = markerRight - Number.parseFloat(before.width);
return {
text: li.firstChild?.textContent?.trim() ?? "",
offsetFromRowLeft: Math.round((markerLeft - rowLeft) * 100) / 100,
singleLine: Number.parseFloat(before.height) <= lineHeight * 1.15,
};
});
const checkboxes = [...rowEl.querySelectorAll<HTMLInputElement>('li > input[type="checkbox"]')].map((input) => ({
offsetFromRowLeft: Math.round((input.getBoundingClientRect().left - rowLeft) * 100) / 100,
}));
return { fontSize: getComputedStyle(streamElement()!).fontSize, markers, checkboxes };
function streamElement() {
return rowEl.closest<HTMLElement>("[class*='_stream_']");
}
});
expect(bounds.fontSize).toBe("25px");
expect(bounds.markers.length).toBeGreaterThanOrEqual(10);
for (const m of bounds.markers) {
expect(m.singleLine, `single-line marker for ${m.text}`).toBe(true);
expect(m.offsetFromRowLeft, `marker for ${m.text}`).toBeGreaterThanOrEqual(0);
}
for (const cb of bounds.checkboxes) {
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
}
});
-3
Переглянути файл
@@ -1,3 +0,0 @@
# Per-user IDE state
/shelf/
/changelists.json
-31
Переглянути файл
@@ -157,7 +157,6 @@ work), but 0.1 code no longer runs: rebuild it against the 1.0 SDK.
| `fileIcons` | `id`, `patterns` (file names), `icon` (SVG), `iconDark?` — whatever icon theme is in use | no |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables = [{ name, prompt }]` — New menu | no |
| `commitChecks` | `id`, `title` — a before-commit check in Commit Options (see _Commits_) | yes |
| `serverCommands` | `server`, `command`, `run` — a language server's client command run by this plugin's command (API 1.9; see _Commands a server hands to the client_) |
A `viewItem.context` menu needs `view`, the id of one of the plugin's own
views. It adds the commands to the right-click menu of the items in that
@@ -433,8 +432,6 @@ matching SDK. Released 1.8 plugins keep working. New in 1.9:
(Debug runs the configuration and attaches to a process the run starts). See
_Environment and debugger_ under _Runs, terminal sessions and test results_.
- **`[[contributes.serverCommands]]`** routes a command a language server leaves
to the client (a code lens's, a code action's) to the plugin's own command.
- **Requests to a language server.** `Project::language_server_request` and
`language_server_notify` send a running server its own methods, behind the
high-risk `lsp:<server>` capability. See _Requests to a language server_.
@@ -784,34 +781,6 @@ project.language_server_notify("phoxite", "phoxite/refresh", None)?;
is at most 256 bytes, params at most 1 MiB.
- The project must be trusted; otherwise the call is `denied`.
#### Commands a server hands to the client
A server's code lens, code action or inlay hint can carry a command the server
does not execute itself (it is not in its `executeCommandProvider`): the client
is meant to. A plugin claims such a command in its manifest, and the IDE runs
the plugin's own command instead of failing with "no language server provides
command":
```toml
[[contributes.commands]]
id = "model-view"
title = "Show the Eloquent Model"
[[contributes.serverCommands]]
server = "phoxite" # the server whose results carry the command
command = "laravel.modelView" # the command name in the server's result
run = "model-view" # this plugin's command
```
- `run` gets the command's `arguments` array as JSON in `arg`, in the window and
editor where the lens or action was activated.
- The manifest must declare `lsp:<server>`, and the claim counts only while the
plugin holds that grant.
- A command listed in the server's `executeCommandProvider` still goes to the
server.
- When two installed plugins claim the same `server` and `command`, the first
one loaded keeps it and the conflict is logged.
In tests, `MockHost::set_language_server_response(server, method, json)` makes
a server run and answer, and `language_server_requests()` /
`language_server_notifications()` list what the plugin sent.
-1
Переглянути файл
@@ -250,7 +250,6 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
nav::find_files_named,
nav::find_dirs,
nav::find_symbols,
nav::find_symbols_named,
nav::mark_recent,
nav::recent_files,
nav::remove_recent,
+6 -28
Переглянути файл
@@ -24,13 +24,8 @@ pub fn index_file_extensions(window: Window, state: State<'_, AppState>) -> IdeR
#[tauri::command]
#[specta::specta]
pub async fn find_files(
window: Window,
state: State<'_, AppState>,
query: String,
limit: u32,
) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit).await
pub fn find_files(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit)
}
#[tauri::command]
@@ -42,13 +37,8 @@ pub async fn find_files_named(window: Window, state: State<'_, AppState>, name:
/// Folders holding indexed files, for `@` references.
#[tauri::command]
#[specta::specta]
pub async fn find_dirs(
window: Window,
state: State<'_, AppState>,
query: String,
limit: u32,
) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit).await
pub fn find_dirs(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit)
}
/// Spring Web mapping sources for the request-path index of Search Everywhere.
@@ -63,26 +53,14 @@ pub fn spring_route_sources(
#[tauri::command]
#[specta::specta]
pub async fn find_symbols(
pub fn find_symbols(
window: Window,
state: State<'_, AppState>,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit).await
}
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder).
#[tauri::command]
#[specta::specta]
pub async fn find_symbols_named(
window: Window,
state: State<'_, AppState>,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
ide_host::ops::nav::find_symbols_named(&state.host, window.label(), names, within).await
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit)
}
#[tauri::command]
+1 -2
Переглянути файл
@@ -439,8 +439,7 @@ pub fn spec(os: Os) -> Vec<Entry> {
SEP,
act("view.quickSwitchScheme", "Quick Switch Scheme…"),
SEP,
act("editor.resetFontSize", "Reset Font Size"),
act("editor.resetFontSizeAll", "Reset Font Size in All Editors"),
act("editor.resetFontSize", "Reset Font Size in All Editors"),
SEP,
act("view.notifications", "Notifications"),
],
+2 -4
Переглянути файл
@@ -1,12 +1,10 @@
//! Tauri runs a command declared without `async` on the main thread, so disk I/O or a
//! large diff there freezes the window (input, painting, every other IPC call).
/// Commands that read or write project files, Local History or `.env` files, diff two
/// arbitrary texts, or scan the project index in parallel: they must be `async` and do
/// that work on the blocking pool.
/// Commands that read or write project files, Local History or `.env` files, or diff two
/// arbitrary texts: they must be `async` and do that work on the blocking pool.
const OFF_MAIN_THREAD: &[(&str, &[&str])] = &[
("doc.rs", &["history_list", "history_content"]),
("nav.rs", &["find_files", "find_dirs", "find_symbols"]),
(
"vcs.rs",
&[
+3 -4
Переглянути файл
@@ -216,11 +216,10 @@ docker_snapshot trusted desktop bin
end_process trusted desktop bindings async
env_reload always project_host bindings async
file_dialog_needs_gtk trusted desktop bindings async
find_dirs always project_host bindings async
find_files always project_host bindings async
find_dirs always project_host bindings sync
find_files always project_host bindings sync
find_files_named always project_host bindings async
find_symbols always project_host bindings async
find_symbols_named always project_host bindings async
find_symbols always project_host bindings sync
fs_compare_directories always project_host bindings async
fs_copy always project_host bindings async
fs_copy_merge always project_host bindings async
-9
Переглянути файл
@@ -491,8 +491,6 @@ export const commands = {
/** Folders holding indexed files, for `@` references. */
findDirs: (query: string, limit: number) => typedError<FileMatch[], IdeError>(__TAURI_INVOKE("find_dirs", { query, limit })),
findSymbols: (query: string, filter: SymbolFilter, limit: number) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols", { query, filter, limit })),
/** Index symbols named exactly one of `names` inside `within` (an agent task's folder). */
findSymbolsNamed: (names: string[], within: IpcPath) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols_named", { names, within })),
markRecent: (path: string) => typedError<null, IdeError>(__TAURI_INVOKE("mark_recent", { path })),
/** Recently opened files, most recent first (⌘E). */
recentFiles: () => typedError<IpcPath[], IdeError>(__TAURI_INVOKE("recent_files")),
@@ -4901,8 +4899,6 @@ export type EditorConfigProps = {
export type EditorGeneralSettings = {
/** Change font size with ⌘ + mouse wheel. */
wheelZoom?: boolean,
/** Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors. */
wheelZoomScope?: string,
markdownImageFolder?: string,
markdownImageNamePattern?: string,
/** Drag-and-drop of selected text inside the editor. */
@@ -5727,11 +5723,6 @@ export type GitSettings = {
pushDialogOnlyProtected?: boolean,
/** Stashes and shelves share one tab. */
combineStashAndShelf?: boolean,
/**
* The non-modal Commit tool window works on the index: Staged / Unstaged groups,
* stage and unstage instead of inclusion checkboxes, and no change lists.
*/
stagingArea?: boolean,
};
export type GoBuildTags = {
+12 -57
Переглянути файл
@@ -8,7 +8,7 @@ import { acceptCompletion, completionStatus } from "@codemirror/autocomplete";
import { executeAction, registerActions, type Action } from "@/platform/actions";
import { getContext } from "@/platform/context";
import { focusedSoftWrapSurface } from "@/workbench/softWrap";
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom, stepSurfaceFontZoomIn } from "@/workbench/contributions";
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom } from "@/workbench/contributions";
import { editorController, useGotoLine, useTabs } from "./controller";
import {
addCaretsToLineEnds,
@@ -71,7 +71,7 @@ import { copyReferenceToClipboard, declaredName, qualifiedReference, referenceOf
import { declarationChain } from "./view/outline";
import { recordClipboard } from "./clipboardHistory";
import { useDocMeta, useOutline } from "./model/document";
import { resetAllEditorsFontZoom, resetConfiguredEditorsFontZoom, stepConfiguredEditorsFontZoom } from "./cm/prefs";
import { resetAllEditorsFontZoom, stepAllEditorsFontZoom } from "./cm/prefs";
import { useProject } from "@/platform/project";
import { call, commands } from "@/platform/ipc";
import { editorPrefs } from "@/platform/editorSettings";
@@ -117,12 +117,7 @@ function withView(run: (view: EditorView, slot: EditorSlot) => unknown) {
};
}
function activePaneEditorFocus(): Element | null {
if (typeof document === "undefined") return null;
return document.querySelector(`[data-pane-id="${useTabs.getState().activePane}"] [data-editor-focus]`);
}
/** Routes keyboard font zoom to focus, then the active editor slot or pane surface. */
/** Routes keyboard font zoom to focus, then the active editor slot. */
function stepSurfaceFontSize(delta: 1 | -1): void {
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
if (activeEl) {
@@ -131,55 +126,18 @@ function stepSurfaceFontSize(delta: 1 | -1): void {
if (cmEl) {
const cmView = EditorView.findFromDOM(cmEl);
if (cmView) {
stepConfiguredEditorsFontZoom(cmView, delta);
stepAllEditorsFontZoom(cmView, delta);
return;
}
}
}
const slot = activeSlot();
if (!slot?.view) {
stepSurfaceFontZoomIn(activePaneEditorFocus(), delta);
return;
}
stepConfiguredEditorsFontZoom(slot.view, delta);
if (!slot?.view) return;
stepAllEditorsFontZoom(slot.view, delta);
if (!slot.view.hasFocus && !getContext().popupOpen) slot.view.focus();
}
function resetFontSize(): void {
const allScope = editorPrefs().general.wheelZoomScope === "all";
const surfaceOpts = allScope ? { isolatedOnly: true } : undefined;
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
if (activeEl) {
if (stepFocusedSurfaceFontZoom(0, surfaceOpts)) return;
if (!allScope) {
const cmEl = activeEl.closest?.(".cm-editor") as HTMLElement | null;
if (cmEl) {
const cmView = EditorView.findFromDOM(cmEl);
if (cmView) {
resetConfiguredEditorsFontZoom(cmView);
return;
}
}
}
}
const slot = activeSlot();
if (!allScope && slot?.view) {
resetConfiguredEditorsFontZoom(slot.view);
return;
}
if (!slot?.view && stepSurfaceFontZoomIn(activePaneEditorFocus(), 0, surfaceOpts)) return;
if (allScope) resetAllFontSize();
}
function resetAllFontSize(): void {
resetAllEditorsFontZoom();
if (typeof document !== "undefined") {
resetSurfaceFontZoom();
}
}
// --- extend / shrink selection ---------------------------------------------------
/** One stack per selection range (by index): ⌥↑ / ⌥↓ work on every caret. */
@@ -976,19 +934,16 @@ export function registerEditorActions(): () => void {
},
{
id: "editor.resetFontSize",
title: "Reset Font Size",
category: "View",
keywords: ["zoom", "font size", "mouse wheel"],
when: "projectOpen",
run: resetFontSize,
},
{
id: "editor.resetFontSizeAll",
title: "Reset Font Size in All Editors",
category: "View",
keywords: ["zoom", "font size", "mouse wheel"],
when: "projectOpen",
run: resetAllFontSize,
run: () => {
resetAllEditorsFontZoom();
if (typeof document !== "undefined") {
resetSurfaceFontZoom();
}
},
},
{
id: "editor.increaseFontSize",
+1 -2
Переглянути файл
@@ -270,7 +270,7 @@ describe("language modes", () => {
}
});
it("colours `this`, `super` and Rust's `self` as keywords", async () => {
it("colours `this` and `super` as keywords in Java, JavaScript, TypeScript and C++", async () => {
const highlighter = tagHighlighter([
{ tag: t.keyword, class: "keyword" },
{ tag: t.self, class: "self" },
@@ -281,7 +281,6 @@ describe("language modes", () => {
["JavaScript", "/p/a.js", "class A extends B { m() { super.m(); this.a = 1; } }", ["super", "this"]],
["TypeScript", "/p/a.ts", "class A extends B { m() { super.m(); this.a = 1; } }", ["super", "this"]],
["C++", "/p/a.cpp", "void A::m() { this->a = 1; }", ["this"]],
["Rust", "/p/a.rs", "impl A { fn m(&self) { self.a = 1; } }", ["self", "self"]],
] as const) {
const support = await loadSupport(findLanguageDescription(mode, path)!);
const found: Array<[string, string]> = [];
+1 -2
Переглянути файл
@@ -308,9 +308,8 @@ const EXTRA_TAGS: Record<string, Parameters<typeof styleTags>[0]> = {
JSX: JS_TAGS,
TSX: JS_TAGS,
Java: JAVA_TAGS,
// CLion colours `this` as a keyword, RustRover `self`.
// CLion colours `this` as a keyword.
"C++": { this: t.keyword },
Rust: { self: t.keyword },
PHP: {
"; ,": t.separator,
"ClassDeclaration/Name BaseClause/Name InterfaceClause/Name": t.className,
+4 -20
Переглянути файл
@@ -37,7 +37,7 @@ import { markdownImages } from "./markdownImages";
import { selectionMarks } from "./selectionMarks";
import { seamlessSelection } from "./selectionLayer";
import { useEditorRegistry } from "@/editor/api";
import { editorPrefs, type EditorExtras } from "@/platform/editorSettings";
import type { EditorExtras } from "@/platform/editorSettings";
import { openideaHighlightStyle } from "./highlight";
import {
cursorHumpLeft,
@@ -426,27 +426,11 @@ export function stepAllEditorsFontZoom(origin: EditorView, delta: number): void
}
}
/** Resets one editor's font zoom to 0. */
export function resetEditorFontZoom(view: EditorView): void {
if (view.state.field(fontZoom, false)) view.dispatch({ effects: setFontZoom.of(0) });
}
/** Resets every open editor's font zoom, and the value new editors start from. */
export function resetAllEditorsFontZoom(): void {
sharedFontZoom = 0;
for (const ed of useEditorRegistry.getState().editors) resetEditorFontZoom(ed.view);
}
/** Steps font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
export function stepConfiguredEditorsFontZoom(origin: EditorView, delta: number): void {
if (editorPrefs().general.wheelZoomScope === "all") stepAllEditorsFontZoom(origin, delta);
else stepFontZoom(origin, delta);
}
/** Resets font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
export function resetConfiguredEditorsFontZoom(origin: EditorView): void {
if (editorPrefs().general.wheelZoomScope === "all") resetAllEditorsFontZoom();
else resetEditorFontZoom(origin);
for (const ed of useEditorRegistry.getState().editors)
if (ed.view.state.field(fontZoom, false)) ed.view.dispatch({ effects: setFontZoom.of(0) });
}
/** Exported for tests: the ⌘/Ctrl+wheel handler of the prefs compartment. */
@@ -454,7 +438,7 @@ export const wheelZoom = EditorView.domEventHandlers({
wheel(e, view) {
if (!e.metaKey && !e.ctrlKey) return false;
e.preventDefault();
stepConfiguredEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
stepAllEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
return true;
},
});
+4 -12
Переглянути файл
@@ -331,20 +331,12 @@ export class EditorController implements SlotHost {
this.disposers.push(
useTabs.subscribe((s, previous) => {
const open = openKeys(s);
const live = new Set<string>();
for (const pane of Object.values(s.panes)) for (const tab of pane.tabs) live.add(tab.id);
const closed = new Map<string, EditorInput>();
const closedTabs: Tab[] = [];
for (const pane of Object.values(previous.panes))
for (const tab of pane.tabs) {
if (!live.has(tab.id)) closedTabs.push(tab);
if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
}
if (!this.replacingProject) {
const kinds = useContributions.getState().editorKinds;
for (const tab of closedTabs) kinds.get(tab.input.kind)?.onTabClose?.(tab.id, tab.input);
for (const input of closed.values()) kinds.get(input.kind)?.onClose?.(input);
}
for (const tab of pane.tabs) if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
if (!this.replacingProject)
for (const input of closed.values())
useContributions.getState().editorKinds.get(input.kind)?.onClose?.(input);
const prev = prevTabs;
prevTabs = s;
if (
+3 -21
Переглянути файл
@@ -2,12 +2,11 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { useEditorRegistry, type TextEditorHandle } from "@/editor/api";
import { useProject } from "@/platform/project";
import { fontZoom, resetAllEditorsFontZoom, setFontZoom, stepAllEditorsFontZoom, wheelZoom } from "./cm/prefs";
const zoomOf = (view: EditorView) => view.state.field(fontZoom, false);
describe("editor font zoom (active editor by default, all editors when configured)", () => {
describe("shared editor font zoom (#2480)", () => {
const handles: TextEditorHandle[] = [];
const makeView = (extensions = [fontZoom, wheelZoom]) => {
const parent = document.createElement("div");
@@ -18,10 +17,7 @@ describe("editor font zoom (active editor by default, all editors when configure
handles.push(handle);
return view;
};
beforeEach(() => {
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
beforeEach(() => resetAllEditorsFontZoom());
afterEach(() => {
for (const handle of handles) {
useEditorRegistry.getState().editors.delete(handle);
@@ -30,23 +26,9 @@ describe("editor font zoom (active editor by default, all editors when configure
}
handles.length = 0;
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
it("zooms only the active editor from ⌘/Ctrl+wheel by default (IDEA parity)", () => {
const first = makeView();
const second = makeView();
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
expect(zoomOf(first)).toBe(1);
expect(zoomOf(second)).toBe(0);
expect(zoomOf(makeView())).toBe(0);
second.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: 10 }));
expect(zoomOf(first)).toBe(1);
expect(zoomOf(second)).toBe(-1);
});
it("zooms every open editor from ⌘/Ctrl+wheel when wheelZoomScope is 'all' (#2480)", () => {
useProject.setState({ settings: { editor: { general: { wheelZoomScope: "all" } } } } as never);
it("zooms every open editor from ⌘/Ctrl+wheel on one of them", () => {
const first = makeView();
const second = makeView();
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
-10
Переглянути файл
@@ -13,8 +13,6 @@ import {
import { _provideCodePreview, _provideDocumentAttacher, editorsFor } from "@/editor/api";
import { isUntitledUri } from "@/platform/virtualDocs";
import { formatDocument } from "@/editor/lsp/format";
import { chooserTitle, locationItems, pinToFind } from "@/editor/lsp/navigation";
import { openPopup } from "@/editor/lsp/popupStore";
import { editorController } from "./controller";
import { attachDocument } from "./model/attachment";
import { previewExtensions } from "./cm/preview";
@@ -66,14 +64,6 @@ export function activate(): void | (() => void) {
forgetSavedTabs: () => ctrl.forgetSavedTabs(),
keepSavedTabs: () => ctrl.keepSavedTabs(),
documentHistory: (command) => ctrl.documentHistory(command),
chooseDeclaration: async (targets, name, anchor) =>
openPopup({
kind: "list",
anchor,
title: chooserTitle("declaration", name, targets.length),
items: await locationItems(targets),
pin: pinToFind(name, targets),
}),
reformat: async (path) => {
const handle = editorsFor(path)[0];
return !!handle && (await formatDocument(handle.view, { explicit: false, selectionOnly: false })).applied;
+1 -8
Переглянути файл
@@ -12,13 +12,11 @@ afterEach(() => {
describe("custom editor close lifecycle", () => {
it("notifies once when the last split showing an input closes", async () => {
const close = vi.fn();
const tabClose = vi.fn();
const dispose = registerEditorKind({
kind: "close-probe",
title: () => "Probe",
component: () => null,
onClose: close,
onTabClose: tabClose,
});
controller = new EditorController(createMemoryBackend({}));
controller.start();
@@ -28,14 +26,9 @@ describe("custom editor close lifecycle", () => {
controller.split(useTabs.getState().activePane, "row");
const panes = Object.values(useTabs.getState().panes);
expect(panes).toHaveLength(2);
const firstTabId = panes[0]!.tabs[0]!.id;
const secondTabId = panes[1]!.tabs[0]!.id;
await controller.closeTab(panes[0]!.id, firstTabId);
expect(tabClose).toHaveBeenCalledExactlyOnceWith(firstTabId, input);
await controller.closeTab(panes[0]!.id, panes[0]!.tabs[0]!.id);
expect(close).not.toHaveBeenCalled();
await controller.closeInput(input.key);
expect(tabClose).toHaveBeenCalledTimes(2);
expect(tabClose).toHaveBeenLastCalledWith(secondTabId, input);
expect(close).toHaveBeenCalledExactlyOnceWith(input);
} finally {
dispose();
+3 -6
Переглянути файл
@@ -21,7 +21,6 @@ import {
prepareMenuGroups,
textEditorWrapperFor,
EditorShownProvider,
EditorTabIdProvider,
useContributions,
useFileDecorations,
useEditorDocumentRevision,
@@ -480,11 +479,9 @@ function KindEditor({ tab, shown, kept = false }: { tab: Tab; shown: boolean; ke
tabIndex={-1}
aria-hidden={shown ? undefined : true}
>
<EditorTabIdProvider value={tab.id}>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
</EditorTabIdProvider>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
</div>
);
}
-15
Переглянути файл
@@ -135,21 +135,6 @@ describe("list popup", () => {
expect(onClose).toHaveBeenCalledOnce();
});
it("focuses the rows, not the header's pin button, when it opens", () => {
openPopup({
kind: "list",
anchor: { x: 0, y: 0 },
title: "Choose Declaration of foo (2 found)",
items: [
{ id: "a", label: "foo", run: vi.fn() },
{ id: "b", label: "foo", run: vi.fn() },
],
pin: { label: "Open in Find Tool Window", run: vi.fn() },
});
render(<LspPopups />);
expect(document.activeElement).toBe(screen.getByRole("listbox"));
});
it("pins the results elsewhere from the header button", () => {
const pin = vi.fn();
openPopup({
-1
Переглянути файл
@@ -210,7 +210,6 @@ function ListPopup({ popup }: { popup: Extract<LspPopup, { kind: "list" }> }) {
activeIndex={activeIndex}
onActiveChange={setActive}
hoverSelects
autoFocus
aria-label={popup.title}
onActivate={(r) => activate(r.item)}
empty={
-5
Переглянути файл
@@ -64,11 +64,6 @@ describe("semanticRanges", () => {
]);
});
it("colours rust-analyzer's `self` as a keyword", () => {
const input = { tokenTypes: ["selfKeyword"], tokenModifiers: [], data: [0, 0, 3, 0, 0] };
expect(semanticRanges(doc, input)[0]?.className).toBe("cm-sem-keyword");
});
it("colours a constructor (jdtls: class + `constructor`) as a function", () => {
const input = { tokenTypes: ["class"], tokenModifiers: ["constructor", "declaration"], data: [0, 0, 3, 0, 0b11] };
expect(semanticRanges(doc, input)[0]?.className).toBe("cm-sem-function cm-sem-declaration");
+1 -2
Переглянути файл
@@ -61,8 +61,7 @@ const TYPE_CLASS: Record<string, string> = {
lifetime: "annotation",
selfParameter: "self",
clsParameter: "self",
// rust-analyzer's `self`: RustRover colours the self parameter as a keyword.
selfKeyword: "keyword",
selfKeyword: "self",
};
const MODIFIER_CLASS: Record<string, string> = {
+2 -2
Переглянути файл
@@ -41,8 +41,8 @@ import {
import { safeDelete } from "./safeDelete";
import { startHierarchyRefactoring } from "./hierarchy";
/** Languages with a server that runs the class-hierarchy refactorings (the app-owned JDT extension; Phoxite for PHP). */
const HIERARCHY_LANGUAGES = new Set(["java", "php"]);
/** Languages whose server runs the class-hierarchy refactorings (the app-owned JDT extension). */
const HIERARCHY_LANGUAGES = new Set(["java"]);
/** Outcome of the server query: its answer, or why there is none. */
export type ServerAnswer =
+1 -1
Переглянути файл
@@ -30,7 +30,7 @@
.field :global(.cm-editor) {
background: transparent;
color: var(--fg-strong);
font-size: var(--agent-fs-ui, var(--fs-ui));
font-size: var(--fs-ui);
}
.field :global(.cm-editor.cm-focused) {
outline: none;
+1 -4
Переглянути файл
@@ -1,7 +1,4 @@
.home {
--agent-fs-ui: calc(var(--fs-ui) + var(--agent-font-zoom, 0px));
--agent-fs-small: calc(var(--fs-small) + var(--agent-font-zoom, 0px));
--agent-fs-code: calc(var(--fs-code) + var(--agent-font-zoom, 0px));
flex: 1;
min-height: 0;
overflow: auto;
@@ -25,7 +22,7 @@
}
.heading {
margin: 0 0 10px;
font-size: calc(18px + var(--agent-font-zoom, 0px));
font-size: 18px;
font-weight: 600;
text-align: center;
color: var(--fg-strong);
+3 -9
Переглянути файл
@@ -14,8 +14,7 @@ import { SubmitButton } from "./SubmitButton";
import { canSend, emptyDraft } from "./composerModel";
import { ConfigPickers } from "./ConfigPickers";
import { useEffortFocus } from "./effortFocus";
import { useAgentFontZoomSurface } from "./fontZoom";
import { HOME_KEY, providerIcon } from "./model";
import { providerIcon } from "./model";
import { ADD_AGENT, providerOptions as agentOptions } from "./providerOptions";
import {
HOME,
@@ -32,7 +31,7 @@ import {
import { useAgentSettings } from "./agentSettings";
import styles from "./Home.module.css";
export function HomeEditor({ docked = false, input }: { docked?: boolean; input?: EditorInput }) {
export function HomeEditor({ docked = false }: { docked?: boolean; input?: EditorInput }) {
const tx = useTx();
const txTemplate = useTxTemplate();
const draft = useAgents((s) => s.draft);
@@ -98,7 +97,6 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input?
const { defaults, fitWindowWidth } = useAgentSettings();
const config = draftConfig(provider, draft, (provider && defaults[provider.id]) || {});
const homeRoot = useRef<HTMLDivElement>(null);
const { zoomStyle } = useAgentFontZoomSurface(homeRoot, input?.key ?? HOME_KEY, docked);
const unavailableModel = config.some(
(o) =>
o.category === "model" &&
@@ -129,11 +127,7 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input?
};
return (
<div
ref={homeRoot}
className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}
style={zoomStyle}
>
<div ref={homeRoot} className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}>
<div className={styles.inner}>
{!docked && (
<h1 className={styles.heading}>
+2 -88
Переглянути файл
@@ -3,20 +3,17 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { clearMocks, mockIPC } from "@tauri-apps/api/mocks";
import { resetMermaidForTests } from "../viewers/markdown/mermaid";
import { StrictMode } from "react";
import { useProject } from "@/platform/project";
import type { SymbolMatch } from "@/platform/ipc";
import { Markdown, markdownBlocks, markdownHtml } from "./Markdown";
const { openFile, chooseDeclaration, openExternalUrl } = vi.hoisted(() => ({
const { openFile, openExternalUrl } = vi.hoisted(() => ({
openFile: vi.fn().mockResolvedValue(undefined),
chooseDeclaration: vi.fn().mockResolvedValue(undefined),
openExternalUrl: vi.fn().mockResolvedValue(undefined),
}));
const copyText = vi.hoisted(() => vi.fn());
const readImage = vi.fn<(path: string) => Promise<string>>();
const PIXEL = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
vi.mock("@/workbench/contributions", () => ({
editorService: () => ({ openFile, chooseDeclaration }),
editorService: () => ({ openFile }),
}));
vi.mock("@/platform/openUrl", () => ({ openExternalUrl }));
vi.mock("@/ui", async (importOriginal) => ({
@@ -352,86 +349,3 @@ describe("streamed replies", () => {
expect(container.textContent?.trim()).toBe("Something else");
});
});
describe("symbol links", () => {
const symbol = (name: string, path: string, line: number): SymbolMatch => ({
name,
kind: "class",
container: null,
path,
relPath: path.slice("/repo/".length),
range: { start: { line, col: 6 }, end: { line, col: 6 + name.length } },
score: 0,
indices: [],
});
const index = [
symbol("FooView", "/repo/src/view.ts", 4),
symbol("BarView", "/repo/src/bar.ts", 1),
symbol("BarView", "/repo/web/bar.ts", 9),
symbol("StreamView", "/repo/src/stream.ts", 2),
symbol("SinkView", "/repo/src/sink.ts", 1),
symbol("SinkView", "/repo/web/sink.ts", 7),
];
let lookups: string[][];
beforeEach(() => {
lookups = [];
useProject.setState({ project: { root: "/repo" } as never });
mockIPC((cmd, args) => {
if (cmd === "fs_probe") throw new Error("missing");
if (cmd !== "find_symbols_named") return null;
const { names } = args as { names: string[] };
lookups.push(names);
return index.filter((symbol) => names.includes(symbol.name));
});
});
afterEach(() => useProject.setState({ project: null }));
const code = (container: HTMLElement, text: string) =>
[...container.querySelectorAll<HTMLElement>("code")].find((span) => span.textContent === text)!;
it("opens the one definition a name has, and leaves other code plain", async () => {
const { container } = render(<Markdown text={"`FooView` runs `cargo test`, see `Missing`."} cwd="/repo/one" />);
await waitFor(() => expect(code(container, "FooView").dataset.path).toBe("/repo/src/view.ts"));
expect(code(container, "cargo test").dataset.path).toBeUndefined();
expect(code(container, "Missing").dataset.path).toBeUndefined();
expect(lookups).toEqual([["FooView", "Missing"]]);
fireEvent.click(code(container, "FooView"));
expect(openFile).toHaveBeenCalledWith("/repo/src/view.ts", { focus: true, selection: { line: 4, col: 6 } });
});
it("looks a streamed reply's names up once, after its text settles", async () => {
const reply = "First `StreamView`.\n\nThen `SinkView` in `web/sink.ts` and `StreamView` again.";
const { container, rerender } = render(<Markdown text={reply.slice(0, 10)} cwd="/repo/two" />);
for (let end = 12; end <= reply.length; end += 6) rerender(<Markdown text={reply.slice(0, end)} cwd="/repo/two" />);
rerender(<Markdown text={reply} cwd="/repo/two" />);
await waitFor(() => expect(code(container, "SinkView").dataset.path).toBe("/repo/web/sink.ts"));
expect(lookups).toEqual([["StreamView", "SinkView"]]);
rerender(<Markdown text={`${reply}\n\nDone with \`StreamView\`.`} cwd="/repo/two" />);
await new Promise((resolve) => setTimeout(resolve, 600));
expect(lookups).toHaveLength(1);
});
it("shows Go to Declaration's chooser when several files define the name", async () => {
const { container } = render(<Markdown text={"Both define `BarView`."} cwd="/repo" />);
await waitFor(() => expect(code(container, "BarView").className).not.toBe(""));
expect(code(container, "BarView").dataset.path).toBeUndefined();
fireEvent.click(code(container, "BarView"));
expect(openFile).not.toHaveBeenCalled();
expect(chooseDeclaration).toHaveBeenCalledWith(
[expect.objectContaining({ path: "/repo/src/bar.ts" }), expect.objectContaining({ path: "/repo/web/bar.ts" })],
"BarView",
expect.objectContaining({ x: expect.any(Number), y: expect.any(Number) }),
);
});
it("keeps a file a span names over a symbol of the same name", async () => {
mockIPC((cmd, args) => {
if (cmd === "fs_probe") return null;
if (cmd === "find_symbols_named") lookups.push((args as { names: string[] }).names);
return null;
});
const { container } = render(<Markdown text={"Open `Config.load`."} cwd="/repo/three" />);
await waitFor(() => expect(code(container, "Config.load").dataset.path).toBe("/repo/three/Config.load"));
});
});
+12 -111
Переглянути файл
@@ -1,28 +1,25 @@
/**
* Agent messages: Markdown → sanitized HTML (marked + DOMPurify). Fenced code is
* highlighted and gets a Copy button; inline code naming a file of the task, or a symbol
* the index has, opens it.
* highlighted and gets a Copy button; inline code naming a file of the task opens it.
* Mermaid fences become `[data-mermaid]` placeholders drawn by the Markdown viewer's
* shared renderer after each render; the block keeps a Copy button of its own, since
* the drawn diagram hides the code block, and `onDiagramDrawn` lets the conversation
* follow the end when a diagram draws after the last streamed chunk.
*/
import { useEffect, useLayoutEffect, useRef, useSyncExternalStore } from "react";
import { useLayoutEffect, useRef, useSyncExternalStore } from "react";
import { Marked } from "marked";
import DOMPurify from "dompurify";
import { highlightInto } from "@/editor/lsp/markdown";
import { iconNode } from "@/ui/iconNode";
import { tx } from "@/platform/i18n";
import { openExternalUrl } from "@/platform/openUrl";
import { useProject } from "@/platform/project";
import { copyText } from "@/ui";
import { editorService, type DeclarationChoice } from "@/workbench/contributions";
import { editorService } from "@/workbench/contributions";
import { hasMermaid, renderMermaidIn } from "@/features/viewers/markdown/mermaid";
import { subscribeTheme, themeKey } from "@/platform/themeWatch";
import { fileHref, pathLink, symbolRef, type PathLink, type SymbolRef } from "./conversation";
import { fileHref, pathLink, type PathLink } from "./conversation";
import { loadImages, type MessageImages } from "./markdownImages";
import { fileExists } from "./ReferenceChip";
import { inTaskFolder, lookupSymbols, symbolTargets } from "./symbolLinks";
import styles from "./Session.module.css";
const escapeHtml = (s: string) =>
@@ -175,58 +172,6 @@ export function openPathLink(link: PathLink) {
void editorService().openFile(link.path, { selection, focus: true });
}
/** The symbol each inline code span names. */
const symbolRefs = new WeakMap<Element, SymbolRef>();
/** Whether inline code that names a symbol also names an existing file (which it then opens). */
const fileChecks = new WeakMap<Element, Promise<boolean>>();
/** Inline code naming a symbol defined in several places: the chooser's targets. */
const choices = new WeakMap<Element, DeclarationChoice[]>();
/** How long a reply's text stays unchanged before its symbols are looked up. */
const SETTLE_MS = 400;
function mentionedPaths(root: HTMLElement): string[] {
const codePaths = [...root.querySelectorAll("code")].map((code) => pathLink(code.textContent ?? "", "")?.path);
const linkPaths = [...root.querySelectorAll("a[href]")].map(
(anchor) => fileHref(anchor.getAttribute("href") ?? "", "")?.path,
);
return [...codePaths, ...linkPaths].filter((path): path is string => !!path);
}
function markPath(element: HTMLElement, link: PathLink) {
element.classList.add(styles.fileLink!);
element.dataset.path = link.path;
if (link.line !== undefined) element.dataset.line = String(link.line);
if (link.col !== undefined) element.dataset.col = String(link.col);
element.title = tx`Open ${link.path}`;
}
/** Links `spans` of the reply in `root` to their definitions: one index lookup for all their names. */
async function linkSymbols(root: HTMLElement, spans: HTMLElement[], cwd: string) {
const projectRoot = useProject.getState().project?.root ?? cwd;
const refs = spans.map((code) => symbolRefs.get(code)!);
const answers = lookupSymbols(
projectRoot,
refs.map((ref) => ref.name),
);
const mentioned = mentionedPaths(root);
await Promise.all(
spans.map(async (code, at) => {
if (await fileChecks.get(code)) return;
const ref = refs[at]!;
const found = (await answers.get(ref.name)!).map((symbol) => inTaskFolder(symbol, projectRoot, cwd));
const targets = symbolTargets(ref, found, mentioned, cwd);
if (!code.isConnected || !targets.length) return;
if (targets.length > 1) {
code.classList.add(styles.fileLink!);
choices.set(code, targets);
return;
}
const { path, range } = targets[0]!;
markPath(code, { path, line: range.start.line, col: range.start.col });
}),
);
}
/** Highlighting, Copy buttons and file links over freshly rendered `root`. */
function enhance(root: HTMLElement, cwd: string, images: MessageImages): () => void {
let alive = true;
@@ -252,15 +197,15 @@ function enhance(root: HTMLElement, cwd: string, images: MessageImages): () => v
});
root.querySelectorAll<HTMLElement>("code").forEach((code) => {
if (code.parentElement?.tagName === "PRE" || code.closest("a")) return;
const text = code.textContent ?? "";
const ref = symbolRef(text);
if (ref) symbolRefs.set(code, ref);
const link = pathLink(text, cwd);
const link = pathLink(code.textContent ?? "", cwd);
if (!link) return;
const exists = fileExists(link.path);
if (ref) fileChecks.set(code, exists);
void exists.then((found) => {
if (alive && found) markPath(code, link);
void fileExists(link.path).then((exists) => {
if (!alive || !exists) return;
code.classList.add(styles.fileLink!);
code.dataset.path = link.path;
if (link.line !== undefined) code.dataset.line = String(link.line);
if (link.col !== undefined) code.dataset.col = String(link.col);
code.title = tx`Open ${link.path}`;
});
});
return () => {
@@ -331,9 +276,6 @@ export function Markdown({
const diagrams = useRef<Node[]>([]);
// Diagrams are drawn in the active theme's colours: a theme change redraws them.
const theme = useSyncExternalStore(subscribeTheme, themeKey, () => "");
useLayoutEffect(() => {
images.current.onLoaded = onDiagramDrawn;
}, [onDiagramDrawn]);
useLayoutEffect(() => {
const root = ref.current;
if (!root) return;
@@ -351,39 +293,6 @@ export function Markdown({
const blocks = painted.current;
return () => clearBlocks(blocks, 0);
}, []);
/** Symbol spans already looked up (or being looked up). */
const looked = useRef(new WeakSet<Element>());
// Symbols: once the text stops changing (a streamed reply changes its last block on every
// chunk), the spans not looked up yet, as they come into view.
useEffect(() => {
const root = ref.current;
if (!root) return;
let observer: IntersectionObserver | null = null;
const lookUp = (spans: HTMLElement[]) => {
spans.forEach((span) => looked.current.add(span));
if (spans.length) void linkSymbols(root, spans, cwd);
};
const timer = setTimeout(() => {
const spans = [...root.querySelectorAll<HTMLElement>("code")].filter(
(code) => symbolRefs.has(code) && !looked.current.has(code),
);
if (!spans.length) return;
if (typeof IntersectionObserver === "undefined") {
lookUp(spans);
return;
}
observer = new IntersectionObserver((entries) => {
const shown = entries.filter((entry) => entry.isIntersecting).map((entry) => entry.target as HTMLElement);
shown.forEach((span) => observer!.unobserve(span));
lookUp(shown);
});
spans.forEach((span) => observer!.observe(span));
}, SETTLE_MS);
return () => {
clearTimeout(timer);
observer?.disconnect();
};
}, [text, cwd]);
// Mermaid diagrams: before paint, so cached ones don't flash their source. Only a
// draw that lands after the render needs the follow — cached ones are in place by
// the time the conversation's own render pass scrolls.
@@ -409,14 +318,6 @@ export function Markdown({
void copyText(copy.dataset.copy ?? "");
return;
}
const code = target.closest<HTMLElement>("code");
const targets = code && choices.get(code);
if (targets && !window.getSelection()?.toString()) {
const rect = code.getBoundingClientRect();
const name = symbolRefs.get(code)!.name;
void editorService().chooseDeclaration?.(targets, name, { x: rect.left, y: rect.bottom + 2 });
return;
}
const file = target.closest<HTMLElement>("code[data-path]");
if (file && !window.getSelection()?.toString()) {
const line = file.dataset.line === undefined ? undefined : Number(file.dataset.line);
+4 -4
Переглянути файл
@@ -4,7 +4,7 @@
align-items: center;
gap: var(--space-1);
max-width: 100%;
height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
height: 20px;
padding: 0 6px 0 4px;
margin: 0 1px;
vertical-align: -4px;
@@ -12,8 +12,8 @@
background: color-mix(in srgb, var(--fg) 9%, transparent);
box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--fg) 14%, transparent);
color: var(--fg-strong);
font-size: var(--agent-fs-small, var(--fs-small));
line-height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
font-size: var(--fs-small);
line-height: 20px;
white-space: nowrap;
cursor: pointer;
user-select: none;
@@ -243,7 +243,7 @@
padding: 6px 10px;
color: var(--fg-editor);
font-family: var(--font-mono);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
line-height: 1.5;
white-space: pre;
overflow-x: auto;
+32 -57
Переглянути файл
@@ -1,9 +1,6 @@
.session {
--session-content-width: var(--agent-conversation-width);
--session-card-width: 80%;
--agent-fs-ui: calc(var(--fs-ui) + var(--agent-font-zoom, 0px));
--agent-fs-small: calc(var(--fs-small) + var(--agent-font-zoom, 0px));
--agent-fs-code: calc(var(--fs-code) + var(--agent-font-zoom, 0px));
flex: 1;
min-height: 0;
min-width: 0;
@@ -255,7 +252,6 @@
padding: var(--space-3);
display: flex;
flex-direction: column;
font-size: var(--agent-fs-ui, var(--fs-ui));
}
/* Actual row heights keep WebKit's scrollbar and cross-message selections anchored. */
.stream > * {
@@ -326,7 +322,7 @@
-webkit-user-select: none;
user-select: none;
color: var(--fg-subtle);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
white-space: nowrap;
}
.messageHead > .role {
@@ -361,7 +357,7 @@
gap: 5px;
margin-bottom: 3px;
color: var(--fg-subtle);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
-webkit-user-select: none;
user-select: none;
}
@@ -555,7 +551,7 @@
}
.markdown :global(code) {
font-family: var(--font-mono);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
padding: 0 2px;
border-radius: 3px;
background: var(--md-code-bg);
@@ -624,19 +620,12 @@
display: none;
}
.markdown :global(.mermaid-output) {
overflow-x: auto;
overflow-y: hidden;
overflow: hidden;
text-align: center;
/* Node labels are drawing, not text: selecting across a reply skips them. */
-webkit-user-select: none;
user-select: none;
}
.markdown :global(.mermaid-output svg[data-natural-width]) {
display: block;
margin: 0 auto;
width: calc(min(var(--diagram-width), 100%) * var(--markdown-zoom-scale, 1));
height: auto;
}
.markdown :global([data-mermaid-state="error"] > .mermaid-output) {
margin-top: 6px;
padding: 6px 10px;
@@ -645,7 +634,7 @@
background: var(--bg-elev);
color: var(--danger);
font-family: var(--font-mono);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
text-align: left;
white-space: pre-wrap;
}
@@ -659,17 +648,10 @@
.markdown :global(ul),
.markdown :global(ol) {
--md-list-indent: 1.55em;
margin: 0 0 8px;
padding-left: var(--md-list-indent);
padding-left: 20px;
list-style: none;
}
.markdown :global(ol) {
--md-list-indent: 2.1em;
}
.markdown :global(ol:has(> li:nth-child(100))) {
--md-list-indent: 2.75em;
}
/* Markers are drawn as pseudo-elements: WebKit paints a selection box around a native marker,
leaving a broken stripe down the gutter when a list is selected. */
.markdown :global(li) {
@@ -677,8 +659,7 @@
}
.markdown :global(li)::before {
position: absolute;
right: calc(100% + 0.45em);
white-space: nowrap;
right: calc(100% + 6px);
-webkit-user-select: none;
user-select: none;
}
@@ -740,11 +721,7 @@
border-top: 1px solid var(--border);
}
.markdown :global(img) {
max-width: calc(100% * var(--markdown-zoom-scale, 1));
}
.markdown :global(img[data-natural-width]) {
width: calc(min(var(--image-width), 100%) * var(--markdown-zoom-scale, 1));
height: auto;
max-width: 100%;
}
.loadImage {
padding: 2px 8px;
@@ -759,7 +736,7 @@
background: var(--bg-hover);
}
.markdown :global(li:has(> input[type="checkbox"])) {
margin-left: calc(-1 * var(--md-list-indent));
margin-left: -20px;
}
.markdown :global(li:has(> input[type="checkbox"]))::before {
content: none;
@@ -785,9 +762,9 @@
align-items: center;
gap: var(--space-1);
min-width: 0;
min-height: var(--h-row);
height: var(--h-row);
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
-webkit-user-select: none;
user-select: none;
}
@@ -840,7 +817,7 @@
}
.toolTitle {
min-width: 0;
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
@@ -853,7 +830,7 @@
}
.toolDiff {
font: inherit;
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
border: 0;
background: none;
padding: 0 4px;
@@ -884,7 +861,7 @@
padding: 0 calc(var(--space-2) / 2);
border-radius: var(--radius-row);
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
-webkit-user-select: none;
user-select: none;
}
@@ -940,7 +917,7 @@
border: 1px solid var(--border);
background: var(--bg-elev);
font-family: var(--font-mono);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
white-space: pre-wrap;
overflow-wrap: anywhere;
color: var(--fg-secondary);
@@ -997,7 +974,7 @@
.permissionCommand {
min-width: 0;
max-width: 100%;
max-height: calc((var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6) * 6);
max-height: calc(var(--lh-code) * 6);
box-sizing: border-box;
margin: 0;
padding: var(--space-2);
@@ -1007,8 +984,8 @@
background: var(--bg-editor);
color: var(--fg);
font-family: var(--font-mono);
font-size: var(--agent-fs-code, var(--fs-code));
line-height: calc(var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6);
font-size: var(--fs-code);
line-height: var(--lh-code);
white-space: pre-wrap;
overflow-wrap: anywhere;
tab-size: 2;
@@ -1046,7 +1023,7 @@
text-overflow: ellipsis;
white-space: nowrap;
font-family: var(--font-mono);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.permissionDone {
padding: calc(var(--space-2) / 2) 0;
@@ -1054,7 +1031,7 @@
border-radius: var(--radius-small);
background: none;
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.permissionRecord {
display: block;
@@ -1143,7 +1120,6 @@
padding: 0 4px 0 8px;
border-radius: var(--radius-row);
background: var(--bg-elev);
font-size: var(--agent-fs-ui, var(--fs-ui));
}
.queuedText {
flex: 1;
@@ -1236,7 +1212,7 @@
flex-wrap: wrap;
gap: var(--space-1) var(--space-1-5);
margin-top: 4px;
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.attachment {
display: inline-flex;
@@ -1449,7 +1425,7 @@
flex: none;
margin-left: auto;
color: var(--fg-subtle);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
@@ -1457,7 +1433,7 @@
padding-left: 22px;
color: var(--fg-muted);
font-family: var(--font-mono);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
@@ -1465,7 +1441,7 @@
.subagentSection > summary {
padding-left: 22px;
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
cursor: pointer;
list-style: none;
}
@@ -1534,7 +1510,7 @@
.messageFrom {
margin-bottom: 2px;
color: var(--fg-subtle);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.readOnly {
@@ -1591,7 +1567,6 @@
border: 1px solid var(--border-strong);
border-radius: var(--radius-control);
background: var(--bg-elev);
font-size: var(--agent-fs-ui, var(--fs-ui));
container: question-card / inline-size;
}
.questionTabCheck {
@@ -1642,7 +1617,7 @@
border-radius: var(--radius-small);
background: var(--bg-hover);
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.questionLabel .questionTag {
margin: 0 0 0 8px;
@@ -1699,13 +1674,13 @@
}
.questionDescription {
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
overflow-wrap: anywhere;
}
.questionKey {
flex: none;
color: var(--fg-subtle);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.questionOther {
margin: 2px 0 0 30px;
@@ -1750,7 +1725,7 @@
}
.questionPreviewCaption {
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.questionPreviewBody {
margin: 0;
@@ -1760,14 +1735,14 @@
border-radius: var(--radius-small);
background: var(--bg-editor);
font-family: var(--font-mono);
font-size: var(--agent-fs-code, var(--fs-code));
font-size: var(--fs-code);
}
.questionPreviewEmpty {
padding: 8px;
border: 1px dashed var(--border);
border-radius: var(--radius-small);
color: var(--fg-subtle);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
}
.questionActions {
display: flex;
@@ -1783,7 +1758,7 @@
}
.questionPage {
color: var(--fg-subtle);
font-size: var(--agent-fs-small, var(--fs-small));
font-size: var(--fs-small);
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
+13 -40
Переглянути файл
@@ -81,7 +81,6 @@ import {
} from "./composerModel";
import { ConfigPickers } from "./ConfigPickers";
import { useEffortFocus } from "./effortFocus";
import { useAgentFontZoomSurface } from "./fontZoom";
import { findRanges, formatDuration, formatSentAt, isFindRangeShown } from "./conversation";
import { ImagePreview, imageSrc } from "./ImagePreview";
import { useAgentSettings } from "./agentSettings";
@@ -116,7 +115,6 @@ import {
hasTaskTerminal,
isBusy,
providerIcon,
sessionKey,
statusLabel,
subagentStatusLabel,
subagentTitle,
@@ -225,7 +223,6 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
const [inputFocus, setInputFocus] = useState(0);
const { fitWindowWidth } = useAgentSettings();
const sessionRoot = useRef<HTMLDivElement>(null);
const { fontZoom, zoomStyle } = useAgentFontZoomSurface(sessionRoot, sessionKey(id), docked, !!task);
const canFocusInput = shown && !!task && task.status !== "archived" && !view;
const session = useMemo<FocusedSession>(
() => ({
@@ -258,7 +255,7 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
changesOpen && !docked && styles.withChanges,
fitWindowWidth && styles.fitWidth,
)}
style={{ ...changesWidth, ...zoomStyle }}
style={changesWidth}
onFocusCapture={() => shown && setFocusedSession(session)}
onBlurCapture={(e) => {
if (!e.currentTarget.contains(e.relatedTarget as Node | null) && focusedSession() === session) {
@@ -294,7 +291,6 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
onOpenSubagent={openSubagent}
finding={finding && shown}
findFocus={findFocus}
fontZoom={fontZoom}
onCloseFind={() => setFinding(false)}
/>
</FoldedContent.Provider>
@@ -615,10 +611,9 @@ function useOffscreenRows(
visible: boolean,
enabled: boolean,
fitWindowWidth: boolean,
fontZoom: number,
) {
// The container width, column mode and font zoom the marked rows were laid out at.
const measured = useRef<{ width: number; fitWindowWidth: boolean; fontZoom: number } | null>(null);
// The container width and column mode the marked rows were laid out at.
const measured = useRef<{ width: number; fitWindowWidth: boolean } | null>(null);
useLayoutEffect(() => {
const el = ref.current;
if (!el) return;
@@ -633,15 +628,10 @@ function useOffscreenRows(
return;
}
if (!visible) return;
if (
measured.current?.width === el.clientWidth &&
measured.current.fitWindowWidth === fitWindowWidth &&
measured.current.fontZoom === fontZoom
)
return;
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
measured.current = { width: el.clientWidth, fitWindowWidth };
unmark();
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
}, [ref, visible, enabled, fitWindowWidth]);
useEffect(() => {
const el = ref.current;
if (!el || !enabled || !visible) return;
@@ -664,13 +654,8 @@ function useOffscreenRows(
});
};
const remeasure = () => {
if (
measured.current?.width === el.clientWidth &&
measured.current.fitWindowWidth === fitWindowWidth &&
measured.current.fontZoom === fontZoom
)
return;
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
measured.current = { width: el.clientWidth, fitWindowWidth };
unmark();
};
remeasure();
@@ -691,7 +676,7 @@ function useOffscreenRows(
rows.disconnect();
resize.disconnect();
};
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
}, [ref, visible, enabled, fitWindowWidth]);
}
interface StreamProps {
@@ -704,7 +689,6 @@ interface StreamProps {
finding: boolean;
/** Bumped by Find in Conversation: focus the find field again. */
findFocus: number;
fontZoom: number;
onCloseFind: () => void;
}
@@ -720,17 +704,7 @@ function scrollsInside(target: EventTarget | null, root: HTMLElement): boolean {
return false;
}
function Stream({
loadError,
task,
entries,
subagent,
onOpenSubagent,
finding,
findFocus,
fontZoom,
onCloseFind,
}: StreamProps) {
function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, findFocus, onCloseFind }: StreamProps) {
const ref = useRef<HTMLDivElement>(null);
useSelectionBoundary(ref);
const [openFolds] = useState(() => new Map<string, boolean>());
@@ -825,7 +799,7 @@ function Stream({
// Hidden behind another tab, it has no layout to scroll; shown again, it follows the end again.
const visible = useEditorShown();
const { foldTurns, toolCalls, fitWindowWidth } = useAgentSettings();
useOffscreenRows(ref, visible, !finding, fitWindowWidth, fontZoom);
useOffscreenRows(ref, visible, !finding, fitWindowWidth);
/** A diagram that drew after the last streamed chunk grows the conversation: keep following. */
const onDiagramDrawn = useCallback(() => {
const el = ref.current;
@@ -994,10 +968,9 @@ function Stream({
className={clsx(styles.stream, selectableText)}
tabIndex={-1}
onWheel={(e) => {
if (e.defaultPrevented) return;
markUserScroll();
if (e.deltaY < 0 && !e.ctrlKey && !e.metaKey) stopFollowing(e.target);
else if (e.deltaY > 0 && !e.ctrlKey && !e.metaKey) scrollingUp.current = false;
if (e.deltaY < 0 && !e.ctrlKey && !e.defaultPrevented) stopFollowing(e.target);
else if (e.deltaY > 0 && !e.ctrlKey && !e.defaultPrevented) scrollingUp.current = false;
}}
onTouchStart={(e) => {
touchY.current = e.touches.length === 1 ? e.touches[0]!.clientY : null;
-39
Переглянути файл
@@ -7,7 +7,6 @@ import {
isFindRangeShown,
pathLink,
quoteText,
symbolRef,
withQuote,
} from "./conversation";
@@ -47,44 +46,6 @@ describe("pathLink", () => {
});
});
describe("symbolRef", () => {
it("reads the forms a reply names a symbol in", () => {
expect(symbolRef("FooView")).toMatchObject({ name: "FooView", kinds: expect.arrayContaining(["class"]) });
expect(symbolRef("load()")).toMatchObject({ name: "load", kinds: ["function", "method", "constructor"] });
expect(symbolRef("validate(input)")).toMatchObject({ name: "validate" });
expect(symbolRef("has_header")).toMatchObject({ name: "has_header", kinds: ["function", "method", "constructor"] });
expect(symbolRef("loadConfig")).toMatchObject({ name: "loadConfig" });
expect(symbolRef("Config.load")).toMatchObject({ name: "load", container: "Config" });
expect(symbolRef("Config::load()")).toMatchObject({ name: "load", container: "Config" });
expect(symbolRef("lib.rs::has_header")).toMatchObject({ name: "has_header", file: "lib.rs" });
expect(symbolRef("src/a.ts#load")).toMatchObject({ name: "load", file: "src/a.ts" });
});
it("leaves words, keywords, literals, commands and code plain", () => {
for (const text of [
"true",
"null",
"inventory",
"None",
"False",
"Self",
"Some(x)",
"None.value",
"42",
"1.5",
"cargo test",
"git log --oneline",
"x = 1",
"a && b",
"$HOME",
"foo(bar(1))",
"TODO",
"src/",
]) {
expect(symbolRef(text)).toBeNull();
}
});
});
describe("fileHref", () => {
const cwd = "C:/repo";
it("resolves a link against the task folder", () => {
+1 -44
Переглянути файл
@@ -1,6 +1,5 @@
/** Reading an agent conversation: quoting, file and symbol links, turn times and finding text. */
/** Reading an agent conversation: quoting, file links, turn times and finding text. */
import type { SymbolKind } from "@/platform/ipc";
import { opensOtherShare } from "@/platform/paths";
/** `text` as a Markdown quote for the composer, followed by an empty line to type in. */
@@ -65,48 +64,6 @@ export function pathLink(text: string, cwd: string): PathLink | null {
return out;
}
/** A symbol an inline code span names: `name`, inside `container` or `file` when the text says so. */
export interface SymbolRef {
name: string;
container?: string;
/** The tail of the defining file's path (`lib.rs`, `src/a.ts`). */
file?: string;
kinds: readonly SymbolKind[];
}
const IDENT = "[A-Za-z_$][\\w$]*";
const CALL = "(\\([^()]*\\))?";
const SYMBOL = new RegExp(`^(?:(${IDENT})(?:\\.|#|::))?(${IDENT})${CALL}$`);
const FILE_SYMBOL = new RegExp(`^((?:[\\w.@-]+\\/)*[\\w@-]+\\.[A-Za-z]\\w*)(?:#|::)(${IDENT})${CALL}$`);
const TYPE_KINDS: readonly SymbolKind[] = ["class", "interface", "struct", "enum", "trait", "typeAlias", "function"];
const CALLABLE_KINDS: readonly SymbolKind[] = ["function", "method", "constructor"];
const MEMBER_KINDS: readonly SymbolKind[] = [...CALLABLE_KINDS, "field", "property", "constant", "enumMember"];
const ANY_KINDS: readonly SymbolKind[] = [...new Set<SymbolKind>([...TYPE_KINDS, ...MEMBER_KINDS, "variable"])];
/** Capitalized keywords and literals that read like a type name. */
const LITERALS = new Set(["None", "True", "False", "Self", "Some", "Ok", "Err", "Null", "Nil", "NaN", "Infinity"]);
/**
* The symbol inline code names (`FooView`, `load()`, `has_header`, `Config.load`,
* `lib.rs::has_header`, `a.ts#load`); null for words, keywords, literals and anything
* with spaces or shell syntax (`cargo test`, `true`, `None`, `x = 1`).
*/
export function symbolRef(text: string): SymbolRef | null {
const trimmed = text.trim();
const inFile = FILE_SYMBOL.exec(trimmed);
if (inFile) return { name: inFile[2]!, file: inFile[1]!, kinds: ANY_KINDS };
const match = SYMBOL.exec(trimmed);
if (!match) return null;
const [, container, name, call] = match;
if (LITERALS.has(container ?? name!)) return null;
if (container) return { name: name!, container, kinds: MEMBER_KINDS };
if (call) return { name: name!, kinds: CALLABLE_KINDS };
if (/^[A-Z]\w*[a-z]/.test(name!)) return { name: name!, kinds: TYPE_KINDS };
if (/^[a-z]\w*[a-z\d][A-Z]/.test(name!) || /^[a-z][a-z\d]*(?:_[a-z\d]+)+$/.test(name!)) {
return { name: name!, kinds: CALLABLE_KINDS };
}
return null;
}
/** `850ms`, `12s`, `1m 05s`, `2h 03m`. */
export function formatDuration(ms: number): string {
if (ms < 1000) return `${Math.max(0, Math.round(ms))}ms`;
-380
Переглянути файл
@@ -1,380 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { act, cleanup, render } from "@testing-library/react";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import type { AgentEntry, AgentTask } from "@/bindings";
import { _addEditor, _removeEditor, type EditorDocContext } from "@/editor/api";
import { fontZoom as cmFontZoom, resetAllEditorsFontZoom } from "@/editor/core/cm/prefs";
import type { EditorSlot } from "@/editor/core/model/slot";
import { executeAction } from "@/platform/actions";
import { useContextKeys } from "@/platform/context";
import { useProject } from "@/platform/project";
import { EditorShownProvider, EditorTabIdProvider } from "@/workbench/contributions";
import { HomeEditor } from "./HomeEditor";
import { SessionEditor } from "./SessionEditor";
import {
clearAgentTabFontZoom,
clearAgentTaskFontZoom,
resetAllAgentFontZoom,
stepAgentSurfaceFontZoom,
useAgentFontZoom,
} from "./fontZoom";
import { SESSION_KIND, sessionKey } from "./model";
import { disconnect, useAgents } from "./store";
import styles from "./Session.module.css";
let activeSlot: Partial<EditorSlot> | null = null;
const imageReads = new Map<string, string>();
vi.mock("@/editor/core/controller", async (importOriginal) => ({
...(await importOriginal<object>()),
editorController: () => ({
get activeSlot() {
return activeSlot;
},
}),
}));
vi.mock("@tauri-apps/api/webview", () => ({
getCurrentWebview: () => ({
onDragDropEvent: () => Promise.resolve(() => {}),
}),
}));
vi.mock("@/platform/ipc", async (original) => ({
...(await original<typeof import("@/platform/ipc")>()),
commands: {
fsProbe: async () => ({
status: "ok",
data: { size: 1, binary: false, tooLarge: false },
}),
fsReadImage: async (path: string) => {
const url = imageReads.get(path);
if (url) return { status: "ok", data: url };
return { status: "error", error: { kind: "notFound", message: path } };
},
agentEntries: async () => ({ status: "ok", data: [] as AgentEntry[] }),
agentChanges: async () => ({ status: "ok", data: [] }),
agentGroupedChanges: async () => ({ status: "ok", data: { uncommitted: [], commits: [] } }),
agentProviders: async () => ({ status: "ok", data: [] }),
vcsBranchInfo: async () => ({ status: "ok", data: { head: "main" } }),
vcsBranches: async () => ({ status: "ok", data: [] }),
},
}));
const { registerEditorActions } = await import("@/editor/core/actions");
const { useTabs } = await import("@/editor/core/controller");
const makeTask = (id: string): AgentTask => ({
id,
title: id,
provider: "copilot",
status: "ready",
isolation: "local",
model: null,
cwd: "/project",
branch: null,
base: null,
baseCommit: null,
error: null,
createdMs: 0,
updatedMs: 0,
config: [],
commands: [],
usage: null,
queue: [],
});
describe("Agent chat font size zoom", () => {
const disposers: Array<() => void> = [];
const views: EditorView[] = [];
beforeEach(() => {
resetAllEditorsFontZoom();
resetAllAgentFontZoom();
imageReads.clear();
disposers.push(registerEditorActions());
useContextKeys.setState({ projectOpen: true, textEditorActive: false, editorFocus: true, popupOpen: false });
useProject.setState({
project: { name: "openidea", root: "/project", isGit: true, workspace: null } as never,
settings: null,
});
const t1 = makeTask("t1");
const t2 = makeTask("t2");
useAgents.setState({
loaded: true,
tasks: new Map([
[t1.id, t1],
[t2.id, t2],
]),
entries: new Map([
[t1.id, [{ type: "agent", text: "Hello `world`" }]],
[t2.id, [{ type: "agent", text: "Second task" }]],
]),
});
});
afterEach(() => {
cleanup();
for (const view of views.splice(0)) view.destroy();
for (const dispose of disposers.splice(0).reverse()) dispose();
activeSlot = null;
disconnect();
resetAllAgentFontZoom();
useProject.setState({ project: null, settings: null });
useContextKeys.setState({}, true);
});
it("scales only the focused Agent chat tab with ⌘=/⌘-/⌘0, clamped to -6..36, leaving other chat tabs untouched", async () => {
const { container } = render(
<div>
<div data-pane-id="left">
<div data-editor-focus="" tabIndex={-1}>
<EditorTabIdProvider value="tab-1">
<EditorShownProvider value={true}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
<EditorTabIdProvider value="tab-kept">
<EditorShownProvider value={false}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t2"), data: { task: "t2" } }} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
<div data-pane-id="right">
<div data-editor-focus="" tabIndex={-1}>
<EditorTabIdProvider value="tab-2">
<EditorShownProvider value={true}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
</div>
<HomeEditor docked />
</div>,
);
act(() => useTabs.setState((s) => ({ ...s, activePane: "left" })));
const sessions = container.querySelectorAll<HTMLElement>(`.${styles.session}`);
const leftSession = sessions[0]!;
const keptSession = sessions[1]!;
const rightSession = sessions[2]!;
const home = container.querySelector<HTMLElement>('[class*="home"]')!;
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(home.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
// Works when the composer's CodeMirror input in tab-1 has focus — only tab-1 changes.
leftSession.querySelector<HTMLElement>(".cm-content")!.focus();
await act(() => executeAction("editor.increaseFontSize"));
await act(() => executeAction("editor.increaseFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
expect(leftSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("1.1538");
expect(keptSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(home.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
// Focusing right split tab-2 (even showing the same task t1) zooms only tab-2.
rightSession.querySelector<HTMLElement>(".cm-content")!.focus();
await act(() => executeAction("editor.decreaseFontSize"));
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("-1px");
expect(rightSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("0.9231");
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
// ⌘0 while focused in tab-2 resets only tab-2, keeping tab-1 at +2px.
await act(() => executeAction("editor.resetFontSize"));
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
// Works when the active pane's KindEditor [data-editor-focus] wrapper or body has focus.
const leftWrapper = container.querySelector<HTMLElement>('[data-pane-id="left"] [data-editor-focus]')!;
leftWrapper.focus();
await act(() => executeAction("editor.increaseFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("3px");
document.body.focus();
await act(() => executeAction("editor.decreaseFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
// Clamped to -6..36.
act(() => stepAgentSurfaceFontZoom("tab:tab-1", 100));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(36);
await act(() => executeAction("editor.increaseFontSize"));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(36);
act(() => stepAgentSurfaceFontZoom("tab:tab-1", -100));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(-6);
await act(() => executeAction("editor.decreaseFontSize"));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(-6);
// ⌘0 on the active pane resets tab-1.
await act(() => executeAction("editor.resetFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(leftSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("1");
});
it("isolates docked Agent chat and code editor resets from each other", async () => {
const ctx: EditorDocContext = {
doc: 1,
path: "/project/a.ts",
language: "typescript",
uiMode: null,
readOnly: false,
};
const view = new EditorView({ state: EditorState.create({ doc: "const x = 1;", extensions: [cmFontZoom] }) });
document.body.appendChild(view.dom);
const handle = { view, ctx };
_addEditor(handle);
disposers.push(() => {
_removeEditor(handle);
view.dom.remove();
});
views.push(view);
activeSlot = { view, disposed: false };
const { container } = render(
<SessionEditor docked input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />,
);
const stream = container.querySelector<HTMLElement>(`.${styles.stream}`)!;
// Zoom code editor first (+2), then zoom docked chat (+1).
view.contentDOM.focus();
await act(() => executeAction("editor.increaseFontSize"));
await act(() => executeAction("editor.increaseFontSize"));
expect(view.state.field(cmFontZoom)).toBe(2);
stream.focus();
await act(() => executeAction("editor.increaseFontSize"));
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBe(1);
expect(view.state.field(cmFontZoom)).toBe(2);
// Resetting in code editor leaves docked chat at +1.
view.contentDOM.focus();
await act(() => executeAction("editor.resetFontSize"));
expect(view.state.field(cmFontZoom)).toBe(0);
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBe(1);
// Zoom code editor again (+1); resetting in docked chat leaves code editor at +1.
await act(() => executeAction("editor.increaseFontSize"));
expect(view.state.field(cmFontZoom)).toBe(1);
stream.focus();
await act(() => executeAction("editor.resetFontSize"));
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBeUndefined();
expect(view.state.field(cmFontZoom)).toBe(1);
});
it("zooms with ⌘/Ctrl+wheel only on the hovered chat tab when editor.general.wheelZoom is enabled", () => {
const { container } = render(
<div>
<EditorTabIdProvider value="tab-1">
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorTabIdProvider>
<EditorTabIdProvider value="tab-2">
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t2"), data: { task: "t2" } }} />
</EditorTabIdProvider>
</div>,
);
const streams = container.querySelectorAll<HTMLElement>(`.${styles.stream}`);
const stream1 = streams[0]!;
const offEvent = new WheelEvent("wheel", { bubbles: true, cancelable: true, metaKey: true, deltaY: -100 });
act(() => {
stream1.dispatchEvent(offEvent);
});
expect(offEvent.defaultPrevented).toBe(false);
expect(useAgentFontZoom.getState().bySurface).toEqual({});
act(() =>
useProject.setState((s) => ({
...s,
settings: { editor: { general: { wheelZoom: true } } } as never,
})),
);
const up = new WheelEvent("wheel", { bubbles: true, cancelable: true, metaKey: true, deltaY: -100 });
act(() => {
stream1.dispatchEvent(up);
});
expect(up.defaultPrevented).toBe(true);
expect(useAgentFontZoom.getState().bySurface).toEqual({ "tab:tab-1": 1 });
const down = new WheelEvent("wheel", { bubbles: true, cancelable: true, ctrlKey: true, deltaY: 100 });
act(() => {
stream1.dispatchEvent(down);
});
expect(down.defaultPrevented).toBe(true);
expect(useAgentFontZoom.getState().bySurface).toEqual({});
const plain = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: -100 });
act(() => {
stream1.dispatchEvent(plain);
});
expect(plain.defaultPrevented).toBe(false);
});
it("sizes SVG and raster images in replies so they scale with --markdown-zoom-scale", async () => {
const svgUrl = `data:image/svg+xml;base64,${btoa('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 120"></svg>')}`;
const pngUrl = "data:image/png;base64,iVBORw0KGgo=";
imageReads.set("/project/diagram.svg", svgUrl);
imageReads.set("/project/shot.png", pngUrl);
act(() =>
useAgents.setState((s) => ({
...s,
entries: new Map([["t1", [{ type: "agent", text: "![Diagram](diagram.svg)\n\n![Shot](shot.png)" }]]]),
})),
);
const { container } = render(
<EditorShownProvider value={true}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorShownProvider>,
);
await vi.waitFor(() => {
const diag = container.querySelector<HTMLImageElement>('img[alt="Diagram"]');
expect(diag?.getAttribute("src")).toBe(svgUrl);
});
const diag = container.querySelector<HTMLImageElement>('img[alt="Diagram"]')!;
expect(diag.hasAttribute("data-natural-width")).toBe(true);
expect(diag.style.getPropertyValue("--image-width")).toBe("320px");
const shot = container.querySelector<HTMLImageElement>('img[alt="Shot"]')!;
Object.defineProperty(shot, "naturalWidth", { value: 640, configurable: true });
Object.defineProperty(shot, "naturalHeight", { value: 360, configurable: true });
act(() => {
shot.dispatchEvent(new Event("load"));
});
expect(shot.hasAttribute("data-natural-width")).toBe(true);
expect(shot.style.getPropertyValue("--image-width")).toBe("640px");
});
it("prunes bySurface entries when a tab closes or a task is removed", () => {
stepAgentSurfaceFontZoom("tab:tab-a", 4);
stepAgentSurfaceFontZoom("tab:tab-b", -2);
stepAgentSurfaceFontZoom("docked:agent:t1", 3);
stepAgentSurfaceFontZoom("agent:t1", 2);
expect(useAgentFontZoom.getState().bySurface).toEqual({
"tab:tab-a": 4,
"tab:tab-b": -2,
"docked:agent:t1": 3,
"agent:t1": 2,
});
clearAgentTabFontZoom("tab-a");
expect(useAgentFontZoom.getState().bySurface).toEqual({
"tab:tab-b": -2,
"docked:agent:t1": 3,
"agent:t1": 2,
});
clearAgentTaskFontZoom("agent:t1");
expect(useAgentFontZoom.getState().bySurface).toEqual({
"tab:tab-b": -2,
});
});
});
-95
Переглянути файл
@@ -1,95 +0,0 @@
import { useEffect, type CSSProperties, type RefObject } from "react";
import { create } from "zustand";
import { editorPrefs } from "@/platform/editorSettings";
import { useProject } from "@/platform/project";
import { registerFontZoomSurface, useEditorShown, useEditorTabId, useToolWindowShown } from "@/workbench/contributions";
const MIN_FONT_ZOOM = -6;
const MAX_FONT_ZOOM = 36;
const DEFAULT_UI_FONT_SIZE = 13;
export const useAgentFontZoom = create<{ bySurface: Record<string, number> }>(() => ({ bySurface: {} }));
export function agentSurfaceZoomKey(fallbackKey: string, docked: boolean, tabId: string | null): string {
if (docked) return `docked:${fallbackKey}`;
return tabId ? `tab:${tabId}` : fallbackKey;
}
/** Steps one Agent chat surface's font zoom by `delta` px (-6..36), or resets it when `delta === 0`. */
export function stepAgentSurfaceFontZoom(surfaceKey: string, delta: number): void {
useAgentFontZoom.setState((s) => {
const current = s.bySurface[surfaceKey] ?? 0;
const next = delta === 0 ? 0 : Math.max(MIN_FONT_ZOOM, Math.min(MAX_FONT_ZOOM, current + delta));
if (next === current) return s;
if (next === 0) {
const { [surfaceKey]: _, ...rest } = s.bySurface;
return { bySurface: rest };
}
return { bySurface: { ...s.bySurface, [surfaceKey]: next } };
});
}
export function clearAgentTabFontZoom(tabId: string): void {
stepAgentSurfaceFontZoom(`tab:${tabId}`, 0);
}
export function clearAgentTaskFontZoom(taskKey: string): void {
useAgentFontZoom.setState((s) => {
const dockedKey = `docked:${taskKey}`;
if (!(taskKey in s.bySurface) && !(dockedKey in s.bySurface)) return s;
const { [taskKey]: _a, [dockedKey]: _b, ...rest } = s.bySurface;
return { bySurface: rest };
});
}
export function resetAllAgentFontZoom(): void {
useAgentFontZoom.setState({ bySurface: {} });
}
function uiFontSizeOf(settings: unknown): number {
if (!settings || typeof settings !== "object") return DEFAULT_UI_FONT_SIZE;
const a = (settings as { appearance?: { useCustomFont?: unknown; uiFontSize?: unknown } }).appearance;
return a?.useCustomFont && typeof a.uiFontSize === "number" && a.uiFontSize > 0 ? a.uiFontSize : DEFAULT_UI_FONT_SIZE;
}
/**
* Wires per-tab keyboard font zoom (`editor.increaseFontSize` / `decreaseFontSize` / `resetFontSize`)
* and `⌘/Ctrl+wheel` (when `editor.general.wheelZoom` is on) to an Agent chat surface.
*/
export function useAgentFontZoomSurface(
ref: RefObject<HTMLElement | null>,
fallbackKey: string,
docked: boolean,
enabled = true,
): { fontZoom: number; zoomStyle: CSSProperties } {
const editorShown = useEditorShown();
const toolWindowShown = useToolWindowShown();
const tabId = useEditorTabId();
const surfaceKey = agentSurfaceZoomKey(fallbackKey, docked, tabId);
const active = enabled && (docked ? toolWindowShown : editorShown);
const fontZoom = useAgentFontZoom((s) => s.bySurface[surfaceKey] ?? 0);
const baseSize = useProject((s) => uiFontSizeOf(s.settings));
useEffect(() => {
const el = ref.current;
if (!active || !el) return;
const step = (delta: number) => stepAgentSurfaceFontZoom(surfaceKey, delta);
const onWheel = (e: WheelEvent) => {
if ((!e.ctrlKey && !e.metaKey) || e.deltaY === 0 || !editorPrefs().general.wheelZoom) return;
e.preventDefault();
e.stopPropagation();
step(e.deltaY < 0 ? 1 : -1);
};
el.addEventListener("wheel", onWheel, { capture: true, passive: false });
const release = registerFontZoomSurface(el, step, { isolated: true });
return () => {
el.removeEventListener("wheel", onWheel, { capture: true });
release();
};
}, [ref, active, surfaceKey]);
const zoomScale = Number((Math.max(4, baseSize + fontZoom) / baseSize).toFixed(4));
const zoomStyle = {
"--agent-font-zoom": `${fontZoom}px`,
"--markdown-zoom-scale": String(zoomScale),
} as CSSProperties;
return { fontZoom, zoomStyle };
}
-3
Переглянути файл
@@ -38,7 +38,6 @@ import {
import { sendPaths, sendSelection, trackEditorCopies } from "./references";
import { focusedSession } from "./sessionFocus";
import { cycleFocusedEffort } from "./effortFocus";
import { clearAgentTabFontZoom } from "./fontZoom";
import {
closeActiveTask,
closeAndNewTask,
@@ -189,7 +188,6 @@ export function activate(): () => void {
const s = useAgents.getState();
if (s.ephemeral.has(task) && s.docked !== task) void discardEphemeral(task);
},
onTabClose: (tabId) => clearAgentTabFontZoom(tabId),
// Rebuilding a long conversation on every switch back is slow.
keepAlive: true,
}),
@@ -201,7 +199,6 @@ export function activate(): () => void {
const task = useAgents.getState().tasks.get((input.data as { task: string }).task);
return task ? providerIcon(task.provider) : "toolwindow-agents";
},
onTabClose: (tabId) => clearAgentTabFontZoom(tabId),
restorable: true,
}),
// An explicit editor drop sets the placement for subsequent sessions too.
+6 -35
Переглянути файл
@@ -1,7 +1,6 @@
import { call, commands } from "@/platform/ipc";
import { ipcPath } from "@/platform/paths";
import { tx } from "@/platform/i18n";
import { applyImageZoomWidth, svgDataUrlSize } from "@/ui/svgSize";
import styles from "./Session.module.css";
const hasControl = (text: string) => [...text].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127);
@@ -40,41 +39,16 @@ export function imageTarget(source: string, cwd: string): ImageTarget | null {
}
/** What one message has loaded: streaming reuses it, later replies read a new QR at the same path and ask again. */
export type MessageImages = {
reads: Map<string, Promise<string>>;
asked: Set<string>;
onLoaded?: () => void;
};
export type MessageImages = { reads: Map<string, Promise<string>>; asked: Set<string> };
export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageImages): () => void {
const { reads, asked } = imagesState;
export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: MessageImages): () => void {
let alive = true;
const held: HTMLButtonElement[] = [];
const images = [...root.querySelectorAll<HTMLImageElement>("img")];
const bindUrl = (img: HTMLImageElement, url: string, asyncLoad: boolean) => {
const svgSize = svgDataUrlSize(url);
if (svgSize && applyImageZoomWidth(img, svgSize) && asyncLoad) imagesState.onLoaded?.();
img.onload = () => {
if (!alive) return;
if (!img.hasAttribute("data-natural-width") && img.naturalWidth > 0 && img.naturalHeight > 0) {
if (applyImageZoomWidth(img, { w: img.naturalWidth, h: img.naturalHeight }) && asyncLoad) {
imagesState.onLoaded?.();
}
} else if (asyncLoad) {
imagesState.onLoaded?.();
}
};
img.src = url;
if (!img.hasAttribute("data-natural-width") && img.complete && img.naturalWidth > 0 && img.naturalHeight > 0) {
applyImageZoomWidth(img, { w: img.naturalWidth, h: img.naturalHeight });
}
};
for (const img of images) {
applyImageZoomWidth(img);
const source = img.dataset.imageSrc ?? "";
const fail = () => {
if (!alive) return;
img.onload = null;
img.onerror = null;
img.removeAttribute("src");
img.alt = tx`Unable to load image: ${source}`;
@@ -88,7 +62,7 @@ export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageI
const { url } = target;
if (/^data:/i.test(url) || asked.has(url)) {
img.hidden = false;
bindUrl(img, url, false);
img.src = url;
} else {
// A reply can be steered into naming an address that carries data out: the user decides.
// That holds for this machine too, where a server may pass the request on.
@@ -101,7 +75,7 @@ export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageI
asked.add(url);
load.remove();
img.hidden = false;
bindUrl(img, url, true);
img.src = url;
};
img.hidden = true;
img.before(load);
@@ -115,16 +89,13 @@ export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageI
void pending.catch(() => reads.delete(target.path));
}
void pending.then((url) => {
if (alive) bindUrl(img, url, true);
if (alive) img.src = url;
}, fail);
}
}
return () => {
alive = false;
for (const img of images) {
img.onload = null;
img.onerror = null;
}
for (const img of images) img.onerror = null;
for (const load of held) load.remove();
};
}
-4
Переглянути файл
@@ -20,7 +20,6 @@ import type {
Isolation,
} from "@/bindings";
import { useChangesOptions } from "./changesOptions";
import { clearAgentTaskFontZoom, resetAllAgentFontZoom } from "./fontZoom";
import { basename, useProject } from "@/platform/project";
import { defaultTaskProject } from "./project";
import { call, commands, isTauri } from "@/platform/ipc";
@@ -519,7 +518,6 @@ export function disconnect() {
arrivedWhileLoading.clear();
streamingReply.clear();
modelFlights.clear();
resetAllAgentFontZoom();
useAgents.setState({
loaded: false,
error: null,
@@ -578,7 +576,6 @@ function onEvent(e: AgentEvent) {
organize,
...(s.docked === e.id ? { docked: null } : {}),
});
clearAgentTaskFontZoom(sessionKey(e.id));
void editorService().closeInput?.(sessionKey(e.id));
break;
}
@@ -1277,7 +1274,6 @@ export async function discardEphemeral(task: string): Promise<void> {
lastComposer: state.lastComposer === task ? HOME : state.lastComposer,
};
});
clearAgentTaskFontZoom(sessionKey(task));
void editorService().closeInput?.(sessionKey(task));
}
-81
Переглянути файл
@@ -1,81 +0,0 @@
import { afterEach, describe, expect, it } from "vitest";
import { clearMocks, mockIPC } from "@tauri-apps/api/mocks";
import type { SymbolKind, SymbolMatch } from "@/platform/ipc";
import { symbolRef } from "./conversation";
import { inTaskFolder, lookupSymbols, symbolTargets } from "./symbolLinks";
const symbol = (
name: string,
path: string,
kind: SymbolKind = "class",
container: string | null = null,
): SymbolMatch => ({
name,
kind,
container,
path,
relPath: path.replace(/^\/repo\//, ""),
range: { start: { line: 3, col: 6 }, end: { line: 3, col: 6 + name.length } },
score: 0,
indices: [],
});
afterEach(clearMocks);
describe("symbolTargets", () => {
const views = [symbol("FooView", "/repo/web/view.ts"), symbol("FooView", "/repo/app/view.ts")];
it("keeps only exact matches of the named kind, container and file", () => {
const found = [
symbol("load", "/repo/a.ts", "method", "Config"),
symbol("load", "/repo/b.ts", "method", "Loader"),
symbol("load", "/repo/c.ts", "variable"),
];
expect(symbolTargets(symbolRef("Config.load")!, found, [], "/repo").map((found) => found.path)).toEqual([
"/repo/a.ts",
]);
expect(symbolTargets(symbolRef("b.ts#load")!, found, [], "/repo").map((found) => found.path)).toEqual([
"/repo/b.ts",
]);
expect(symbolTargets(symbolRef("load()")!, found, [], "/repo").map((found) => found.path)).toEqual([
"/repo/a.ts",
"/repo/b.ts",
]);
expect(symbolTargets(symbolRef("FooView")!, [symbol("FooView", "/repo/x.ts", "variable")], [], "/repo")).toEqual(
[],
);
});
it("prefers a file the reply names, then the task's folder", () => {
const ref = symbolRef("FooView")!;
expect(symbolTargets(ref, views, ["/app/view.ts"], "/repo/web").map((found) => found.path)).toEqual([
"/repo/app/view.ts",
]);
expect(symbolTargets(ref, views, [], "/repo/web").map((found) => found.path)).toEqual(["/repo/web/view.ts"]);
expect(symbolTargets(ref, views, ["/other.ts"], "/repo")).toHaveLength(2);
});
it("puts a worktree task's targets under its own folder", () => {
const [view] = views;
expect(inTaskFolder(view!, "/repo", "/repo/web").path).toBe("/repo/web/view.ts");
expect(inTaskFolder(view!, "/repo", "/worktrees/fix").path).toBe("/worktrees/fix/web/view.ts");
});
});
describe("lookupSymbols", () => {
it("asks the index once per name and folder, in one request", async () => {
const asked: string[][] = [];
mockIPC((cmd, args) => {
if (cmd !== "find_symbols_named") return null;
const { names } = args as { names: string[] };
asked.push(names);
return names.map((name) => symbol(name, `/repo/${name}.ts`));
});
const first = lookupSymbols("/batch", ["FooView", "load", "FooView"]);
expect((await first.get("load"))!.map((found) => found.path)).toEqual(["/repo/load.ts"]);
const second = lookupSymbols("/batch", ["load", "BarView"]);
expect((await second.get("BarView"))!.map((found) => found.name)).toEqual(["BarView"]);
await lookupSymbols("/elsewhere", ["load"]).get("load");
expect(asked).toEqual([["FooView", "load"], ["BarView"], ["load"]]);
});
});
-73
Переглянути файл
@@ -1,73 +0,0 @@
/**
* Symbol links in agent replies: the names a reply shows are looked up in the symbol index
* in one batch, and each name only once per task folder.
*/
import { call, commands, type SymbolMatch } from "@/platform/ipc";
import type { SymbolRef } from "./conversation";
/** Index answers by the folder they were asked in, then by name. */
const answers = new Map<string, Map<string, Promise<SymbolMatch[]>>>();
const NAMES_PER_FOLDER = 2000;
/** The index's symbols named exactly each of `names` inside `within`; one request for the names not asked before. */
export function lookupSymbols(within: string, names: Iterable<string>): Map<string, Promise<SymbolMatch[]>> {
const known = answers.get(within) ?? new Map<string, Promise<SymbolMatch[]>>();
answers.set(within, known);
const wanted = new Set(names);
const missing = [...wanted].filter((name) => !known.has(name));
if (missing.length) {
const found = call(commands.findSymbolsNamed(missing, within)).catch(() => []);
for (const name of missing) {
if (known.size >= NAMES_PER_FOLDER) known.delete(known.keys().next().value!);
known.set(
name,
found.then((symbols) => symbols.filter((symbol) => symbol.name === name)),
);
}
}
return new Map([...wanted].map((name) => [name, known.get(name)!]));
}
/** Narrows `symbols` by each preference in turn, skipping one that would leave nothing. */
function preferred(symbols: SymbolMatch[], ...preferences: Array<(symbol: SymbolMatch) => boolean>): SymbolMatch[] {
return preferences.reduce((pool, prefers) => {
const narrowed = pool.filter(prefers);
return narrowed.length ? narrowed : pool;
}, symbols);
}
const trimSlash = (path: string) => path.replace(/\/$/, "");
const under = (folder: string, path: string) => path.startsWith(`${trimSlash(folder)}/`);
/**
* The definitions `ref` names among `symbols` (same name, kind, container and file), the
* ones in a file the reply names first, then the ones in the task's folder `cwd`.
*/
export function symbolTargets(
ref: SymbolRef,
symbols: readonly SymbolMatch[],
mentioned: readonly string[],
cwd: string,
): SymbolMatch[] {
const exact = symbols.filter(
(symbol) =>
symbol.name === ref.name &&
ref.kinds.includes(symbol.kind) &&
(!ref.container || symbol.container?.split(/\.|::/).pop() === ref.container) &&
(!ref.file || symbol.path.endsWith(`/${ref.file}`)),
);
return preferred(
exact,
(symbol) => mentioned.some((path) => symbol.path.endsWith(`/${path.replace(/^\.?\//, "")}`)),
(symbol) => under(cwd, symbol.path),
);
}
/**
* `symbol` as the task sees it: a task in a worktree outside the indexed project root has
* the same file under its own folder.
*/
export function inTaskFolder(symbol: SymbolMatch, projectRoot: string, cwd: string): SymbolMatch {
if (trimSlash(cwd) === trimSlash(projectRoot) || under(projectRoot, cwd)) return symbol;
return { ...symbol, path: `${trimSlash(cwd)}/${symbol.relPath}` };
}
+14 -41
Переглянути файл
@@ -9,7 +9,6 @@ import {
Spinner,
SymbolBadge,
Tabs,
showContextMenu,
Tree,
badgeKind,
type TreeHandle,
@@ -18,11 +17,8 @@ import {
} from "@/ui";
import { openLocation } from "./ipc";
import {
closeHierarchyTab,
pinHierarchyTab,
closeHierarchy,
ROOT_ID,
selectHierarchyTab,
tabHierarchy,
directionLabel,
hierarchyTitle,
hierarchyTarget,
@@ -58,44 +54,22 @@ useHierarchyOptions.subscribe((s) => {
}
});
/** Tool window header: the `Callers of foo` content tabs. */
/** Tool window header: `Callers of foo` content tab. */
export function HierarchyTabs() {
const state = useHierarchy();
const tabs = state.tabs.flatMap((tab) => {
const h = tabHierarchy(state, tab);
return h.root ? [{ tab, label: hierarchyTitle(h.mode, h.direction, h.root.name) }] : [];
});
if (!tabs.length || state.active === null) return null;
const mode = useHierarchy((s) => s.mode);
const direction = useHierarchy((s) => s.direction);
const root = useHierarchy((s) => s.root);
if (!root) return null;
const label = hierarchyTitle(mode, direction, root.name);
return (
<Tabs
variant="compact"
className={styles.tabs}
aria-label="Hierarchies"
items={tabs.map(({ tab, label }) => ({ id: String(tab.id), label, closable: true, pinned: tab.pinned }))}
activeId={String(state.active)}
onSelect={(id) => selectHierarchyTab(Number(id))}
onClose={(id) => closeHierarchyTab(Number(id))}
onTogglePin={(id) => {
const tab = tabs.find((t) => t.tab.id === Number(id))?.tab;
if (tab) pinHierarchyTab(tab.id, !tab.pinned);
}}
onContextMenu={(id, e) => {
const tab = tabs.find((t) => t.tab.id === Number(id))?.tab;
if (!tab) return;
// IDEA's content tab menu.
showContextMenu(e, [
{ id: "close", label: "Close Tab", run: () => closeHierarchyTab(tab.id) },
{ id: "closeAll", label: "Close All Tabs", run: () => tabs.forEach((t) => closeHierarchyTab(t.tab.id)) },
{
id: "closeOthers",
label: "Close Other Tabs",
disabled: tabs.length < 2,
run: () => tabs.forEach((t) => t.tab.id !== tab.id && closeHierarchyTab(t.tab.id)),
},
{ kind: "separator" },
{ id: "pin", label: tab.pinned ? "Unpin Tab" : "Pin Tab", run: () => pinHierarchyTab(tab.id, !tab.pinned) },
]);
}}
items={[{ id: "current", label, closable: true }]}
activeId="current"
onSelect={() => undefined}
onClose={closeHierarchy}
/>
);
}
@@ -140,7 +114,7 @@ function HierarchyToolbar() {
}
export function HierarchyView() {
const { mode, direction, root, children, failed, notes, loading, expanded, generation } = useHierarchy();
const { mode, direction, root, children, failed, notes, loading, generation } = useHierarchy();
const projectRoot = useProject((s) => s.project?.root ?? "");
const roots = useMemo<Node[]>(() => (root ? [{ kind: "root", id: ROOT_ID }] : []), [root]);
@@ -250,12 +224,11 @@ export function HierarchyView() {
getChildren={getChildren}
isExpandable={isExpandable}
loadChildren={(n) => (n.kind === "item" ? loadChildren(n.node) : undefined)}
onExpandedChange={(opened, n, open) => {
useHierarchy.setState({ expanded: [...opened] });
onExpandedChange={(_expanded, n, open) => {
const shown = open ? children.get(n.id) : undefined;
if (shown) prefetchLevels(shown);
}}
defaultExpanded={expanded}
defaultExpanded={[ROOT_ID]}
handleRef={tree}
isOccurrence={() => true}
onSelectionChange={(_sel, n) => {
-42
Переглянути файл
@@ -306,45 +306,3 @@ describe("closing the hierarchy tab", () => {
expect(hide).toHaveBeenCalledWith("hierarchy", { removeFromStripe: true });
});
});
describe("hierarchy tabs", () => {
it("replace the selected tab unless it is pinned, and keep each tab's tree", async () => {
const { closeHierarchyTab, pinHierarchyTab, selectHierarchyTab, tabHierarchy } = await import("./hierarchy");
const names = () => {
const s = useHierarchy.getState();
return s.tabs.map((t) => `${tabHierarchy(s, t).mode}:${t.pinned ? "pinned" : ""}`);
};
resetHierarchy();
await showHierarchy("call");
await showHierarchy("type");
expect(names()).toEqual(["type:"]);
const first = useHierarchy.getState().active!;
pinHierarchyTab(first, true);
await showHierarchy("call");
expect(names()).toEqual(["type:pinned", "call:"]);
const second = useHierarchy.getState().active!;
expect(
useHierarchy
.getState()
.children.get(ROOT_ID)
?.map((n) => n.item.name),
).toEqual(["main"]);
selectHierarchyTab(first);
expect(useHierarchy.getState().mode).toBe("type");
selectHierarchyTab(second);
expect(useHierarchy.getState().mode).toBe("call");
expect(
useHierarchy
.getState()
.children.get(ROOT_ID)
?.map((n) => n.item.name),
).toEqual(["main"]);
closeHierarchyTab(second);
expect(useHierarchy.getState()).toMatchObject({ active: first, mode: "type" });
expect(names()).toEqual(["type:pinned"]);
closeHierarchyTab(first);
expect(useHierarchy.getState()).toMatchObject({ root: null, tabs: [], active: null });
});
});
+1 -111
Переглянути файл
@@ -54,27 +54,8 @@ interface HierarchyState {
/** Parent id → why its children may be missing callers. */
notes: ReadonlyMap<string, string>;
loading: boolean;
/** Ids of the expanded nodes, so a tab shown again keeps its tree open. */
expanded: readonly string[];
/** Bumped per (re)query so stale responses are dropped and the tree resets. */
generation: number;
/** Content tabs; the selected one's hierarchy is the state above. */
tabs: readonly HierarchyTab[];
active: number | null;
}
/** The hierarchy of a tab that isn't selected. */
export type SavedHierarchy = Pick<
HierarchyState,
"mode" | "direction" | "root" | "children" | "failed" | "notes" | "loading" | "expanded"
>;
export interface HierarchyTab {
id: number;
/** Pinned: a new hierarchy opens beside it instead of taking its place. */
pinned: boolean;
/** Null for the selected tab. */
saved: SavedHierarchy | null;
}
export const ROOT_ID = "root";
@@ -87,89 +68,9 @@ export const useHierarchy = create<HierarchyState>(() => ({
failed: new Set(),
notes: new Map(),
loading: false,
expanded: [ROOT_ID],
generation: 0,
tabs: [],
active: null,
}));
let tabSeq = 0;
function saved(s: HierarchyState): SavedHierarchy {
const { mode, direction, root, children, failed, notes, loading, expanded } = s;
return { mode, direction, root, children, failed, notes, loading, expanded };
}
/** A tab's mode, direction and root: the live state's for the selected one. */
export function tabHierarchy(s: HierarchyState, tab: HierarchyTab): SavedHierarchy {
return tab.saved ?? saved(s);
}
/**
* As IDEA: a new hierarchy takes the place of the selected tab unless it is pinned,
* then it opens in a tab of its own.
*/
function openTab() {
const s = useHierarchy.getState();
const current = s.tabs.find((t) => t.id === s.active);
if (current && !current.pinned) return;
cancelInflight();
const id = ++tabSeq;
useHierarchy.setState({
tabs: [
...s.tabs.map((t) => (t.id === s.active ? { ...t, saved: saved(s) } : t)),
{ id, pinned: false, saved: null },
],
active: id,
root: null,
children: new Map(),
failed: new Set(),
notes: new Map(),
loading: false,
expanded: [ROOT_ID],
generation: s.generation + 1,
});
}
export function selectHierarchyTab(id: number) {
const s = useHierarchy.getState();
const target = s.tabs.find((t) => t.id === id);
if (id === s.active || !target?.saved) return;
cancelInflight();
const next = target.saved;
useHierarchy.setState({
...next,
loading: false,
generation: s.generation + 1,
active: id,
tabs: s.tabs.map((t) => (t.id === s.active ? { ...t, saved: saved(s) } : t.id === id ? { ...t, saved: null } : t)),
});
// Its requests were dropped when it was left: load it again.
if (next.loading) void loadRoot();
}
/** Closes a tab; the tool window goes with the last one. */
export function closeHierarchyTab(id: number) {
const s = useHierarchy.getState();
const at = s.tabs.findIndex((t) => t.id === id);
if (at < 0) return;
const rest = s.tabs.filter((t) => t.id !== id);
if (!rest.length) {
closeHierarchy();
return;
}
if (id !== s.active) {
useHierarchy.setState({ tabs: rest });
return;
}
useHierarchy.setState({ tabs: rest, active: null });
selectHierarchyTab((s.tabs[at + 1] ?? s.tabs[at - 1])!.id);
}
export function pinHierarchyTab(id: number, pinned: boolean) {
useHierarchy.setState((s) => ({ tabs: s.tabs.map((t) => (t.id === id ? { ...t, pinned } : t)) }));
}
/** Call hierarchy requests the current tree still waits for. */
const inflight = new Set<RequestId>();
@@ -187,10 +88,7 @@ export function resetHierarchy() {
failed: new Set(),
notes: new Map(),
loading: false,
expanded: [ROOT_ID],
generation: s.generation + 1,
tabs: [],
active: null,
}));
}
@@ -350,14 +248,7 @@ async function loadRoot(quiet = false): Promise<RootResult> {
if (!root) return "stale";
const generation = s.generation + 1;
cancelInflight();
useHierarchy.setState({
generation,
children: new Map(),
failed: new Set(),
notes: new Map(),
loading: true,
expanded: [ROOT_ID],
});
useHierarchy.setState({ generation, children: new Map(), failed: new Set(), notes: new Map(), loading: true });
try {
const { items, incomplete } = await withDocument(root.path, (doc) =>
request(s.mode, doc, root.path, root.line, root.col, s.direction),
@@ -474,7 +365,6 @@ export async function showHierarchy(mode: HierarchyMode) {
hint("Open a file to show the hierarchy");
return;
}
openTab();
const s = useHierarchy.getState();
const direction = s.mode === mode ? s.direction : mode === "call" ? "incoming" : "outgoing";
useHierarchy.setState({
-1
Переглянути файл
@@ -191,7 +191,6 @@ function providePluginEndpoints(pluginId: string): () => void {
export function defineBuiltinUiPoints(): () => void {
const disposers = [
defineUiPoint("mcpTools", {}),
defineUiPoint("serverCommands", {}),
defineUiPoint("endpoints", { project: ({ pluginId }) => providePluginEndpoints(pluginId) }),
defineUiPoint<CommandDecl>("commands", {
title: "Commands",
-11
Переглянути файл
@@ -69,14 +69,3 @@ it("keeps an agent's commands out of other tabs", async () => {
await startRun(agent, undefined, undefined, { prepared: true });
expect(useRun.getState().sessions).toHaveLength(2);
});
it("gives runs started together their own tabs", async () => {
useRun.setState({ sessions: [finished("a"), finished("b")], activeSession: "a" });
await Promise.all([
startRun(config("x"), "a", undefined, { prepared: true }),
startRun(config("y"), undefined, undefined, { prepared: true }),
startRun(config("z"), undefined, undefined, { prepared: true }),
]);
expect(tabs()).toEqual(["a:x", "b:y", expect.stringMatching(/^run\d+:z$/)]);
expect(ipc.runStart).toHaveBeenCalledTimes(3);
});
+17 -41
Переглянути файл
@@ -760,58 +760,38 @@ export function sessionsOf(config: RunConfig, sessions = useRun.getState().sessi
* Agents' commands keep to their own tabs.
*/
function reusableTab(sessions: readonly RunSession[], active: string | null, config: RunConfig) {
const free = sessions.filter((s) => !isLive(s) && !s.pinned && !claimedTabs.has(s.id));
const free = sessions.filter((s) => !isLive(s) && !s.pinned);
const same = free.find((s) => s.config.id === config.id);
if (same || agentName(config) !== null) return same;
const others = free.filter((s) => agentName(s.config) === null);
return others.find((s) => s.id === active) ?? others[0];
}
/** Tabs a starting run is about to take: runs started together (compounds, reruns of several packages) must not take the same one. */
const claimedTabs = new Set<string>();
/** Pins or unpins a session's tab. */
export function pinSession(id: string, pinned: boolean) {
patchSession(id, { pinned });
}
interface StartRunOptions {
show?: boolean;
/** Launch this instead of `config` (e.g. with a debug agent); the tab still shows `config`. Skips before launch tasks. */
launch?: RunConfig;
/** Every output line of this run. */
onLine?: (text: string) => void;
/** The process exited. */
onExit?: (exitCode: number | null, stopped: boolean) => void;
/** Before launch tasks already ran (or must not run). */
prepared?: boolean;
/** Configurations whose launch led to this one (before launch tasks, compounds): breaks cycles. */
chain?: readonly string[];
/** Runs before the stop signal when the user stops this run (run executors). */
beforeStop?: (runId: RunId) => Promise<void>;
}
/** Starts `config`, reusing the tab of a finished (or the given) session (see `reusableTab`). */
export async function startRun(
config: RunConfig,
reuse?: string,
baseConfig?: RunConfig,
options: StartRunOptions = {},
): Promise<RunSession | null> {
if (!reuse || claimedTabs.has(reuse)) return startRunIn(config, reuse, baseConfig, options);
claimedTabs.add(reuse);
try {
return await startRunIn(config, reuse, baseConfig, options);
} finally {
claimedTabs.delete(reuse);
}
}
async function startRunIn(
config: RunConfig,
reuse: string | undefined,
baseConfig: RunConfig | undefined,
options: StartRunOptions,
options: {
show?: boolean;
/** Launch this instead of `config` (e.g. with a debug agent); the tab still shows `config`. Skips before launch tasks. */
launch?: RunConfig;
/** Every output line of this run. */
onLine?: (text: string) => void;
/** The process exited. */
onExit?: (exitCode: number | null, stopped: boolean) => void;
/** Before launch tasks already ran (or must not run). */
prepared?: boolean;
/** Configurations whose launch led to this one (before launch tasks, compounds): breaks cycles. */
chain?: readonly string[];
/** Runs before the stop signal when the user stops this run (run executors). */
beforeStop?: (runId: RunId) => Promise<void>;
} = {},
): Promise<RunSession | null> {
config = withRunTarget(config);
if (!options.launch && isCMakeBuild(config)) {
@@ -861,16 +841,12 @@ async function startRunIn(
// IDEA there is no time limit: a first Stop waits for the shutdown, a second one kills it.
await waitForExit(stopping, null);
const now = useRun.getState();
const picked = session ? undefined : reusableTab(now.sessions, now.activeSession, config);
session ??= picked;
session ??= reusableTab(now.sessions, now.activeSession, config);
if (picked) claimedTabs.add(picked.id);
try {
await maybeEditorService()?.saveAll();
} catch {
/* saving is best effort */
} finally {
if (picked) claimedTabs.delete(picked.id);
}
const startedAt = Date.now();
+1 -13
Переглянути файл
@@ -115,19 +115,7 @@ const GENERAL = editorPage({
{
title: "Mouse Control",
items: [
{
t: "check",
key: `${P}.general.wheelZoom`,
label: "Change font size with Ctrl/Command+Mouse Wheel",
inline: {
kind: "select",
key: `${P}.general.wheelZoomScope`,
options: [
{ value: "active", label: "Active editor" },
{ value: "all", label: "All editors" },
],
},
},
{ t: "check", key: `${P}.general.wheelZoom`, label: "Change font size with Ctrl/Command+Mouse Wheel" },
{ t: "check", key: `${P}.general.dragAndDrop`, label: "Enable drag-and-drop functionality in editor" },
],
},
-6
Переглянути файл
@@ -504,12 +504,6 @@ export const VCS_PAGES: PageSpec[] = [
{
title: "Commit",
options: [
{
kind: "toggle",
key: "vcs.git.stagingArea",
label: "Enable staging area",
hint: "Commit works on the Git index: stage and unstage changes instead of checking them. Change lists are not used. Only for the non-modal commit interface.",
},
{ kind: "toggle", key: "vcs.git.warnCrlf", label: "Warn if CRLF line separators are about to be committed" },
{
kind: "toggle",
-83
Переглянути файл
@@ -1,83 +0,0 @@
.root {
flex: 1;
height: 100%;
min-height: 0;
display: flex;
flex-direction: column;
background: var(--bg-app);
}
.toolbar {
flex: none;
height: var(--h-header);
display: flex;
align-items: center;
gap: var(--space-0-5);
padding: 0 6px;
border-bottom: 1px solid var(--border);
}
.toolbar > * {
flex-shrink: 0;
}
.sep {
width: 1px;
height: 14px;
margin: 0 4px;
background: var(--border-strong);
}
.count {
padding: 0 6px;
color: var(--fg-subtle);
font-size: var(--fs-small);
white-space: nowrap;
}
.grow {
flex: 1;
}
.scroll {
flex: 1;
min-height: 0;
overflow-y: auto;
}
.block {
border-bottom: 1px solid var(--border);
}
/* The file's header stays at the top while its diff scrolls by. */
.header {
position: sticky;
top: 0;
z-index: 3;
display: flex;
align-items: center;
gap: var(--space-1);
height: var(--h-header);
padding: 0 6px;
background: var(--bg-elev);
border-bottom: 1px solid var(--border);
}
.name {
flex: none;
font-weight: 500;
white-space: nowrap;
}
.dir {
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
color: var(--fg-subtle);
font-size: var(--fs-small);
}
.body {
display: flex;
flex-direction: column;
}
/* Space a block takes before its diff loads, so the scrollbar is roughly right. */
.placeholder {
height: 160px;
}
.empty {
display: flex;
align-items: center;
justify-content: center;
color: var(--fg-subtle);
}
-219
Переглянути файл
@@ -1,219 +0,0 @@
/**
* The all-in-one diff tab (`combined-diff`): one block per file of a change, each a diff
* as tall as its content under a sticky header, in one scrolling view. Blocks load as they
* come near the viewport; a header collapses its block or opens the file's own diff tab.
*/
import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
import clsx from "clsx";
import { tx } from "@/platform/i18n";
import { relativeDir, useProject } from "@/platform/project";
import { Icon, IconButton, T, fileIconName } from "@/ui";
import { editorService, type EditorInput } from "@/workbench/contributions";
import { setAllInOneDiff, type CombinedDiffData } from "./allInOneDiff";
import { DiffEditor } from "./DiffEditor";
import { diffInput, openDiff, withChain, type DiffData } from "./diffInput";
import { loadDiffOptions, saveDiffOptions } from "./diffOptions";
import { KIND_COLOR, KIND_LABEL, baseName, fileCount } from "./model";
import styles from "./CombinedDiff.module.css";
type Kind = "added" | "deleted" | "modified";
/** What happened to the file: one side absent means added or deleted. */
export function blockKind(item: DiffData): Kind {
const absent = (s: DiffData["left"]) => s.type === "text" && !!s.absent;
return absent(item.left) ? "added" : absent(item.right) ? "deleted" : "modified";
}
/** How far below the viewport a block starts loading (above it, only once scrolled to). */
const PRELOAD = "0px 0px 800px 0px";
function Block({
item,
index,
items,
collapsed,
onToggle,
mode,
}: {
item: DiffData;
index: number;
items: readonly DiffData[];
collapsed: boolean;
onToggle: () => void;
mode: "split" | "unified";
}) {
const ref = useRef<HTMLElement>(null);
// Without IntersectionObserver (tests), every block loads at once.
const [near, setNear] = useState(() => typeof IntersectionObserver === "undefined");
useEffect(() => {
const el = ref.current;
if (!el || near) return;
const io = new IntersectionObserver(
(entries) => {
if (entries.some((e) => e.isIntersecting)) setNear(true);
},
{ root: el.closest("[data-combined-scroll]"), rootMargin: PRELOAD },
);
io.observe(el);
return () => io.disconnect();
}, [near]);
const input: EditorInput = useMemo(() => diffInput({ ...item, mode }), [item, mode]);
const kind = blockKind(item);
const name = baseName(item.path);
const root = useProject((s) => s.project?.root ?? "");
const dir = relativeDir(root, item.path);
return (
<section ref={ref} className={styles.block} data-combined-block={item.path} aria-label={name}>
<div className={styles.header}>
<IconButton
icon={collapsed ? "chevron-right" : "chevron-down"}
title={collapsed ? "Expand File" : "Collapse File"}
size="small"
aria-expanded={!collapsed}
onClick={onToggle}
/>
<Icon name={fileIconName(name)} size={16} />
<span className={styles.name} style={{ color: KIND_COLOR[kind] }} title={tx(KIND_LABEL[kind])}>
{name}
</span>
{dir && (
<span className={styles.dir} title={item.path}>
{dir}
</span>
)}
<span className={styles.grow} />
<IconButton
icon="diff"
title="Open in Separate Tab"
size="small"
// The file's own diff, still knowing its siblings for Compare Next File.
onClick={() => void editorService().openInput(diffInput(withChain(items, index)), { focus: true })}
/>
{item.right.type === "worktree" && (
<IconButton
icon="edit"
title="Jump to Source"
size="small"
onClick={() => void editorService().openFile(item.path, { focus: true })}
/>
)}
</div>
{!collapsed &&
(near ? (
<div className={styles.body}>
<DiffEditor input={input} fit />
</div>
) : (
<div className={styles.placeholder} />
))}
</section>
);
}
export function CombinedDiffTab({ input }: { input: EditorInput }) {
const data = input.data as CombinedDiffData;
const items = data.items;
const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(() => new Set());
const [mode, setMode] = useState(() => loadDiffOptions().mode);
const scrollRef = useRef<HTMLDivElement>(null);
const blocks = () => [...(scrollRef.current?.querySelectorAll<HTMLElement>("[data-combined-block]") ?? [])];
/** The block at the top of the view. */
const current = () => {
const top = scrollRef.current?.getBoundingClientRect().top ?? 0;
const all = blocks();
const at = all.findIndex((b) => b.getBoundingClientRect().bottom > top + 1);
return at < 0 ? all.length - 1 : at;
};
const scrollTo = (path: string) => {
const el = blocks().find((b) => b.dataset.combinedBlock === path);
const scroller = scrollRef.current;
if (el && scroller) scroller.scrollTop += el.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
};
const step = (dir: 1 | -1) => {
const next = items[current() + dir];
if (next) scrollTo(next.path);
};
// Open at the file the diff was asked for.
useLayoutEffect(() => {
if (data.reveal) scrollTo(data.reveal);
// Once per tab: later revisits keep their scroll position.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
const setViewer = (next: "split" | "unified") => {
setMode(next);
saveDiffOptions({ ...loadDiffOptions(), mode: next });
};
const toggle = (path: string) =>
setCollapsed((c) => {
const s = new Set(c);
if (s.has(path)) s.delete(path);
else s.add(path);
return s;
});
const allCollapsed = items.length > 0 && items.every((i) => collapsed.has(i.path));
return (
<div className={styles.root}>
<div className={styles.toolbar} role="toolbar" aria-label={tx("Combined Changes Diff")}>
<IconButton icon="arrow-up" title="Previous File" size="small" onClick={() => step(-1)} />
<IconButton icon="arrow-down" title="Next File" size="small" onClick={() => step(1)} />
<IconButton
icon={allCollapsed ? "expand-all" : "collapse-all"}
title={allCollapsed ? "Expand All Files" : "Collapse All Files"}
size="small"
onClick={() => setCollapsed(allCollapsed ? new Set() : new Set(items.map((i) => i.path)))}
/>
<span className={styles.sep} />
<IconButton
icon="diff-side-by-side"
title="Side-by-side Viewer"
size="small"
pressed={mode === "split"}
onClick={() => setViewer("split")}
/>
<IconButton
icon="diff-unified"
title="Unified Viewer"
size="small"
pressed={mode === "unified"}
onClick={() => setViewer("unified")}
/>
<span className={styles.count}>{fileCount(items.length)}</span>
<span className={styles.grow} />
<IconButton
icon="editor-only"
title="Show Files in Separate Diff Tabs"
size="small"
onClick={() => {
// Back to one diff per file, at the file in view.
setAllInOneDiff(false);
const at = Math.max(0, current());
void openDiff(withChain(items, at)).then(() => editorService().closeInput?.(input.key));
}}
/>
</div>
<div ref={scrollRef} className={styles.scroll} data-combined-scroll>
{items.length ? (
items.map((item, index) => (
<Block
key={`${item.path}:${mode}`}
item={item}
index={index}
items={items}
collapsed={collapsed.has(item.path)}
onToggle={() => toggle(item.path)}
mode={mode}
/>
))
) : (
<div className={clsx(styles.placeholder, styles.empty)}>
<T>No changes</T>
</div>
)}
</div>
</div>
);
}
-10
Переглянути файл
@@ -344,13 +344,3 @@
.checkProblemLink:hover {
text-decoration: underline;
}
/* Staging area: Stage / Unstage on the hovered or selected row, as a hover icon at the row's end. */
.stageButton {
flex: none;
margin-left: auto;
visibility: hidden;
}
[role="treeitem"]:hover .stageButton,
[role="treeitem"][aria-selected="true"] .stageButton {
visibility: visible;
}
+11 -60
Переглянути файл
@@ -61,7 +61,6 @@ import {
import { applyStash, commitChanges, deleteFiles, dropStash, showUnstashDialog, stashChanges } from "./changeOps";
import { CommitOptionsPopup } from "./CommitOptions";
import { DEFAULT_LIST_NAME, useChangelists, withListDefaults } from "./changelists";
import { inclusionChecks, isCommitAll, useStagingArea } from "./staging";
import { addToChangelist, commitFiles } from "./changelistsUi";
import { acceptSide } from "./conflictsUi";
import { copyChangesAsPatch } from "./patches";
@@ -398,14 +397,13 @@ export function nodeMenu(
{
label: "Stage",
icon: "plus",
// Under Staged Changes, a partially staged file only offers Unstage.
disabled: !files.some((f) => f.unstaged) || nodes.every((n) => n.group === "staged"),
disabled: !files.some((f) => f.unstaged),
run: () => void runOp(tx`Stage ${paths.length} files`, () => call(commands.vcsStage(paths))),
},
{
label: "Unstage",
icon: "minus",
disabled: !files.some((f) => f.staged) || nodes.every((n) => n.group === "unstaged" || n.group === "unversioned"),
disabled: !files.some((f) => f.staged),
run: () => void runOp(tx`Unstage ${paths.length} files`, () => call(commands.vcsUnstage(paths))),
},
{ kind: "separator" },
@@ -432,41 +430,6 @@ export function nodeMenu(
return items;
}
/**
* The staging operation of a node of the staging area's tree: Unstage under Staged, Stage
* under Unstaged and Unversioned Files, applied to every file below the node.
*/
export function stageOperation(n: ChangeNode): { label: string; icon: "plus" | "minus"; paths: string[] } | null {
const paths = n.files.map((f) => stripSlash(f.path));
if (!paths.length) return null;
if (n.group === "staged") return { label: "Unstage", icon: "minus", paths };
if (n.group === "unstaged" || n.group === "unversioned") return { label: "Stage", icon: "plus", paths };
return null;
}
function StageButton({ node }: { node: ChangeNode }) {
const op = stageOperation(node);
if (!op) return null;
const { label, icon, paths } = op;
const count = paths.length;
return (
<IconButton
icon={icon}
title={label}
size="small"
className={styles.stageButton}
onMouseDown={(e) => e.stopPropagation()}
onDoubleClick={(e) => e.stopPropagation()}
onClick={(e) => {
e.stopPropagation();
void runOp(icon === "plus" ? tx`Stage ${count} files` : tx`Unstage ${count} files`, () =>
call(icon === "plus" ? commands.vcsStage(paths) : commands.vcsUnstage(paths)),
).then(() => refreshNow());
}}
/>
);
}
function CheckMark({
checked,
indeterminate,
@@ -503,11 +466,7 @@ function useCommitChecks() {
const root = useVcs((s) => s.root) ?? "";
const userChecks = useCommit((s) => s.checks);
const lists = useChangelists((s) => s.state);
const staging = useStagingArea();
return useMemo(
() => inclusionChecks(status, root, lists, userChecks, staging),
[status, root, lists, userChecks, staging],
);
return useMemo(() => withListDefaults(status, root, lists, userChecks), [status, root, lists, userChecks]);
}
/** Number of changes the commit would include. */
@@ -608,17 +567,14 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
const status = useVcs((s) => s.status);
const root = useVcs((s) => s.root) ?? "";
const groupByDir = useCommit((s) => s.groupByDir);
// With the staging area the Commit tool window shows the index: Staged / Unstaged, no lists or checkboxes.
const staging = useStagingArea() && mode === "commit";
const groupByStaging = useCommit((s) => s.groupByStaging) || staging;
const groupByStaging = useCommit((s) => s.groupByStaging);
const groupByRepo = useCommit((s) => s.groupByRepo);
const diffPreview = useCommit((s) => s.diffPreview);
const commitDiffPreview = useCommit((s) => s.commitDiffPreview);
const doubleClickOpensDiff = useWorkflowSettings((s) => s.vcs.commit.doubleClickOpensDiff);
const changelists = useChangelists((s) => s.state);
const lists = staging ? undefined : changelists;
const lists = useChangelists((s) => s.state);
const checks = useCommitChecks();
const checkboxes = mode !== "local" && !staging;
const checkboxes = mode !== "local";
const [dropTarget, setDropTarget] = useState<string | null>(null);
// IDEA starts with Unversioned Files collapsed.
const [collapsed, setCollapsed] = useState<Set<string>>(() => new Set(["group:unversioned"]));
@@ -753,9 +709,7 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
...(repos.length > 1
? [{ label: "Repository", checked: groupByRepo, run: () => setGroupByRepo(!groupByRepo) }]
: []),
...(staging
? []
: [{ label: "Staging State", checked: groupByStaging, run: () => setGroupByStaging(!groupByStaging) }]),
{ label: "Staging State", checked: groupByStaging, run: () => setGroupByStaging(!groupByStaging) },
...(mode === "local"
? [
{ kind: "separator" } as const,
@@ -944,14 +898,13 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
)}
{label}
{n.type === "group" && <span className={styles.detail}>{fileCount(n.files.length)}</span>}
{!staging && n.type === "file" && n.files[0] && isPartiallyStaged(n.files[0]) && (
{n.type === "file" && n.files[0] && isPartiallyStaged(n.files[0]) && (
<span className={styles.partial} title={tx("Partially staged: only staged hunks are committed")}>
<T>partial</T>
</span>
)}
{n.detail && n.detailIcon && <Icon name={n.detailIcon} size={14} className={styles.detailIcon} />}
{n.detail && <span className={styles.detail}>{n.detail}</span>}
{staging && <StageButton node={n} />}
</span>
);
}}
@@ -1204,8 +1157,8 @@ function CommitMessageActions() {
}
/** Label of the Commit button. */
export function commitLabel(amend: boolean, problems: boolean, all = false): string {
return problems ? "Commit Anyway" : amend ? "Amend Commit" : all ? "Commit All" : "Commit";
export function commitLabel(amend: boolean, problems: boolean): string {
return problems ? "Commit Anyway" : amend ? "Amend Commit" : "Commit";
}
/** Label of the Commit and Push button. */
@@ -1222,15 +1175,13 @@ function CommitPanel({ included }: { included: number }) {
const { canCommit } = runner;
// After Fixup… / Squash Into…, the second button commits and autosquashes the target.
const fixup = useCommit((s) => pendingFixup(s.message, s.fixupTarget));
const staging = useStagingArea();
const commitAll = useVcs((s) => staging && isCommitAll(s.status));
return (
<div className={styles.commit}>
<CommitMessageField included={included} runner={runner} />
<div className={styles.commitActions}>
<Button variant="primary" disabled={!canCommit} onClick={() => void runner.run(false)} title="⌘↩">
<T>{commitLabel(amend, checkProblems.length > 0, commitAll)}</T>
<T>{commitLabel(amend, checkProblems.length > 0)}</T>
</Button>
{fixup ? (
<Button
-22
Переглянути файл
@@ -8,9 +8,6 @@
flex-direction: column;
background: var(--bg-app);
}
.toolbar[hidden] {
display: none;
}
.toolbar {
flex: none;
height: var(--h-header);
@@ -396,22 +393,3 @@
animation: none;
}
}
/* A block of the all-in-one diff: as tall as its content, the tab scrolls. */
.fit {
flex: none;
height: auto;
}
.fit .host {
flex: none;
}
.fit .host > :global(.cm-editor) {
flex: none;
}
.fit .host :global(.cm-mergeView) {
flex: none;
overflow-y: visible;
}
.fit .host :global(.cm-mergeViewEditors) {
min-height: 0;
}
+11 -37
Переглянути файл
@@ -77,7 +77,6 @@ import {
type DiffSide,
} from "./diffInput";
import { diffAnnotations } from "./diffAnnotations";
import { setAllInOneDiff } from "./allInOneDiff";
import { annotationsShown, blameSlot, toggleAnnotations } from "./blame";
import { diffBlameTarget } from "./diffBlame";
import { changedChainNeighbour } from "./diffNavigation";
@@ -255,7 +254,6 @@ export function DiffEditor({
onNeighbour,
onJumpToSource,
onClose,
fit = false,
}: {
input: EditorInput;
toolbarActions?: ReactNode;
@@ -269,11 +267,6 @@ export function DiffEditor({
onJumpToSource?: () => void;
/** Closes the diff's editor tab (Esc, IDEA's Close Diff Editor); hosts that aren't tabs leave it out. */
onClose?: () => void;
/**
* A block of the all-in-one diff: as tall as its content (the host scrolls), without the
* toolbar, side-by-side panes always aligned, and not taking the editor tab's focus.
*/
fit?: boolean;
}) {
const input_ = input.data as DiffData;
// Swap Sides shows the request's sides the other way round; another request starts unswapped.
@@ -303,8 +296,6 @@ export function DiffEditor({
// the unified layout of an empty side is exactly that. The saved mode stays as it is.
const single = oneSided(data);
const viewMode: DiffMode = single ? "unified" : opts.mode;
/** Side-by-side panes padded to line up; a fitted block always is (its host scrolls, not the panes). */
const aligned = fit || opts.alignChanges;
const [lang, setLang] = useState<Extension | null>(null);
const [chunkInfo, setChunkInfo] = useState({ count: 0, current: -1, moves: 0, whitespaceOnly: false });
const [busy, setBusy] = useState(false);
@@ -536,7 +527,7 @@ export function DiffEditor({
let views: Views;
if (viewMode === "split") {
let merge: MergeView | null = null;
const panes = aligned
const panes = opts.alignChanges
? null
: new UnalignedPanes({
sync: syncScroll.current,
@@ -694,7 +685,7 @@ export function DiffEditor({
lang,
viewMode,
single,
aligned,
opts.alignChanges,
opts.collapse,
opts.ignore,
opts.highlight,
@@ -714,8 +705,7 @@ export function DiffEditor({
const views = viewsRef.current;
if (!views) return;
// Aligned panes scroll in MergeView's outer element, which scrollSnapshot does not cover.
// A fitted block has no scroller of its own: anchoring would scroll the all-in-one diff.
const outer = !fit && views.merge && !views.panes ? views.merge.dom : null;
const outer = views.merge && !views.panes ? views.merge.dom : null;
const top = outer?.getBoundingClientRect().top;
const block = top == null ? null : views.b.lineBlockAtHeight(Math.max(0, top - views.b.documentTop));
const anchor =
@@ -740,15 +730,14 @@ export function DiffEditor({
});
return () => cancelAnimationFrame(frame);
}
}, [softWrap, wrapSlot, fit]);
}, [softWrap, wrapSlot]);
useEffect(() => viewsRef.current?.panes?.setSync(opts.syncScroll), [opts.syncScroll]);
// The editor area focuses the tab's host (`[data-editor-focus]`), e.g. after F7 opened the next
// file: hand that focus on to the diff, so its keymap and Jump to Source apply right away.
useEffect(() => {
// The blocks of an all-in-one diff share one tab: none takes its focus.
const host = fit ? null : rootRef.current?.closest<HTMLElement>("[data-editor-focus]");
const host = rootRef.current?.closest<HTMLElement>("[data-editor-focus]");
const views = viewsRef.current;
if (!host || !views) return;
const forward = () => (focusedSide.current === "a" && views.a ? views.a : views.b).focus();
@@ -758,7 +747,7 @@ export function DiffEditor({
host.addEventListener("focus", onFocus);
if (document.activeElement === host) forward();
return () => host.removeEventListener("focus", onFocus);
}, [viewsGen, fit]);
}, [viewsGen]);
useEffect(
() => () => {
@@ -1189,25 +1178,10 @@ export function DiffEditor({
{
id: "align",
label: "Align Changes",
checked: aligned,
disabled: viewMode !== "split" || fit,
checked: opts.alignChanges,
disabled: viewMode !== "split",
run: () => setOpts({ alignChanges: !opts.alignChanges }),
},
// A tab of one file of a change: show every file of it in one scrollable tab instead.
...(input_.chain && input_.chain.length > 1 && !input_.embedded && onClose
? [
{ kind: "separator" } as const,
{
id: "allInOne",
label: "Show All Files in One Diff View",
checked: false,
run: () => {
setAllInOneDiff(true);
void openDiff(input_).then(() => onClose());
},
},
]
: []),
...contribs.flatMap((c) => {
const items = c.settingsItems?.() ?? [];
return items.length ? [{ kind: "separator" } as const, ...items] : [];
@@ -1332,7 +1306,7 @@ export function DiffEditor({
return (
<div
ref={rootRef}
className={clsx(styles.root, fit && styles.fit)}
className={styles.root}
onKeyDown={onKeyDown}
onFocusCapture={() => {
setFocusedDiffNavigator(nav.current);
@@ -1345,7 +1319,7 @@ export function DiffEditor({
}
}}
>
<div ref={toolbarRef} className={styles.toolbar} role="toolbar" aria-label={tx("Diff")} hidden={fit}>
<div ref={toolbarRef} className={styles.toolbar} role="toolbar" aria-label={tx("Diff")}>
<IconButton
icon="arrow-up"
title="Previous Difference"
@@ -1585,7 +1559,7 @@ export function DiffEditor({
className={clsx(
styles.host,
opts.highlight === "none" && styles.noHighlight,
viewMode === "split" && !aligned && styles.unaligned,
viewMode === "split" && !opts.alignChanges && styles.unaligned,
)}
hidden={!!binary || !!error || !ready}
aria-label={diffTitle(data)}
-126
Переглянути файл
@@ -1,126 +0,0 @@
import { act, fireEvent, render, screen } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("../DiffEditor", () => ({
DiffEditor: ({ input, fit }: { input: { data: { path: string; mode?: string } }; fit?: boolean }) => (
<div data-testid="block-diff" data-path={input.data.path} data-mode={input.data.mode} data-fit={String(!!fit)} />
),
}));
import { provideEditorService, type EditorInput } from "@/workbench/contributions";
import { useProject } from "@/platform/project";
import { allInOneDiff, combinedOf, setAllInOneDiff } from "../allInOneDiff";
import { CombinedDiffTab, blockKind } from "../CombinedDiff";
import { COMBINED_DIFF_KIND } from "../allInOneDiff";
import { combinedDiffInput, openDiff, withChain, type DiffData } from "../diffInput";
const diff = (path: string, extra: Partial<DiffData> = {}): DiffData => ({
path,
left: { type: "rev", rev: "HEAD" },
right: { type: "worktree" },
...extra,
});
const items = [diff("/r/src/a.ts"), diff("/r/src/b.ts"), diff("/r/c.md")];
const openInput = vi.fn(async (_input: EditorInput, _opts?: unknown) => undefined);
const closeInput = vi.fn();
const openFile = vi.fn(async () => undefined);
provideEditorService({ openInput, openFile, closeInput } as never);
beforeEach(() => {
localStorage.clear();
useProject.setState({ project: { name: "r", root: "/r", trusted: true, isGit: true, settings: {} } as never });
openInput.mockClear();
closeInput.mockClear();
});
describe("all-in-one diff", () => {
it("is off by default; on, a diff of a change with several files opens all of them", () => {
expect(allInOneDiff()).toBe(false);
expect(combinedOf(withChain(items, 1))).toBeNull();
setAllInOneDiff(true);
expect(combinedOf(withChain(items, 1))).toMatchObject({ reveal: "/r/src/b.ts" });
expect(combinedOf(withChain(items, 1))!.items).toHaveLength(3);
// One file, or a diff shown inside another view, stays as it is.
expect(combinedOf(diff("/r/a"))).toBeNull();
expect(combinedOf({ ...withChain(items, 0), embedded: true })).toBeNull();
});
it("opens one tab per change, whichever of its files asked", async () => {
setAllInOneDiff(true);
await openDiff(withChain(items, 0));
await openDiff({ ...withChain(items, 2), line: 4 });
const [first, second] = openInput.mock.calls.map((c) => c[0]);
expect(first!.kind).toBe(COMBINED_DIFF_KIND);
expect(second!.key).toBe(first!.key);
expect(second!.path).toBe("/r/c.md");
// The blocks don't carry the chain or the reveal of the file that opened them.
const blocks = (first!.data as { items: DiffData[] }).items;
expect(blocks.every((b) => !b.chain && b.line === undefined)).toBe(true);
});
it("keeps one diff per file while off", async () => {
await openDiff(withChain(items, 0));
expect(openInput.mock.calls[0]![0].kind).toBe("diff");
});
it("tells added and deleted files from the absent side", () => {
expect(blockKind(diff("/r/a", { left: { type: "text", text: "", label: "", absent: true } }))).toBe("added");
expect(blockKind(diff("/r/a", { right: { type: "text", text: "", label: "", absent: true } }))).toBe("deleted");
expect(blockKind(diff("/r/a"))).toBe("modified");
});
});
describe("the all-in-one diff tab", () => {
const input = combinedDiffInput({ items });
it("shows a block per file, each diff fitted to its content", () => {
render(<CombinedDiffTab input={input} />);
expect(screen.getByText("3 files")).toBeTruthy();
const blocks = screen.getAllByTestId("block-diff");
expect(blocks.map((b) => b.dataset.path)).toEqual(["/r/src/a.ts", "/r/src/b.ts", "/r/c.md"]);
expect(blocks.every((b) => b.dataset.fit === "true")).toBe(true);
expect(screen.getAllByText("src")).toHaveLength(2);
});
it("collapses a file and all files", () => {
render(<CombinedDiffTab input={input} />);
act(() => {
fireEvent.click(screen.getAllByRole("button", { name: "Collapse File" })[0]!);
});
expect(screen.getAllByTestId("block-diff")).toHaveLength(2);
act(() => {
fireEvent.click(screen.getByRole("button", { name: "Collapse All Files" }));
});
expect(screen.queryAllByTestId("block-diff")).toHaveLength(0);
act(() => {
fireEvent.click(screen.getByRole("button", { name: "Expand All Files" }));
});
expect(screen.getAllByTestId("block-diff")).toHaveLength(3);
});
it("switches every block between side-by-side and unified", () => {
render(<CombinedDiffTab input={input} />);
act(() => {
fireEvent.click(screen.getByRole("button", { name: "Unified Viewer" }));
});
expect(screen.getAllByTestId("block-diff").every((b) => b.dataset.mode === "unified")).toBe(true);
});
it("opens a file's own diff, and goes back to one tab per file", async () => {
setAllInOneDiff(true);
render(<CombinedDiffTab input={input} />);
await act(async () => {
fireEvent.click(screen.getAllByRole("button", { name: "Open in Separate Tab" })[1]!);
});
const own = openInput.mock.calls[0]![0];
expect(own).toMatchObject({ kind: "diff", path: "/r/src/b.ts" });
expect((own.data as DiffData).chain).toHaveLength(3);
await act(async () => {
fireEvent.click(screen.getByRole("button", { name: "Show Files in Separate Diff Tabs" }));
});
expect(allInOneDiff()).toBe(false);
expect(openInput.mock.calls[1]![0].kind).toBe("diff");
expect(closeInput).toHaveBeenCalledWith(input.key);
});
});
-174
Переглянути файл
@@ -1,174 +0,0 @@
import { act, fireEvent, render, screen } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { FileStatus } from "@/bindings";
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
return { ...real, call: vi.fn(async () => null) };
});
vi.mock("../DiffEditor", () => ({ DiffEditor: () => <div /> }));
import { call, commands } from "@/platform/ipc";
import { useProject } from "@/platform/project";
import { useContextMenuStore, type MenuItem } from "@/ui/Menu";
import { ChangesTree, nodeMenu, stageOperation } from "../CommitView";
import { buildChangeTree, planCommit } from "../changes";
import { useChangelists } from "../changelists";
import { useCommit } from "../commitStore";
import { inclusionChecks, isCommitAll, stagingChecks } from "../staging";
import { useVcs } from "../store";
const file = (rel: string, staged: FileStatus["staged"], unstaged: FileStatus["unstaged"]): FileStatus => ({
path: `/p/${rel}`,
relPath: rel,
staged,
unstaged,
renamedFrom: null,
});
const stagedOnly = file("src/Staged.kt", "modified", null);
const partial = file("src/Partial.kt", "modified", "modified");
const unstagedOnly = file("src/Unstaged.kt", null, "modified");
const untracked = file("src/New.kt", null, "untracked");
function useSettings(stagingArea: boolean, nonModal = true) {
useProject.setState({
project: { name: "p", root: "/p", trusted: true, isGit: true, settings: {} } as never,
settings: { vcs: { git: { stagingArea }, commit: { nonModal } } } as never,
});
}
describe("staging area inclusion", () => {
it("commits what is staged, the staged part of a partially staged file, and nothing else", () => {
const status = [stagedOnly, partial, unstagedOnly, untracked];
expect(isCommitAll(status)).toBe(false);
const plan = planCommit(status, stagingChecks(status));
expect(plan.included.map((f) => f.relPath)).toEqual(["src/Staged.kt", "src/Partial.kt"]);
// Nothing is added to the index, and nothing staged is left out.
expect(plan.stage).toEqual([]);
expect(plan.exclude).toEqual([]);
expect(plan.partial).toEqual([]);
});
it("with nothing staged, Commit All takes every tracked change but not unversioned files", () => {
const status = [unstagedOnly, file("src/Gone.kt", null, "deleted"), untracked];
expect(isCommitAll(status)).toBe(true);
const plan = planCommit(status, stagingChecks(status));
expect(plan.included.map((f) => f.relPath)).toEqual(["src/Unstaged.kt", "src/Gone.kt"]);
expect(plan.stage).toEqual(["/p/src/Unstaged.kt", "/p/src/Gone.kt"]);
});
it("is not Commit All when only unversioned files changed", () => {
expect(isCommitAll([untracked])).toBe(false);
});
it("ignores the checkboxes and change lists", () => {
const status = [stagedOnly, unstagedOnly];
const lists = {
active: "a",
lists: [
{ id: "a", name: "A" },
{ id: "b", name: "B" },
],
files: { "src/Staged.kt": "b" },
};
const checks = new Map([[unstagedOnly.path, "all" as const]]);
const staging = planCommit(status, inclusionChecks(status, "/p", lists as never, checks, true));
expect(staging.included.map((f) => f.relPath)).toEqual(["src/Staged.kt"]);
const lists_ = planCommit(status, inclusionChecks(status, "/p", lists as never, checks, false));
expect(lists_.included.map((f) => f.relPath)).toEqual(["src/Unstaged.kt"]);
});
});
describe("staging operations of the tree's nodes", () => {
const roots = buildChangeTree([stagedOnly, partial, unstagedOnly, untracked], "/p", false, undefined, [], true);
const group = (id: string) => roots.find((n) => n.group === id)!;
it("unstages under Staged and stages under Unstaged and Unversioned Files", () => {
const op = (id: string) => {
const o = stageOperation(group(id))!;
return [o.label, [...o.paths].sort()];
};
expect(op("staged")).toEqual(["Unstage", ["/p/src/Partial.kt", "/p/src/Staged.kt"]]);
expect(op("unstaged")).toEqual(["Stage", ["/p/src/Partial.kt", "/p/src/Unstaged.kt"]]);
expect(op("unversioned")).toEqual(["Stage", ["/p/src/New.kt"]]);
});
it("offers only Unstage for a partially staged file under Staged, only Stage under Unstaged", () => {
const enabled = (items: MenuItem[], label: string) =>
!(items.find((i) => "label" in i && i.label === label) as { disabled?: boolean }).disabled;
const underStaged = group("staged").children!.find((n) => n.label === "Partial.kt")!;
const underUnstaged = group("unstaged").children!.find((n) => n.label === "Partial.kt")!;
expect([enabled(nodeMenu([underStaged], []), "Stage"), enabled(nodeMenu([underStaged], []), "Unstage")]).toEqual([
false,
true,
]);
expect([
enabled(nodeMenu([underUnstaged], []), "Stage"),
enabled(nodeMenu([underUnstaged], []), "Unstage"),
]).toEqual([true, false]);
});
});
describe("the Commit tool window with the staging area", () => {
beforeEach(() => {
localStorage.clear();
vi.mocked(call).mockClear();
useCommit.setState({
groupByDir: false,
groupByStaging: false,
groupByRepo: true,
checks: new Map(),
selection: [],
});
useChangelists.setState({
state: {
active: "a",
lists: [
{ id: "a", name: "Changes" },
{ id: "b", name: "Feature" },
],
files: {},
} as never,
});
useVcs.setState({ root: "/p", repo: "/p", roots: ["/p"], status: [stagedOnly, unstagedOnly], heads: {} });
});
it("groups by staging state without change lists or checkboxes", () => {
useSettings(true);
render(<ChangesTree mode="commit" />);
expect(screen.getByText("Staged Changes")).toBeTruthy();
expect(screen.getByText("Unstaged Changes")).toBeTruthy();
expect(screen.queryByText("Feature")).toBeNull();
expect(screen.queryAllByRole("checkbox")).toHaveLength(0);
act(() => {
fireEvent.click(screen.getByRole("button", { name: "View Options" }));
});
const labels = useContextMenuStore.getState().menu!.items.map((i) => ("label" in i ? i.label : null));
act(() => useContextMenuStore.setState({ menu: null }));
expect(labels).not.toContain("Staging State");
});
it("stages a file from its row's button", async () => {
useSettings(true);
const stageCommand = vi.spyOn(commands, "vcsStage").mockResolvedValue({ status: "ok", data: null });
render(<ChangesTree mode="commit" />);
const stage = screen.getAllByRole("button", { name: "Stage" });
await act(async () => {
fireEvent.click(stage[stage.length - 1]!);
});
expect(stageCommand).toHaveBeenCalledWith(["/p/src/Unstaged.kt"]);
});
it("keeps change lists and checkboxes when off, or under the modal commit interface", () => {
useSettings(true, false);
const { unmount } = render(<ChangesTree mode="commit" />);
expect(screen.getByText("Feature")).toBeTruthy();
expect(screen.queryAllByRole("checkbox").length).toBeGreaterThan(0);
unmount();
useSettings(false);
render(<ChangesTree mode="commit" />);
expect(screen.queryByText("Staged Changes")).toBeNull();
});
});
Loaded 100 of 126 files, more files were not shown because too many files have changed in this diff. Show more