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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 0384f98d33 feat(release): Chinese update notes from a 中文 section of the release
The update manifest's notes come from the release body. A "## 中文" section added at the end of the draft before publishing is now published as notes.zh-CN, and the English notes leave it out. HTML comments, such as the generated-notes marker, are dropped from both.

Refs #3525
2026-11-16 09:28:37 +08:00
Gabriel Gondim b0fbc5a76c feat(mcp): run HTTP Client requests from .http files as built-in tools (#3609)
Adds two built-in MCP tools on top of ide_http. http_list_requests lists the requests in a project .http / .rest file (read-only). http_run_request runs one by index with an optional environment. It needs a trusted project and asks first; the confirmation shows the resolved URL and header names, not their values. The result has status, timing and a body truncated to 8 KiB. Request headers and body are not returned, and URLs in transport errors are redacted. The run is added to the HTTP history.

Refs #3390

Co-authored-by: GGVidal <[email protected]>
2026-11-16 09:26:11 +08:00
l0ng-ai 273564687e ci: split E2E into two parallel shards (#3620)
The E2E job reached its 30-minute limit before finishing (453 of 491 tests, none failed), so whole runs were cancelled. Two Playwright shards (about 250 tests each) run in parallel, each with its own report artifact.

Fixes #3605
2026-11-16 09:23:54 +08:00
l0ng-ai 5436b7202d feat(vcs): show every file of a change in one scrollable diff (#3617)
The diff viewer's settings menu gets Show All Files in One Diff View (off by default). With it on, a diff of a file of a change opens one Combined Changes Diff tab: a block per file under a sticky header, each diff sized to its content and loaded as it nears the viewport, with collapse, open-in-own-tab, file navigation, a shared side-by-side/unified switch and a way back to one tab per file. Blocks reuse DiffEditor in a new fit mode.

Closes #3375
2026-11-16 09:12:11 +08:00
l0ng-ai 9fdb067ec5 feat(vcs): Git staging area mode for the Commit tool window (#3615)
Settings › Version Control › Git › Enable staging area (off by default, non-modal commit interface only) makes the Commit tool window work on the Git index: Staged / Unstaged / Unversioned Files without change lists or inclusion checkboxes, a Stage or Unstage button on each row and group, and a commit of exactly what is staged; with nothing staged, Commit All commits every tracked change. The inclusion is derived from the status, so the commit pipeline is unchanged; the diff's per-block checkboxes are off in this mode.

Closes #2513
2026-11-16 09:01:45 +08:00
Deng Liuтаdengliu c8112f9010 fix(index): prevent Rayon/RwLock deadlock between streaming scans and queries (#3613)
Searching files, folders or symbols while a streaming scan indexed a project of more than 2,048 files could freeze the app for good. Queries hold IndexData::read while scanning on the global Rayon pool; the scan parsed on that same pool, took IndexData::read inside parse_found and published (IndexData::write, writer-preferring) mid-pass, so every worker could block on the lock or on the bounded channel while the query waited for a worker.

- parse_found no longer locks: the previous content hash is captured during classification, and unchanged-content metadata is refreshed inside publish.
- Background indexing and snapshot hydration run on a dedicated INDEX_POOL.
- find_files, find_dirs and find_symbols are async commands on the blocking pool, off the main thread.

Adds a test with concurrent queries across a 4,600-file scan and an unchanged-content rescan.

Co-authored-by: dengliu <[email protected]>
2026-11-16 08:42:32 +08:00
l0ng-ai 0d376cae44 fix(editor): choosers focus their rows, not the pin button, when they open (#3614)
The list popup behind Go to Declaration and the other choosers gave the initial focus to the header's pin button, so arrow keys didn't move through the rows and Enter pinned the results. List takes an autoFocus prop marking it as the popup's initial focus; the list popup sets it. Other popups with a List and header buttons already focus their search field or list.
2026-11-16 08:32:14 +08:00
NealimeKennaтаNealimeKenna b5c86bc064 feat(agents): link symbols named in inline code of agent replies (#3611)
Inline code in an agent reply that names a symbol (FooView, load(), has_header, Config.load, lib.rs::has_header, a.ts#load) now opens its definition, as file paths already did. Keywords, literals and text with spaces or shell syntax are never looked up. Names are looked up once a reply's text has settled and the spans are on screen, in one request through the new find_symbols_named command (exact matches inside the task's project, one walk over the index), and cached per name and folder. A task in a worktree resolves to the same file under its own folder. With several definitions, a file named in the same reply wins, then the task's folder; otherwise clicking opens Go to Declaration's chooser via the new optional EditorService.chooseDeclaration.

Closes #3585

Co-authored-by: NealimeKenna <[email protected]>
2026-11-16 08:29:51 +08:00
Deng Liuтаdengliu 78e169f820 fix(agents): scale Markdown list gutter in em so zoomed list markers don't clip (#3607)
The list gutter in agent replies was a fixed 20px and markers sat 6px left of it without nowrap, so zoomed-in or two-digit ordered markers (10.) were cut at the row's left edge once content-visibility painted the row clipped, or wrapped under overflow-wrap: anywhere. The indent, marker gap and task-list pull-back are now in em (wider for ordered lists and for lists of 100+ items) and markers don't wrap. Adds an e2e case with zoomed single-, two-digit, bullet and task-list markers in measured rows.

Co-authored-by: dengliu <[email protected]>
2026-11-16 08:25:08 +08:00
SunZhiQiang 601f1ee10a fix(agents): retry a failed provider probe instead of caching it (#3612)
A failed provider probe was remembered like a successful one, so a transient startup failure (the CLI updating itself, a busy machine, an initialize timeout) kept showing on the new-task page. Only a successful probe is cached now; a failed one is retried on the next call. Capabilities seeded from the cache are unchanged, since a failed probe carried only defaults.

Co-authored-by: panda-student <[email protected]>
2026-11-16 08:24:13 +08:00
Sameh Elhawaryтаsamehelhawary ea65b8c074 fix(php): only a RequestFailed error is Phoxite's refusal of a refactoring (#3610)
The Phoxite hierarchy adapter treated every server error except ContentModified as the user-facing refusal of a position, so an internal server error read like the user's mistake. Phoxite refuses with LSP RequestFailed (-32803); only that code now becomes invalid input, and other errors go through rpc_err naming the server. Adds ide_jsonrpc::codes::REQUEST_FAILED; the mock test uses -32803 and covers an internal error.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 08:23:29 +08:00
Deng Liuтаdengliu 10ddb4aa89 feat(agents): per-tab font zoom in Agent chat (#3602)
Increase/Decrease/Reset Font Size and Ctrl/Cmd+mouse wheel (when enabled) zoom the focused Agent chat tab, New Task tab or docked Agent tool window on its own (-6..+36 px): prose, code, reference chips, tool cards, prompts, the composer, Mermaid diagrams and images scale together, and off-screen virtualized rows are re-measured. Reset Font Size resets only the focused Agent surface. svgSize moves to src/ui, shared by the Markdown viewer and agents.

Co-authored-by: dengliu <[email protected]>
2026-11-16 06:46:13 +08:00
Deng Liuтаdengliu 1259423fdc feat(editor): font zoom changes the active editor by default, with an Active/All editors setting (#3604)
Increase/Decrease Font Size, Reset Font Size and Ctrl/Cmd+mouse wheel apply to the active editor (or Markdown preview) by default. Settings > Editor > General > Mouse Control gets an Active editor / All editors choice beside "Change font size with Ctrl/Command+Mouse Wheel" (editor.general.wheelZoomScope); All editors keeps the behaviour from #2488. Reset Font Size resets the active editor; Reset Font Size in All Editors (editor.resetFontSizeAll) stays in the View menu.

Co-authored-by: dengliu <[email protected]>
2026-11-16 06:44:30 +08:00
Sameh Elhawaryтаsamehelhawary 3fed53ced7 feat(php): Pull Members Up and Push Members Down with Phoxite (#3603)
When a server of the document advertises experimental.phoxite.refactor, Pull Members Up / Push Members Down send Phoxite's phoxite/refactor/hierarchyMembers and phoxite/refactor/hierarchy requests; the existing dialog, Problems Detected step and edit application are reused. A refused position becomes invalid input, as the JDT extension's refusal does. PHP joins the hierarchy refactoring languages in Refactor This.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 06:42:59 +08:00
Sameh Elhawaryтаsamehelhawary ad236cf1a1 feat(plugins): route a server's client commands to a plugin (serverCommands, API 1.9) (#3597)
A language server's code lens, code action or inlay hint can carry a command it leaves to the client. `[[contributes.serverCommands]]` (API 1.9, needs `lsp:<server>`) routes such a command, when no server of the document lists it in `executeCommandProvider`, to the plugin's own command with the arguments as JSON. The first loaded plugin keeps a claimed server + command; the host logs the conflict once. Routed from lsp_execute_command, lsp_apply_code_action and lsp_execute_code_action; a code action's command is matched against its own server's claims only.

Part of #3542.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 05:32:06 +08:00
l0ng-ai 3b06fc037d test(index): wait for the snapshot instead of a fixed 150 ms
The warm-start snapshot is written on the worker's next round after a short delay; the test polls for it instead of sleeping 150 ms, which loaded CI runners didn't always cover.
2026-11-16 05:21:23 +08:00
l0ng-ai 6d70458e22 fix(rust): colour self as a keyword (#3600)
rust-analyzer's selfKeyword token and @lezer/rust's self tag were painted with Python's self-parameter colour; both now take the keyword colour, as RustRover colours the self parameter by default.
2026-11-16 05:11:06 +08:00
l0ng-ai bbd7c36c40 feat(hierarchy): pin Hierarchy tabs; a new hierarchy replaces the selected unpinned one (#3599)
Call and type hierarchies open in content tabs. A new hierarchy takes the place of the selected tab unless it is pinned, then it opens in its own tab. Tabs are pinned from the shared content tab menu or the pin in place of the close button; a tab shown again keeps its tree and expanded nodes.
2026-11-16 05:09:20 +08:00
119 змінених файлів з 4116 додано та 395 видалено

No files matched your search

+7 -3
Переглянути файл
@@ -208,11 +208,15 @@ jobs:
- run: pnpm build
e2e:
name: E2E
name: E2E (${{ matrix.shard }}/2)
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:
@@ -222,12 +226,12 @@ jobs:
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm e2e
- run: pnpm e2e --shard=${{ matrix.shard }}/2
env:
HOME: /root
- uses: actions/upload-artifact@v6
if: failure()
with:
name: playwright-report
name: playwright-report-${{ matrix.shard }}
path: playwright-report/
retention-days: 7
+29 -9
Переглянути файл
@@ -262,26 +262,46 @@ 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 withoutDownloadSection = (body) => {
const kept = [];
const languages = { "中文": "zh-CN" };
const notesByLanguage = (body) => {
const parts = { "": [] };
let lang = "";
let langLevel = 0;
let skip = 0;
for (const line of body.split(/\r?\n/)) {
for (const line of body.replace(/<!--[\s\S]*?-->/g, "").split(/\r?\n/)) {
const heading = /^(#{1,6})\s+(.*)$/.exec(line);
if (heading) {
const level = heading[1].length;
if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
const title = heading[2].trim();
if (skip && level <= skip) skip = 0;
if (lang && level <= langLevel) lang = "";
if (!skip && level <= 3 && /^download$/i.test(title)) {
skip = level;
continue;
}
if (skip && level <= skip) skip = 0;
if (!skip && !lang && level <= 2 && languages[title]) {
lang = languages[title];
langLevel = level;
parts[lang] ??= [];
continue;
}
}
if (!skip) kept.push(line);
if (!skip) parts[lang].push(line);
}
return kept.join("\n").trim();
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,
};
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({
+7 -2
Переглянути файл
@@ -1204,7 +1204,10 @@ impl AgentManager {
}
/// What `provider` reports about itself, from `initialize` alone: no session is opened,
/// so no MCP server, hook or sign-in runs. Remembered until `refresh`.
/// 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.
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());
@@ -1266,7 +1269,9 @@ impl AgentManager {
}
Err(e) => probe.error = Some(e),
}
self.shared.probes.lock().insert(spec.id, probe.clone());
if probe.error.is_none() {
self.shared.probes.lock().insert(spec.id, probe.clone());
}
Ok(probe)
}
+34
Переглянути файл
@@ -2474,6 +2474,40 @@ 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,6 +12,8 @@ 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.
@@ -37,6 +39,7 @@ 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,6 +69,9 @@ 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 {
@@ -90,6 +93,7 @@ impl Default for GitSettings {
show_push_dialog: true,
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
}
}
}
+252
Переглянути файл
@@ -0,0 +1,252 @@
//! 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,6 +7,7 @@ pub(crate) mod run;
mod vcs;
pub use requests::Requests;
mod files;
mod http;
mod page;
mod reports;
mod search;
@@ -39,6 +40,7 @@ fn tools() -> Vec<tool::Tool> {
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
tools.extend(http::tools());
tools
}
+48
Переглянути файл
@@ -1057,6 +1057,11 @@ 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)
{
@@ -1608,9 +1613,47 @@ 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,
@@ -1652,6 +1695,11 @@ 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())
+28 -9
Переглянути файл
@@ -54,8 +54,9 @@ pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<Extensi
Ok(host.project(window)?.index.file_extensions())
}
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(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 async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
@@ -63,18 +64,33 @@ 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 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_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_symbols(
pub async fn find_symbols(
host: &Host,
window: &str,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
Ok(host.project(window)?.index.find_symbols(&query, filter, limit as usize))
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
}
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
@@ -318,11 +334,14 @@ 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")?) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
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")?) });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_symbols", |c| async move {
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
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
});
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,6 +313,35 @@ 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,6 +93,7 @@ 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,6 +46,11 @@
//! 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"
@@ -72,6 +77,7 @@ 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).
@@ -964,6 +970,37 @@ 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,6 +500,7 @@ 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,3 +697,76 @@ 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
Переглянути файл
@@ -0,0 +1,184 @@
//! `[[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();
}
+18 -14
Переглянути файл
@@ -70,10 +70,14 @@ async fn open(fixture: &str) -> Opened {
}
/// Polls `check` until it holds; fails with its last answer.
async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: impl FnMut() -> Result<(), T>) {
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>>,
{
let deadline = Instant::now() + timeout;
loop {
match check() {
match check().await {
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,
@@ -82,25 +86,25 @@ async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: imp
}
impl Opened {
fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).unwrap();
async fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).await.unwrap();
found.into_iter().map(|f| f.rel_path).collect()
}
fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).unwrap();
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();
found.into_iter().map(|s| (s.name, s.rel_path)).collect()
}
fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter);
async fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter).await;
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), || {
until("indexing", Duration::from_secs(30), || async {
let s = ops::nav::index_status(&p.host, WINDOW).unwrap();
if !s.indexing && s.files > 0 && s.symbols > 0 { Ok(()) } else { Err(s) }
})
@@ -115,12 +119,12 @@ async fn smoke(f: Fixture) {
);
}
let files = p.files(f.file.0);
let files = p.files(f.file.0).await;
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) {
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types).await {
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) {
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All).await {
panic!("{}: Go to Symbol {:?}: {found:?}", f.dir, f.symbol.0);
}
@@ -130,8 +134,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), || {
let found = p.symbols("FreshWidget", SymbolFilter::Types);
until("a deleted file's class", Duration::from_secs(20), || async {
let found = p.symbols("FreshWidget", SymbolFilter::Types).await;
if found.is_empty() { Ok(()) } else { Err(found) }
})
.await;
+10 -2
Переглянути файл
@@ -646,8 +646,16 @@ impl IndexData {
}
}
pub(crate) fn record_of(&self, path: &Path) -> Option<FileRecord> {
self.get(path).map(|e| self.record(e))
/// 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))
}
/// The symbols of one file, in declaration order.
+5
Переглянути файл
@@ -323,6 +323,11 @@ 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,6 +632,41 @@ 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::*;
+107 -2
Переглянути файл
@@ -549,6 +549,24 @@ 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")]);
@@ -779,8 +797,13 @@ 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));
std::thread::sleep(Duration::from_millis(150));
assert!(f.cache.join("index.snapshot").exists(), "a watcher update must regenerate the snapshot");
// 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");
}
#[test]
@@ -962,3 +985,85 @@ 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");
}
+146 -81
Переглянути файл
@@ -11,9 +11,21 @@ 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;
@@ -254,17 +266,19 @@ impl Shared {
}
}
let build_started = Instant::now();
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 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 built = build_started.elapsed();
if entries.iter().any(Option::is_none) {
return false;
@@ -333,17 +347,19 @@ impl Shared {
let started = Instant::now();
match store.load_snapshot() {
Some(snapshot) => {
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 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 mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -363,16 +379,18 @@ 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>)> = 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>)> = 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 mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -446,10 +464,11 @@ impl Shared {
}
let classify_started = Instant::now();
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
let (todo, stale) = {
let d = self.data.read();
let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
let stale = d
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
.paths()
.filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
.filter(|p| !seen.contains(p.as_path()))
@@ -470,7 +489,7 @@ impl Shared {
let total = todo.len();
let mut laps = ChunkLaps::default();
{
// One streaming parallel pass: parse on the rayon pool without
// One streaming parallel pass: parse on `INDEX_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
@@ -485,12 +504,14 @@ impl Shared {
let pass_started = Instant::now();
std::thread::scope(|scope| -> () {
scope.spawn(move || {
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);
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);
});
});
// `tx` drops here: the consumer's loop ends with the channel.
});
@@ -570,13 +591,13 @@ impl Shared {
}
/// Extracts records in parallel, then publishes them to memory and disk.
/// `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 {
fn index_files(&self, files: &[(Found, Option<ContentHash>)]) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let files: Vec<&Found> = files.collect();
let filter = self.filter();
let started = Instant::now();
let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
let extracted: Vec<ParsedFile> = INDEX_POOL.install(|| {
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
});
laps.extract = started.elapsed();
if extracted.is_empty() {
return laps;
@@ -585,49 +606,69 @@ impl Shared {
laps
}
/// 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> {
/// 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> {
if self.is_cancelled() {
return None;
}
let rel = filter.rel(&f.path)?;
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,
};
let key = filter.store_key(&f.path);
let bytes = postcard::to_allocvec(&rec).ok();
Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
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 }
}
};
Some(ParsedFile { rel, key, outcome, 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 entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut inserts: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut refreshes: Vec<MetadataRefresh> = Vec::new();
let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
for out in batch {
let ParsedFile { rel, rec, key, bytes, path } = out;
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
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 });
}
}
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 entries {
for (e, symbols) in inserts {
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();
@@ -818,9 +859,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> = {
let files: Vec<(Found, Option<ContentHash>)> = {
let d = self.data.read();
files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
files.into_iter().filter_map(|f| prev_hash_if_stale(&d, &f).map(|h| (f, h))).collect()
};
if !files.is_empty() {
touched = true;
@@ -828,17 +869,17 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), false);
self.index_files(chunk);
}
}
for before in reparse {
let affected: Vec<Found> = {
let affected: Vec<(Found, Option<ContentHash>)> = {
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 })
Some((Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, None))
})
.collect()
};
@@ -848,7 +889,7 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), true);
self.index_files(chunk);
}
}
}
@@ -866,6 +907,18 @@ 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();
@@ -898,14 +951,26 @@ impl ChunkLaps {
}
}
/// One file parsed off the index thread: its record ready to publish, already
/// serialized for the cache (in parallel with the parse).
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.
struct ParsedFile {
rel: String,
rec: FileRecord,
/// Cache key and postcard bytes; `None` when outside the persisted root.
/// Cache key; `None` when outside the persisted root.
key: Option<String>,
bytes: Option<Vec<u8>>,
outcome: ParsedOutcome,
path: PathBuf,
}
+3
Переглянути файл
@@ -194,6 +194,9 @@ 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`.
+8 -1
Переглянути файл
@@ -1,5 +1,6 @@
//! Pull Members Up / Push Members Down through the app-owned JDT extension
//! (`java/java-usages`). The server checks the move and computes the edit; the UI
//! (`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
//! shows its problems and applies the edit itself.
use super::COMMAND_TIMEOUT;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
@@ -75,6 +76,9 @@ 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)
}
@@ -89,6 +93,9 @@ 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,6 +26,7 @@ mod launch;
mod library_source;
mod loading;
mod notebook;
mod phoxite;
mod plugin_requests;
mod pull;
mod scope;
+97
Переглянути файл
@@ -0,0 +1,97 @@
//! 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,6 +57,16 @@ 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,3 +7429,91 @@ 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,3 +1022,82 @@ 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 @@
4788f82b35966e155dbf51af520acb2d5e7773ddf9f36f4239b9bd51d51b0fb3
6a36bd56db7148032c1fe101bec8c38e326528b1de1ee26b5d7c5b9dd80b3e94
+10
Переглянути файл
@@ -22,3 +22,13 @@ 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,6 +10,8 @@ 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 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 › 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 › 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**.
+3 -1
Переглянути файл
@@ -94,6 +94,7 @@ 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:
@@ -105,6 +106,7 @@ 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
@@ -122,7 +124,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` 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.
- **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.
- 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 only |
| **Push Members Down…** | — | — | Java only |
| **Pull Members Up…** | — | — | Java; PHP with Phoxite |
| **Push Members Down…** | — | — | Java; PHP with Phoxite |
## 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 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.
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.
## 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, 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.
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**.
### UI font and zoom
+25 -24
Переглянути файл
@@ -100,30 +100,31 @@ 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) |
| `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) |
| `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) |
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` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
- **视图 › 外观 › 进入无干扰模式** 隐藏工具窗口、标签页、状态栏和装订区域,并让正文居中。再执行一次即可退出。
- 行号、空白字符、缩进参考线、光标样式和意图灯泡在 **设置 › 编辑器 › 常规 › 外观** 中设置。痕迹导航和粘滞行(滚动时把所在的声明固定在顶部)在 **设置 › 编辑器 › 常规** 下各有单独的页面。
+14 -12
Переглянути файл
@@ -82,17 +82,18 @@ 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` |
| 类别 | 工具 |
| ----------- | --------------------------------------------------------------------------- |
| 文件 | `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` |
几点说明:
@@ -104,6 +105,7 @@ 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`),会先询问,并返回状态和截断后的响应体——不含请求头或请求体。
## 在运行工具窗口中执行命令
@@ -121,7 +123,7 @@ stdio 配置大致如下(路径以你机器上的为准):
## 安全
- **未受信任的项目** 只开放只读工具。写文件、重命名、重新格式化、构建或运行的工具都要求项目已被信任。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project` 和 `run_command` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project`、`run_command` 和 `http_run_request` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- 会写入的工具拒绝项目之外的路径。
## 限制
+3 -3
Переглянути файл
@@ -27,8 +27,8 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
| **内联…** | `⌥⌘N` | `Ctrl+Alt+N` | 语言服务器 |
| **移动…** | `F6` | `F6` | 语言服务器(符号);IDE(文件和文件夹) |
| **安全删除…** | `⌘⌦` | `Alt+Delete` | IDE,借助服务器查找引用 |
| **上拉成员…** | — | — | 仅 Java |
| **下推成员…** | — | — | 仅 Java |
| **上拉成员…** | — | — | Java;PHP(使用 Phoxite) |
| **下推成员…** | — | — | Java;PHP(使用 Phoxite) |
## 重命名
@@ -73,7 +73,7 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
## 上拉成员与下推成员
用于在 Java 类和它的父类或子类之间移动字段和方法。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。这两项由 OpenIDEA 自带的 Java 扩展提供,其他语言不可用。
用于在类和它的父类或子类之间移动字段和方法:支持 Java,以及使用 Phoxite 作为 PHP 服务器时的 PHP(方法、属性和常量)。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。Java 由 OpenIDEA 自带的扩展提供,PHP 由 Phoxite 提供;其他语言和其他 PHP 服务器不可用。
## 撤销
+1 -1
Переглянути файл
@@ -64,7 +64,7 @@ OpenIDEA 会把主题(以及其中附带的编辑器配色方案)转换为
- **启用连字**:用于带编程连字的字体。
- **排版设置**:**主字重**、**粗体字重**,以及主字体缺少字符时使用的 **备用字体**。
临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置所有编辑器中的字体大小** 恢复。在 macOS 上,开启 **设置 › 编辑器 › 常规** 中的 **使用 Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放。
在当前编辑器中临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置字体大小**(或 **视图 › 重置所有编辑器中的字体大小**)恢复。在 **设置 › 编辑器 › 常规** 中开启 **使用 Ctrl/Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
### 界面字体与缩放
+25 -24
Переглянути файл
@@ -100,30 +100,31 @@ 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) |
| `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) |
| `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) |
条目 id(命令、视图、主题等)匹配 `[a-z0-9][a-z0-9._-]*`,不超过 64 个字符。菜单、快捷键和状态栏项只能引用插件自己声明的命令;在 IDE 内部,命令的操作 id 是 `plugin.<plugin id>.<command id>`。
+58
Переглянути файл
@@ -761,3 +761,61 @@ 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
Переглянути файл
@@ -0,0 +1,3 @@
# Per-user IDE state
/shelf/
/changelists.json
+31
Переглянути файл
@@ -157,6 +157,7 @@ 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
@@ -432,6 +433,8 @@ 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_.
@@ -781,6 +784,34 @@ 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,6 +250,7 @@ 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,
+28 -6
Переглянути файл
@@ -24,8 +24,13 @@ pub fn index_file_extensions(window: Window, state: State<'_, AppState>) -> IdeR
#[tauri::command]
#[specta::specta]
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)
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
}
#[tauri::command]
@@ -37,8 +42,13 @@ pub async fn find_files_named(window: Window, state: State<'_, AppState>, name:
/// Folders holding indexed files, for `@` references.
#[tauri::command]
#[specta::specta]
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)
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
}
/// Spring Web mapping sources for the request-path index of Search Everywhere.
@@ -53,14 +63,26 @@ pub fn spring_route_sources(
#[tauri::command]
#[specta::specta]
pub fn find_symbols(
pub async 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)
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
}
#[tauri::command]
+2 -1
Переглянути файл
@@ -439,7 +439,8 @@ pub fn spec(os: Os) -> Vec<Entry> {
SEP,
act("view.quickSwitchScheme", "Quick Switch Scheme…"),
SEP,
act("editor.resetFontSize", "Reset Font Size in All Editors"),
act("editor.resetFontSize", "Reset Font Size"),
act("editor.resetFontSizeAll", "Reset Font Size in All Editors"),
SEP,
act("view.notifications", "Notifications"),
],
+4 -2
Переглянути файл
@@ -1,10 +1,12 @@
//! 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, or diff two
/// arbitrary texts: they must be `async` and do that work on the blocking pool.
/// 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.
const OFF_MAIN_THREAD: &[(&str, &[&str])] = &[
("doc.rs", &["history_list", "history_content"]),
("nav.rs", &["find_files", "find_dirs", "find_symbols"]),
(
"vcs.rs",
&[
+4 -3
Переглянути файл
@@ -216,10 +216,11 @@ 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 sync
find_files always project_host bindings sync
find_dirs always project_host bindings async
find_files always project_host bindings async
find_files_named always project_host bindings async
find_symbols always project_host bindings sync
find_symbols always project_host bindings async
find_symbols_named always project_host bindings async
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,6 +491,8 @@ 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")),
@@ -4899,6 +4901,8 @@ 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. */
@@ -5723,6 +5727,11 @@ 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 = {
+57 -12
Переглянути файл
@@ -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 } from "@/workbench/contributions";
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom, stepSurfaceFontZoomIn } 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, stepAllEditorsFontZoom } from "./cm/prefs";
import { resetAllEditorsFontZoom, resetConfiguredEditorsFontZoom, stepConfiguredEditorsFontZoom } from "./cm/prefs";
import { useProject } from "@/platform/project";
import { call, commands } from "@/platform/ipc";
import { editorPrefs } from "@/platform/editorSettings";
@@ -117,7 +117,12 @@ function withView(run: (view: EditorView, slot: EditorSlot) => unknown) {
};
}
/** Routes keyboard font zoom to focus, then the active editor slot. */
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. */
function stepSurfaceFontSize(delta: 1 | -1): void {
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
if (activeEl) {
@@ -126,18 +131,55 @@ function stepSurfaceFontSize(delta: 1 | -1): void {
if (cmEl) {
const cmView = EditorView.findFromDOM(cmEl);
if (cmView) {
stepAllEditorsFontZoom(cmView, delta);
stepConfiguredEditorsFontZoom(cmView, delta);
return;
}
}
}
const slot = activeSlot();
if (!slot?.view) return;
stepAllEditorsFontZoom(slot.view, delta);
if (!slot?.view) {
stepSurfaceFontZoomIn(activePaneEditorFocus(), delta);
return;
}
stepConfiguredEditorsFontZoom(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. */
@@ -934,16 +976,19 @@ 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: () => {
resetAllEditorsFontZoom();
if (typeof document !== "undefined") {
resetSurfaceFontZoom();
}
},
run: resetAllFontSize,
},
{
id: "editor.increaseFontSize",
+20 -4
Переглянути файл
@@ -37,7 +37,7 @@ import { markdownImages } from "./markdownImages";
import { selectionMarks } from "./selectionMarks";
import { seamlessSelection } from "./selectionLayer";
import { useEditorRegistry } from "@/editor/api";
import type { EditorExtras } from "@/platform/editorSettings";
import { editorPrefs, type EditorExtras } from "@/platform/editorSettings";
import { openideaHighlightStyle } from "./highlight";
import {
cursorHumpLeft,
@@ -426,11 +426,27 @@ 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)
if (ed.view.state.field(fontZoom, false)) ed.view.dispatch({ effects: setFontZoom.of(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);
}
/** Exported for tests: the ⌘/Ctrl+wheel handler of the prefs compartment. */
@@ -438,7 +454,7 @@ export const wheelZoom = EditorView.domEventHandlers({
wheel(e, view) {
if (!e.metaKey && !e.ctrlKey) return false;
e.preventDefault();
stepAllEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
stepConfiguredEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
return true;
},
});
+12 -4
Переглянути файл
@@ -331,12 +331,20 @@ 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 (!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);
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);
}
const prev = prevTabs;
prevTabs = s;
if (
+21 -3
Переглянути файл
@@ -2,11 +2,12 @@ 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("shared editor font zoom (#2480)", () => {
describe("editor font zoom (active editor by default, all editors when configured)", () => {
const handles: TextEditorHandle[] = [];
const makeView = (extensions = [fontZoom, wheelZoom]) => {
const parent = document.createElement("div");
@@ -17,7 +18,10 @@ describe("shared editor font zoom (#2480)", () => {
handles.push(handle);
return view;
};
beforeEach(() => resetAllEditorsFontZoom());
beforeEach(() => {
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
afterEach(() => {
for (const handle of handles) {
useEditorRegistry.getState().editors.delete(handle);
@@ -26,9 +30,23 @@ describe("shared editor font zoom (#2480)", () => {
}
handles.length = 0;
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
it("zooms every open editor from ⌘/Ctrl+wheel on one of them", () => {
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);
const first = makeView();
const second = makeView();
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
+10
Переглянути файл
@@ -13,6 +13,8 @@ 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";
@@ -64,6 +66,14 @@ 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;
+8 -1
Переглянути файл
@@ -12,11 +12,13 @@ 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();
@@ -26,9 +28,14 @@ describe("custom editor close lifecycle", () => {
controller.split(useTabs.getState().activePane, "row");
const panes = Object.values(useTabs.getState().panes);
expect(panes).toHaveLength(2);
await controller.closeTab(panes[0]!.id, panes[0]!.tabs[0]!.id);
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);
expect(close).not.toHaveBeenCalled();
await controller.closeInput(input.key);
expect(tabClose).toHaveBeenCalledTimes(2);
expect(tabClose).toHaveBeenLastCalledWith(secondTabId, input);
expect(close).toHaveBeenCalledExactlyOnceWith(input);
} finally {
dispose();
+6 -3
Переглянути файл
@@ -21,6 +21,7 @@ import {
prepareMenuGroups,
textEditorWrapperFor,
EditorShownProvider,
EditorTabIdProvider,
useContributions,
useFileDecorations,
useEditorDocumentRevision,
@@ -479,9 +480,11 @@ function KindEditor({ tab, shown, kept = false }: { tab: Tab; shown: boolean; ke
tabIndex={-1}
aria-hidden={shown ? undefined : true}
>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
<EditorTabIdProvider value={tab.id}>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
);
}
+15
Переглянути файл
@@ -135,6 +135,21 @@ 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,6 +210,7 @@ function ListPopup({ popup }: { popup: Extract<LspPopup, { kind: "list" }> }) {
activeIndex={activeIndex}
onActiveChange={setActive}
hoverSelects
autoFocus
aria-label={popup.title}
onActivate={(r) => activate(r.item)}
empty={
+2 -2
Переглянути файл
@@ -41,8 +41,8 @@ import {
import { safeDelete } from "./safeDelete";
import { startHierarchyRefactoring } from "./hierarchy";
/** Languages whose server runs the class-hierarchy refactorings (the app-owned JDT extension). */
const HIERARCHY_LANGUAGES = new Set(["java"]);
/** 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"]);
/** 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(--fs-ui);
font-size: var(--agent-fs-ui, var(--fs-ui));
}
.field :global(.cm-editor.cm-focused) {
outline: none;
+4 -1
Переглянути файл
@@ -1,4 +1,7 @@
.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;
@@ -22,7 +25,7 @@
}
.heading {
margin: 0 0 10px;
font-size: 18px;
font-size: calc(18px + var(--agent-font-zoom, 0px));
font-weight: 600;
text-align: center;
color: var(--fg-strong);
+9 -3
Переглянути файл
@@ -14,7 +14,8 @@ import { SubmitButton } from "./SubmitButton";
import { canSend, emptyDraft } from "./composerModel";
import { ConfigPickers } from "./ConfigPickers";
import { useEffortFocus } from "./effortFocus";
import { providerIcon } from "./model";
import { useAgentFontZoomSurface } from "./fontZoom";
import { HOME_KEY, providerIcon } from "./model";
import { ADD_AGENT, providerOptions as agentOptions } from "./providerOptions";
import {
HOME,
@@ -31,7 +32,7 @@ import {
import { useAgentSettings } from "./agentSettings";
import styles from "./Home.module.css";
export function HomeEditor({ docked = false }: { docked?: boolean; input?: EditorInput }) {
export function HomeEditor({ docked = false, input }: { docked?: boolean; input?: EditorInput }) {
const tx = useTx();
const txTemplate = useTxTemplate();
const draft = useAgents((s) => s.draft);
@@ -97,6 +98,7 @@ export function HomeEditor({ docked = false }: { docked?: boolean; input?: Edito
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" &&
@@ -127,7 +129,11 @@ export function HomeEditor({ docked = false }: { docked?: boolean; input?: Edito
};
return (
<div ref={homeRoot} className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}>
<div
ref={homeRoot}
className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}
style={zoomStyle}
>
<div className={styles.inner}>
{!docked && (
<h1 className={styles.heading}>
+88 -2
Переглянути файл
@@ -3,17 +3,20 @@ 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, openExternalUrl } = vi.hoisted(() => ({
const { openFile, chooseDeclaration, 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 }),
editorService: () => ({ openFile, chooseDeclaration }),
}));
vi.mock("@/platform/openUrl", () => ({ openExternalUrl }));
vi.mock("@/ui", async (importOriginal) => ({
@@ -349,3 +352,86 @@ 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"));
});
});
+111 -12
Переглянути файл
@@ -1,25 +1,28 @@
/**
* Agent messages: Markdown → sanitized HTML (marked + DOMPurify). Fenced code is
* highlighted and gets a Copy button; inline code naming a file of the task opens it.
* highlighted and gets a Copy button; inline code naming a file of the task, or a symbol
* the index has, 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 { useLayoutEffect, useRef, useSyncExternalStore } from "react";
import { useEffect, 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 } from "@/workbench/contributions";
import { editorService, type DeclarationChoice } from "@/workbench/contributions";
import { hasMermaid, renderMermaidIn } from "@/features/viewers/markdown/mermaid";
import { subscribeTheme, themeKey } from "@/platform/themeWatch";
import { fileHref, pathLink, type PathLink } from "./conversation";
import { fileHref, pathLink, symbolRef, type PathLink, type SymbolRef } 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) =>
@@ -172,6 +175,58 @@ 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;
@@ -197,15 +252,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 link = pathLink(code.textContent ?? "", cwd);
const text = code.textContent ?? "";
const ref = symbolRef(text);
if (ref) symbolRefs.set(code, ref);
const link = pathLink(text, cwd);
if (!link) return;
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}`;
const exists = fileExists(link.path);
if (ref) fileChecks.set(code, exists);
void exists.then((found) => {
if (alive && found) markPath(code, link);
});
});
return () => {
@@ -276,6 +331,9 @@ 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;
@@ -293,6 +351,39 @@ 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.
@@ -318,6 +409,14 @@ 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: 20px;
height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
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(--fs-small);
line-height: 20px;
font-size: var(--agent-fs-small, var(--fs-small));
line-height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
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(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
line-height: 1.5;
white-space: pre;
overflow-x: auto;
+57 -32
Переглянути файл
@@ -1,6 +1,9 @@
.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;
@@ -252,6 +255,7 @@
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 > * {
@@ -322,7 +326,7 @@
-webkit-user-select: none;
user-select: none;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: nowrap;
}
.messageHead > .role {
@@ -357,7 +361,7 @@
gap: 5px;
margin-bottom: 3px;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
@@ -551,7 +555,7 @@
}
.markdown :global(code) {
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
padding: 0 2px;
border-radius: 3px;
background: var(--md-code-bg);
@@ -620,12 +624,19 @@
display: none;
}
.markdown :global(.mermaid-output) {
overflow: hidden;
overflow-x: auto;
overflow-y: 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;
@@ -634,7 +645,7 @@
background: var(--bg-elev);
color: var(--danger);
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
text-align: left;
white-space: pre-wrap;
}
@@ -648,10 +659,17 @@
.markdown :global(ul),
.markdown :global(ol) {
--md-list-indent: 1.55em;
margin: 0 0 8px;
padding-left: 20px;
padding-left: var(--md-list-indent);
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) {
@@ -659,7 +677,8 @@
}
.markdown :global(li)::before {
position: absolute;
right: calc(100% + 6px);
right: calc(100% + 0.45em);
white-space: nowrap;
-webkit-user-select: none;
user-select: none;
}
@@ -721,7 +740,11 @@
border-top: 1px solid var(--border);
}
.markdown :global(img) {
max-width: 100%;
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;
}
.loadImage {
padding: 2px 8px;
@@ -736,7 +759,7 @@
background: var(--bg-hover);
}
.markdown :global(li:has(> input[type="checkbox"])) {
margin-left: -20px;
margin-left: calc(-1 * var(--md-list-indent));
}
.markdown :global(li:has(> input[type="checkbox"]))::before {
content: none;
@@ -762,9 +785,9 @@
align-items: center;
gap: var(--space-1);
min-width: 0;
height: var(--h-row);
min-height: var(--h-row);
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
@@ -817,7 +840,7 @@
}
.toolTitle {
min-width: 0;
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
@@ -830,7 +853,7 @@
}
.toolDiff {
font: inherit;
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
border: 0;
background: none;
padding: 0 4px;
@@ -861,7 +884,7 @@
padding: 0 calc(var(--space-2) / 2);
border-radius: var(--radius-row);
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
@@ -917,7 +940,7 @@
border: 1px solid var(--border);
background: var(--bg-elev);
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: pre-wrap;
overflow-wrap: anywhere;
color: var(--fg-secondary);
@@ -974,7 +997,7 @@
.permissionCommand {
min-width: 0;
max-width: 100%;
max-height: calc(var(--lh-code) * 6);
max-height: calc((var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6) * 6);
box-sizing: border-box;
margin: 0;
padding: var(--space-2);
@@ -984,8 +1007,8 @@
background: var(--bg-editor);
color: var(--fg);
font-family: var(--font-mono);
font-size: var(--fs-code);
line-height: var(--lh-code);
font-size: var(--agent-fs-code, var(--fs-code));
line-height: calc(var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6);
white-space: pre-wrap;
overflow-wrap: anywhere;
tab-size: 2;
@@ -1023,7 +1046,7 @@
text-overflow: ellipsis;
white-space: nowrap;
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.permissionDone {
padding: calc(var(--space-2) / 2) 0;
@@ -1031,7 +1054,7 @@
border-radius: var(--radius-small);
background: none;
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.permissionRecord {
display: block;
@@ -1120,6 +1143,7 @@
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;
@@ -1212,7 +1236,7 @@
flex-wrap: wrap;
gap: var(--space-1) var(--space-1-5);
margin-top: 4px;
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.attachment {
display: inline-flex;
@@ -1425,7 +1449,7 @@
flex: none;
margin-left: auto;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
@@ -1433,7 +1457,7 @@
padding-left: 22px;
color: var(--fg-muted);
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
@@ -1441,7 +1465,7 @@
.subagentSection > summary {
padding-left: 22px;
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
cursor: pointer;
list-style: none;
}
@@ -1510,7 +1534,7 @@
.messageFrom {
margin-bottom: 2px;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.readOnly {
@@ -1567,6 +1591,7 @@
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 {
@@ -1617,7 +1642,7 @@
border-radius: var(--radius-small);
background: var(--bg-hover);
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionLabel .questionTag {
margin: 0 0 0 8px;
@@ -1674,13 +1699,13 @@
}
.questionDescription {
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
overflow-wrap: anywhere;
}
.questionKey {
flex: none;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionOther {
margin: 2px 0 0 30px;
@@ -1725,7 +1750,7 @@
}
.questionPreviewCaption {
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionPreviewBody {
margin: 0;
@@ -1735,14 +1760,14 @@
border-radius: var(--radius-small);
background: var(--bg-editor);
font-family: var(--font-mono);
font-size: var(--fs-code);
font-size: var(--agent-fs-code, var(--fs-code));
}
.questionPreviewEmpty {
padding: 8px;
border: 1px dashed var(--border);
border-radius: var(--radius-small);
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionActions {
display: flex;
@@ -1758,7 +1783,7 @@
}
.questionPage {
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
+40 -13
Переглянути файл
@@ -81,6 +81,7 @@ 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";
@@ -115,6 +116,7 @@ import {
hasTaskTerminal,
isBusy,
providerIcon,
sessionKey,
statusLabel,
subagentStatusLabel,
subagentTitle,
@@ -223,6 +225,7 @@ 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>(
() => ({
@@ -255,7 +258,7 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
changesOpen && !docked && styles.withChanges,
fitWindowWidth && styles.fitWidth,
)}
style={changesWidth}
style={{ ...changesWidth, ...zoomStyle }}
onFocusCapture={() => shown && setFocusedSession(session)}
onBlurCapture={(e) => {
if (!e.currentTarget.contains(e.relatedTarget as Node | null) && focusedSession() === session) {
@@ -291,6 +294,7 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
onOpenSubagent={openSubagent}
finding={finding && shown}
findFocus={findFocus}
fontZoom={fontZoom}
onCloseFind={() => setFinding(false)}
/>
</FoldedContent.Provider>
@@ -611,9 +615,10 @@ function useOffscreenRows(
visible: boolean,
enabled: boolean,
fitWindowWidth: boolean,
fontZoom: number,
) {
// The container width and column mode the marked rows were laid out at.
const measured = useRef<{ width: number; fitWindowWidth: boolean } | null>(null);
// 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);
useLayoutEffect(() => {
const el = ref.current;
if (!el) return;
@@ -628,10 +633,15 @@ function useOffscreenRows(
return;
}
if (!visible) return;
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
measured.current = { width: el.clientWidth, fitWindowWidth };
if (
measured.current?.width === el.clientWidth &&
measured.current.fitWindowWidth === fitWindowWidth &&
measured.current.fontZoom === fontZoom
)
return;
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
unmark();
}, [ref, visible, enabled, fitWindowWidth]);
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
useEffect(() => {
const el = ref.current;
if (!el || !enabled || !visible) return;
@@ -654,8 +664,13 @@ function useOffscreenRows(
});
};
const remeasure = () => {
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
measured.current = { width: el.clientWidth, fitWindowWidth };
if (
measured.current?.width === el.clientWidth &&
measured.current.fitWindowWidth === fitWindowWidth &&
measured.current.fontZoom === fontZoom
)
return;
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
unmark();
};
remeasure();
@@ -676,7 +691,7 @@ function useOffscreenRows(
rows.disconnect();
resize.disconnect();
};
}, [ref, visible, enabled, fitWindowWidth]);
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
}
interface StreamProps {
@@ -689,6 +704,7 @@ interface StreamProps {
finding: boolean;
/** Bumped by Find in Conversation: focus the find field again. */
findFocus: number;
fontZoom: number;
onCloseFind: () => void;
}
@@ -704,7 +720,17 @@ function scrollsInside(target: EventTarget | null, root: HTMLElement): boolean {
return false;
}
function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, findFocus, onCloseFind }: StreamProps) {
function Stream({
loadError,
task,
entries,
subagent,
onOpenSubagent,
finding,
findFocus,
fontZoom,
onCloseFind,
}: StreamProps) {
const ref = useRef<HTMLDivElement>(null);
useSelectionBoundary(ref);
const [openFolds] = useState(() => new Map<string, boolean>());
@@ -799,7 +825,7 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
// 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);
useOffscreenRows(ref, visible, !finding, fitWindowWidth, fontZoom);
/** A diagram that drew after the last streamed chunk grows the conversation: keep following. */
const onDiagramDrawn = useCallback(() => {
const el = ref.current;
@@ -968,9 +994,10 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
className={clsx(styles.stream, selectableText)}
tabIndex={-1}
onWheel={(e) => {
if (e.defaultPrevented) return;
markUserScroll();
if (e.deltaY < 0 && !e.ctrlKey && !e.defaultPrevented) stopFollowing(e.target);
else if (e.deltaY > 0 && !e.ctrlKey && !e.defaultPrevented) scrollingUp.current = false;
if (e.deltaY < 0 && !e.ctrlKey && !e.metaKey) stopFollowing(e.target);
else if (e.deltaY > 0 && !e.ctrlKey && !e.metaKey) scrollingUp.current = false;
}}
onTouchStart={(e) => {
touchY.current = e.touches.length === 1 ? e.touches[0]!.clientY : null;
+39
Переглянути файл
@@ -7,6 +7,7 @@ import {
isFindRangeShown,
pathLink,
quoteText,
symbolRef,
withQuote,
} from "./conversation";
@@ -46,6 +47,44 @@ 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", () => {
+44 -1
Переглянути файл
@@ -1,5 +1,6 @@
/** Reading an agent conversation: quoting, file links, turn times and finding text. */
/** Reading an agent conversation: quoting, file and symbol 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. */
@@ -64,6 +65,48 @@ 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
Переглянути файл
@@ -0,0 +1,380 @@
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
Переглянути файл
@@ -0,0 +1,95 @@
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,6 +38,7 @@ import {
import { sendPaths, sendSelection, trackEditorCopies } from "./references";
import { focusedSession } from "./sessionFocus";
import { cycleFocusedEffort } from "./effortFocus";
import { clearAgentTabFontZoom } from "./fontZoom";
import {
closeActiveTask,
closeAndNewTask,
@@ -188,6 +189,7 @@ 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,
}),
@@ -199,6 +201,7 @@ 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.
+35 -6
Переглянути файл
@@ -1,6 +1,7 @@
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);
@@ -39,16 +40,41 @@ 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> };
export type MessageImages = {
reads: Map<string, Promise<string>>;
asked: Set<string>;
onLoaded?: () => void;
};
export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: MessageImages): () => void {
export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageImages): () => void {
const { reads, asked } = imagesState;
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}`;
@@ -62,7 +88,7 @@ export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: Mes
const { url } = target;
if (/^data:/i.test(url) || asked.has(url)) {
img.hidden = false;
img.src = url;
bindUrl(img, url, false);
} 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.
@@ -75,7 +101,7 @@ export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: Mes
asked.add(url);
load.remove();
img.hidden = false;
img.src = url;
bindUrl(img, url, true);
};
img.hidden = true;
img.before(load);
@@ -89,13 +115,16 @@ export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: Mes
void pending.catch(() => reads.delete(target.path));
}
void pending.then((url) => {
if (alive) img.src = url;
if (alive) bindUrl(img, url, true);
}, fail);
}
}
return () => {
alive = false;
for (const img of images) img.onerror = null;
for (const img of images) {
img.onload = null;
img.onerror = null;
}
for (const load of held) load.remove();
};
}
+4
Переглянути файл
@@ -20,6 +20,7 @@ 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";
@@ -518,6 +519,7 @@ export function disconnect() {
arrivedWhileLoading.clear();
streamingReply.clear();
modelFlights.clear();
resetAllAgentFontZoom();
useAgents.setState({
loaded: false,
error: null,
@@ -576,6 +578,7 @@ function onEvent(e: AgentEvent) {
organize,
...(s.docked === e.id ? { docked: null } : {}),
});
clearAgentTaskFontZoom(sessionKey(e.id));
void editorService().closeInput?.(sessionKey(e.id));
break;
}
@@ -1274,6 +1277,7 @@ export async function discardEphemeral(task: string): Promise<void> {
lastComposer: state.lastComposer === task ? HOME : state.lastComposer,
};
});
clearAgentTaskFontZoom(sessionKey(task));
void editorService().closeInput?.(sessionKey(task));
}
+81
Переглянути файл
@@ -0,0 +1,81 @@
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
Переглянути файл
@@ -0,0 +1,73 @@
/**
* 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}` };
}
+41 -14
Переглянути файл
@@ -9,6 +9,7 @@ import {
Spinner,
SymbolBadge,
Tabs,
showContextMenu,
Tree,
badgeKind,
type TreeHandle,
@@ -17,8 +18,11 @@ import {
} from "@/ui";
import { openLocation } from "./ipc";
import {
closeHierarchy,
closeHierarchyTab,
pinHierarchyTab,
ROOT_ID,
selectHierarchyTab,
tabHierarchy,
directionLabel,
hierarchyTitle,
hierarchyTarget,
@@ -54,22 +58,44 @@ useHierarchyOptions.subscribe((s) => {
}
});
/** Tool window header: `Callers of foo` content tab. */
/** Tool window header: the `Callers of foo` content tabs. */
export function HierarchyTabs() {
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);
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;
return (
<Tabs
variant="compact"
className={styles.tabs}
aria-label="Hierarchies"
items={[{ id: "current", label, closable: true }]}
activeId="current"
onSelect={() => undefined}
onClose={closeHierarchy}
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) },
]);
}}
/>
);
}
@@ -114,7 +140,7 @@ function HierarchyToolbar() {
}
export function HierarchyView() {
const { mode, direction, root, children, failed, notes, loading, generation } = useHierarchy();
const { mode, direction, root, children, failed, notes, loading, expanded, generation } = useHierarchy();
const projectRoot = useProject((s) => s.project?.root ?? "");
const roots = useMemo<Node[]>(() => (root ? [{ kind: "root", id: ROOT_ID }] : []), [root]);
@@ -224,11 +250,12 @@ export function HierarchyView() {
getChildren={getChildren}
isExpandable={isExpandable}
loadChildren={(n) => (n.kind === "item" ? loadChildren(n.node) : undefined)}
onExpandedChange={(_expanded, n, open) => {
onExpandedChange={(opened, n, open) => {
useHierarchy.setState({ expanded: [...opened] });
const shown = open ? children.get(n.id) : undefined;
if (shown) prefetchLevels(shown);
}}
defaultExpanded={[ROOT_ID]}
defaultExpanded={expanded}
handleRef={tree}
isOccurrence={() => true}
onSelectionChange={(_sel, n) => {
+42
Переглянути файл
@@ -306,3 +306,45 @@ 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 });
});
});
+111 -1
Переглянути файл
@@ -54,8 +54,27 @@ 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";
@@ -68,9 +87,89 @@ 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>();
@@ -88,7 +187,10 @@ export function resetHierarchy() {
failed: new Set(),
notes: new Map(),
loading: false,
expanded: [ROOT_ID],
generation: s.generation + 1,
tabs: [],
active: null,
}));
}
@@ -248,7 +350,14 @@ 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 });
useHierarchy.setState({
generation,
children: new Map(),
failed: new Set(),
notes: new Map(),
loading: true,
expanded: [ROOT_ID],
});
try {
const { items, incomplete } = await withDocument(root.path, (doc) =>
request(s.mode, doc, root.path, root.line, root.col, s.direction),
@@ -365,6 +474,7 @@ 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,6 +191,7 @@ 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",
+13 -1
Переглянути файл
@@ -115,7 +115,19 @@ const GENERAL = editorPage({
{
title: "Mouse Control",
items: [
{ t: "check", key: `${P}.general.wheelZoom`, label: "Change font size with Ctrl/Command+Mouse Wheel" },
{
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.dragAndDrop`, label: "Enable drag-and-drop functionality in editor" },
],
},
+6
Переглянути файл
@@ -504,6 +504,12 @@ 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
Переглянути файл
@@ -0,0 +1,83 @@
.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
Переглянути файл
@@ -0,0 +1,219 @@
/**
* 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,3 +344,13 @@
.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;
}
+60 -11
Переглянути файл
@@ -61,6 +61,7 @@ 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";
@@ -397,13 +398,14 @@ export function nodeMenu(
{
label: "Stage",
icon: "plus",
disabled: !files.some((f) => f.unstaged),
// Under Staged Changes, a partially staged file only offers Unstage.
disabled: !files.some((f) => f.unstaged) || nodes.every((n) => n.group === "staged"),
run: () => void runOp(tx`Stage ${paths.length} files`, () => call(commands.vcsStage(paths))),
},
{
label: "Unstage",
icon: "minus",
disabled: !files.some((f) => f.staged),
disabled: !files.some((f) => f.staged) || nodes.every((n) => n.group === "unstaged" || n.group === "unversioned"),
run: () => void runOp(tx`Unstage ${paths.length} files`, () => call(commands.vcsUnstage(paths))),
},
{ kind: "separator" },
@@ -430,6 +432,41 @@ 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,
@@ -466,7 +503,11 @@ function useCommitChecks() {
const root = useVcs((s) => s.root) ?? "";
const userChecks = useCommit((s) => s.checks);
const lists = useChangelists((s) => s.state);
return useMemo(() => withListDefaults(status, root, lists, userChecks), [status, root, lists, userChecks]);
const staging = useStagingArea();
return useMemo(
() => inclusionChecks(status, root, lists, userChecks, staging),
[status, root, lists, userChecks, staging],
);
}
/** Number of changes the commit would include. */
@@ -567,14 +608,17 @@ 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);
const groupByStaging = useCommit((s) => s.groupByStaging);
// 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 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 lists = useChangelists((s) => s.state);
const changelists = useChangelists((s) => s.state);
const lists = staging ? undefined : changelists;
const checks = useCommitChecks();
const checkboxes = mode !== "local";
const checkboxes = mode !== "local" && !staging;
const [dropTarget, setDropTarget] = useState<string | null>(null);
// IDEA starts with Unversioned Files collapsed.
const [collapsed, setCollapsed] = useState<Set<string>>(() => new Set(["group:unversioned"]));
@@ -709,7 +753,9 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
...(repos.length > 1
? [{ label: "Repository", checked: groupByRepo, run: () => setGroupByRepo(!groupByRepo) }]
: []),
{ label: "Staging State", checked: groupByStaging, run: () => setGroupByStaging(!groupByStaging) },
...(staging
? []
: [{ label: "Staging State", checked: groupByStaging, run: () => setGroupByStaging(!groupByStaging) }]),
...(mode === "local"
? [
{ kind: "separator" } as const,
@@ -898,13 +944,14 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
)}
{label}
{n.type === "group" && <span className={styles.detail}>{fileCount(n.files.length)}</span>}
{n.type === "file" && n.files[0] && isPartiallyStaged(n.files[0]) && (
{!staging && 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>
);
}}
@@ -1157,8 +1204,8 @@ function CommitMessageActions() {
}
/** Label of the Commit button. */
export function commitLabel(amend: boolean, problems: boolean): string {
return problems ? "Commit Anyway" : amend ? "Amend Commit" : "Commit";
export function commitLabel(amend: boolean, problems: boolean, all = false): string {
return problems ? "Commit Anyway" : amend ? "Amend Commit" : all ? "Commit All" : "Commit";
}
/** Label of the Commit and Push button. */
@@ -1175,13 +1222,15 @@ 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)}</T>
<T>{commitLabel(amend, checkProblems.length > 0, commitAll)}</T>
</Button>
{fixup ? (
<Button
+22
Переглянути файл
@@ -8,6 +8,9 @@
flex-direction: column;
background: var(--bg-app);
}
.toolbar[hidden] {
display: none;
}
.toolbar {
flex: none;
height: var(--h-header);
@@ -393,3 +396,22 @@
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;
}
+37 -11
Переглянути файл
@@ -77,6 +77,7 @@ 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";
@@ -254,6 +255,7 @@ export function DiffEditor({
onNeighbour,
onJumpToSource,
onClose,
fit = false,
}: {
input: EditorInput;
toolbarActions?: ReactNode;
@@ -267,6 +269,11 @@ 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.
@@ -296,6 +303,8 @@ 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);
@@ -527,7 +536,7 @@ export function DiffEditor({
let views: Views;
if (viewMode === "split") {
let merge: MergeView | null = null;
const panes = opts.alignChanges
const panes = aligned
? null
: new UnalignedPanes({
sync: syncScroll.current,
@@ -685,7 +694,7 @@ export function DiffEditor({
lang,
viewMode,
single,
opts.alignChanges,
aligned,
opts.collapse,
opts.ignore,
opts.highlight,
@@ -705,7 +714,8 @@ export function DiffEditor({
const views = viewsRef.current;
if (!views) return;
// Aligned panes scroll in MergeView's outer element, which scrollSnapshot does not cover.
const outer = views.merge && !views.panes ? views.merge.dom : null;
// 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 top = outer?.getBoundingClientRect().top;
const block = top == null ? null : views.b.lineBlockAtHeight(Math.max(0, top - views.b.documentTop));
const anchor =
@@ -730,14 +740,15 @@ export function DiffEditor({
});
return () => cancelAnimationFrame(frame);
}
}, [softWrap, wrapSlot]);
}, [softWrap, wrapSlot, fit]);
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(() => {
const host = rootRef.current?.closest<HTMLElement>("[data-editor-focus]");
// 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 views = viewsRef.current;
if (!host || !views) return;
const forward = () => (focusedSide.current === "a" && views.a ? views.a : views.b).focus();
@@ -747,7 +758,7 @@ export function DiffEditor({
host.addEventListener("focus", onFocus);
if (document.activeElement === host) forward();
return () => host.removeEventListener("focus", onFocus);
}, [viewsGen]);
}, [viewsGen, fit]);
useEffect(
() => () => {
@@ -1178,10 +1189,25 @@ export function DiffEditor({
{
id: "align",
label: "Align Changes",
checked: opts.alignChanges,
disabled: viewMode !== "split",
checked: aligned,
disabled: viewMode !== "split" || fit,
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] : [];
@@ -1306,7 +1332,7 @@ export function DiffEditor({
return (
<div
ref={rootRef}
className={styles.root}
className={clsx(styles.root, fit && styles.fit)}
onKeyDown={onKeyDown}
onFocusCapture={() => {
setFocusedDiffNavigator(nav.current);
@@ -1319,7 +1345,7 @@ export function DiffEditor({
}
}}
>
<div ref={toolbarRef} className={styles.toolbar} role="toolbar" aria-label={tx("Diff")}>
<div ref={toolbarRef} className={styles.toolbar} role="toolbar" aria-label={tx("Diff")} hidden={fit}>
<IconButton
icon="arrow-up"
title="Previous Difference"
@@ -1559,7 +1585,7 @@ export function DiffEditor({
className={clsx(
styles.host,
opts.highlight === "none" && styles.noHighlight,
viewMode === "split" && !opts.alignChanges && styles.unaligned,
viewMode === "split" && !aligned && styles.unaligned,
)}
hidden={!!binary || !!error || !ready}
aria-label={diffTitle(data)}
+126
Переглянути файл
@@ -0,0 +1,126 @@
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
Переглянути файл
@@ -0,0 +1,174 @@
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();
});
});
+41
Переглянути файл
@@ -0,0 +1,41 @@
/**
* All-in-one diff: every file of a change (a commit, the local changes, a comparison) in
* one scrollable editor tab instead of one tab per file. The diff viewer's settings menu
* switches it on (Show All Files in One Diff View); diffs of a chain then open this way.
*/
import type { DiffData } from "./diffInput";
export const COMBINED_DIFF_KIND = "combined-diff";
export interface CombinedDiffData {
/** The files, each with its own sides (no chain of their own). */
items: DiffData[];
/** Path of the file to scroll to when the tab opens. */
reveal?: string;
title?: string;
}
const KEY = "openidea.diff.allInOne";
/** Whether diffs of several files open as one all-in-one diff (off by default). */
export function allInOneDiff(): boolean {
try {
return localStorage.getItem(KEY) === "true";
} catch {
return false;
}
}
export function setAllInOneDiff(on: boolean) {
try {
localStorage.setItem(KEY, String(on));
} catch {
// Without storage the choice lasts for this tab only.
}
}
/** The chain of `data` as an all-in-one diff, when that view is on and the chain has several files. */
export function combinedOf(data: DiffData): CombinedDiffData | null {
if (data.embedded || !data.chain || data.chain.length < 2 || !allInOneDiff()) return null;
return { items: data.chain, reveal: data.path };
}
+5 -3
Переглянути файл
@@ -10,7 +10,8 @@ import { workflowSettings } from "@/platform/workflowSettings";
import { maybeEditorService, provideCommitService, useCommitCheckProviders } from "@/workbench/contributions";
import { commitRepos, planCommit, type CommitPlan } from "./changes";
import type { CommitProblem } from "./commitChecks";
import { useChangelists, withListDefaults } from "./changelists";
import { useChangelists } from "./changelists";
import { inclusionChecks, stagingAreaOn } from "./staging";
import { useCommit } from "./commitStore";
import { hunkKeys } from "./hunks";
import { baseName, rootOf } from "./model";
@@ -29,7 +30,8 @@ export function installDraftRevision(): () => void {
});
const offLists = useChangelists.subscribe(() => void revision++);
const offRepo = useVcs.subscribe((s, p) => {
if (s.root !== p.root) revision++;
// With the staging area the index is the inclusion: a status change may change the commit.
if (s.root !== p.root || (s.status !== p.status && stagingAreaOn())) revision++;
});
return () => {
offCommit();
@@ -41,7 +43,7 @@ export function installDraftRevision(): () => void {
/** The included changes, as the status (refreshed by the caller) and the checkboxes say. */
export function currentPlan(): CommitPlan {
const { status, root } = useVcs.getState();
const checks = withListDefaults(status, root ?? "", useChangelists.getState().state, useCommit.getState().checks);
const checks = inclusionChecks(status, root ?? "", useChangelists.getState().state, useCommit.getState().checks);
return planCommit(status, checks);
}
+15 -1
Переглянути файл
@@ -1,5 +1,6 @@
/** Diff editor inputs and helpers to open them. */
import type { ChangedFile, RevisionChange } from "@/bindings";
import { COMBINED_DIFF_KIND, combinedOf, type CombinedDiffData } from "./allInOneDiff";
import { call, commands, type LineEnding } from "@/platform/ipc";
import { workflowSettings } from "@/platform/workflowSettings";
import { editorService, type EditorInput } from "@/workbench/contributions";
@@ -148,7 +149,20 @@ export function diffTitle(data: DiffData): string {
}
export async function openDiff(data: DiffData, opts: { preview?: boolean; focus?: boolean } = {}) {
await editorService().openInput(diffInput(data), { preview: opts.preview, focus: opts.focus ?? true });
const combined = combinedOf(data);
const input = combined ? combinedDiffInput(combined) : diffInput(data);
await editorService().openInput(input, { preview: opts.preview, focus: opts.focus ?? true });
}
/** An all-in-one diff tab: one per change (the same files with the same sides). */
export function combinedDiffInput(data: CombinedDiffData): EditorInput {
const items = data.items.map(({ chain: _chain, reveal: _reveal, line: _line, lineSide: _side, ...item }) => item);
return {
kind: COMBINED_DIFF_KIND,
key: `combined-diff:${items.map(diffKey).join("\n")}`,
path: data.reveal ?? items[0]?.path ?? "",
data: { ...data, items },
};
}
/**
+3 -1
Переглянути файл
@@ -11,6 +11,7 @@ import { tx } from "@/platform/i18n";
import { commands } from "@/platform/ipc";
import { checkOf, hunkIncluded, toggledHunk } from "./changes";
import { useChangelists, withListDefaults } from "./changelists";
import { stagingAreaOn } from "./staging";
import { useCommit } from "./commitStore";
import { hunkKeys } from "./hunks";
import { statusOf, useVcs } from "./store";
@@ -33,7 +34,8 @@ const blocksField = StateField.define<Block[]>({
/** The effective inclusion of `path` (change list defaults applied). */
function inclusionOf(path: string) {
const fs = statusOf(path);
if (!fs) return null;
// With the staging area, blocks go into the commit by staging them, not by checkboxes.
if (!fs || stagingAreaOn()) return null;
const { status, root } = useVcs.getState();
const { checks, excludedHunks } = useCommit.getState();
const effective = withListDefaults(status, root ?? "", useChangelists.getState().state, checks);
+13 -1
Переглянути файл
@@ -4,6 +4,7 @@
* merge and Local History editors, remote operations.
*/
import { onWorkflowSettingsChange, workflowSettings } from "@/platform/workflowSettings";
import { COMBINED_DIFF_KIND, type CombinedDiffData } from "./allInOneDiff";
import { editorsFor, registerEditorContribution } from "@/editor/api";
import {
notifications,
@@ -159,13 +160,24 @@ export { activateDiffWindow, DiffWindow } from "./DiffWindow";
/** The diff viewer (editor kind `diff`), also for windows that show diffs without Git (deployment). */
export function activateDiffViewer(): () => void {
return registerEditorKind({
const single = registerEditorKind({
kind: DIFF_KIND,
standalone: true,
component: lazyComponent(() => import("./diff-editor-tab").then((m) => m.DiffEditorTab)),
title: (input) => diffTitle(input.data as DiffData),
icon: () => "diff",
});
const combined = registerEditorKind({
kind: COMBINED_DIFF_KIND,
standalone: true,
component: lazyComponent(() => import("./CombinedDiff").then((m) => m.CombinedDiffTab)),
title: (input) => (input.data as CombinedDiffData).title ?? tx("Combined Changes Diff"),
icon: () => "diff",
});
return () => {
single();
combined();
};
}
export function activateSettingsPages(): () => void {
+49
Переглянути файл
@@ -0,0 +1,49 @@
/**
* Staging area (Settings › Version Control › Git › Enable staging area): the Commit tool
* window works on the index instead of inclusion checkboxes and change lists. The commit
* takes what is staged; with nothing staged, Commit All takes every tracked change.
*/
import type { ChangelistState, FileStatus } from "@/bindings";
import { useWorkflowSettings, workflowSettings } from "@/platform/workflowSettings";
import { groupOf, type CheckState } from "./changes";
import { withListDefaults } from "./changelists";
const enabled = (vcs: { git: { stagingArea: boolean }; commit: { nonModal: boolean } }) =>
vcs.git.stagingArea && vcs.commit.nonModal;
/** Whether the Commit tool window works on the index (only with the non-modal commit interface). */
export const stagingAreaOn = () => enabled(workflowSettings().vcs);
export const useStagingArea = () => useWorkflowSettings((s) => enabled(s.vcs));
const staged = (f: FileStatus) => !!f.staged && f.staged !== "conflicted";
/** Nothing is staged, but tracked files changed: Commit becomes Commit All. */
export function isCommitAll(status: readonly FileStatus[]): boolean {
return !status.some(staged) && status.some((f) => groupOf(f) === "changes");
}
/**
* The inclusion the index means: staged files with their staged content, nothing else;
* with nothing staged (Commit All), every tracked change with its working-tree content.
*/
export function stagingChecks(status: readonly FileStatus[]): Map<string, CheckState> {
const all = isCommitAll(status);
const out = new Map<string, CheckState>();
for (const f of status) {
if (groupOf(f) !== "changes") continue;
out.set(f.path, all ? "all" : staged(f) ? "staged" : "none");
}
return out;
}
/** What the commit includes: the index in staging mode, else the checkboxes over the change list defaults. */
export function inclusionChecks(
status: readonly FileStatus[],
root: string,
lists: ChangelistState,
checks: ReadonlyMap<string, CheckState>,
staging = stagingAreaOn(),
): Map<string, CheckState> {
return staging ? stagingChecks(status) : withListDefaults(status, root, lists, checks);
}
+22 -4
Переглянути файл
@@ -19,9 +19,9 @@ import {
} from "react";
import clsx from "clsx";
import { call, commands, isTauri } from "@/platform/ipc";
import { useEditorPrefs } from "@/platform/editorSettings";
import { editorPrefs, useEditorPrefs } from "@/platform/editorSettings";
import { useMarkdownPreviewFontSize } from "@/platform/languageSettings";
import { maybeEditorService } from "@/workbench/contributions";
import { maybeEditorService, registerFontZoomSurface } from "@/workbench/contributions";
import { setShownLine } from "@/editor/api";
import { highlightInto } from "@/editor/lsp/markdown";
import { FloatingToolbar, selectableText } from "@/ui";
@@ -38,7 +38,7 @@ import {
selectionMatchesInNode,
setPreviewHighlight,
} from "./highlight";
import { publishPreviewSelection, publishPreviewTop, useLiveMarkdown } from "./live";
import { publishPreviewSelection, publishPreviewTop, stepMarkdownPreviewFontZoom, useLiveMarkdown } from "./live";
import { subscribeTheme, themeKey } from "@/platform/themeWatch";
import { hasMermaid, MERMAID_SELECTOR, renderMermaidIn } from "./mermaid";
import { modeOf, useMarkdownModes } from "./modes";
@@ -51,7 +51,7 @@ import {
resolveLink,
slugify,
} from "./render";
import { applyImageZoomWidth, svgDataUrlSize } from "./svgSize";
import { applyImageZoomWidth, svgDataUrlSize } from "@/ui/svgSize";
import styles from "./Markdown.module.css";
import { tx } from "@/platform/i18n";
@@ -376,6 +376,24 @@ function MarkdownPreview({ path, sync }: { path: string; sync: boolean }) {
};
}, [path]);
useEffect(() => {
const root = ref.current;
if (!root) return;
const onWheel = (e: WheelEvent) => {
if ((!e.ctrlKey && !e.metaKey) || e.deltaY === 0 || !editorPrefs().general.wheelZoom) return;
if ((e.target as Element | null)?.closest?.('.mermaid-output[data-zoomed="true"]')) return;
e.preventDefault();
e.stopPropagation();
stepMarkdownPreviewFontZoom(path, root, e.deltaY < 0 ? 1 : -1);
};
root.addEventListener("wheel", onWheel, { capture: true, passive: false });
const release = registerFontZoomSurface(root, (delta) => stepMarkdownPreviewFontZoom(path, root, delta));
return () => {
root.removeEventListener("wheel", onWheel, { capture: true });
release();
};
}, [path]);
// Preview only: the line on screen when shown, then as the user scrolls;
// cleared when the editor is back or the preview goes away.
useEffect(() => {
Loaded 100 of 119 files, more files were not shown because too many files have changed in this diff. Show more