дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-18 07:35:39 +02:00
Порівняти коміти
1
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
fd2d916bfa |
No files matched your search
@@ -208,15 +208,11 @@ jobs:
|
||||
- run: pnpm build
|
||||
|
||||
e2e:
|
||||
name: E2E (${{ matrix.shard }}/2)
|
||||
name: E2E
|
||||
needs: changes
|
||||
if: needs.changes.outputs.frontend == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-24.04
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
shard: [1, 2]
|
||||
# Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
|
||||
container: mcr.microsoft.com/playwright:v1.64.1-noble
|
||||
steps:
|
||||
@@ -226,12 +222,12 @@ jobs:
|
||||
- uses: actions/setup-node@v5
|
||||
with: { node-version: 22, cache: pnpm }
|
||||
- run: pnpm install --frozen-lockfile
|
||||
- run: pnpm e2e --shard=${{ matrix.shard }}/2
|
||||
- run: pnpm e2e
|
||||
env:
|
||||
HOME: /root
|
||||
- uses: actions/upload-artifact@v6
|
||||
if: failure()
|
||||
with:
|
||||
name: playwright-report-${{ matrix.shard }}
|
||||
name: playwright-report
|
||||
path: playwright-report/
|
||||
retention-days: 7
|
||||
@@ -262,46 +262,26 @@ jobs:
|
||||
}
|
||||
// The update's notes: the release body without its Download section. That
|
||||
// section only matters on the release page, and What's new follows it.
|
||||
// A translated section, "## 中文" added at the end of the draft before it is
|
||||
// published (it runs to the next heading of its level, or the end), becomes
|
||||
// `notes.zh-CN`: What's new shows it in that UI language and falls back to
|
||||
// `notes`, the English rest of the body. HTML comments are dropped.
|
||||
const { data: release } = await github.rest.repos.getRelease({ owner, repo, release_id });
|
||||
const languages = { "中文": "zh-CN" };
|
||||
const notesByLanguage = (body) => {
|
||||
const parts = { "": [] };
|
||||
let lang = "";
|
||||
let langLevel = 0;
|
||||
const withoutDownloadSection = (body) => {
|
||||
const kept = [];
|
||||
let skip = 0;
|
||||
for (const line of body.replace(/<!--[\s\S]*?-->/g, "").split(/\r?\n/)) {
|
||||
for (const line of body.split(/\r?\n/)) {
|
||||
const heading = /^(#{1,6})\s+(.*)$/.exec(line);
|
||||
if (heading) {
|
||||
const level = heading[1].length;
|
||||
const title = heading[2].trim();
|
||||
if (skip && level <= skip) skip = 0;
|
||||
if (lang && level <= langLevel) lang = "";
|
||||
if (!skip && level <= 3 && /^download$/i.test(title)) {
|
||||
if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
|
||||
skip = level;
|
||||
continue;
|
||||
}
|
||||
if (!skip && !lang && level <= 2 && languages[title]) {
|
||||
lang = languages[title];
|
||||
langLevel = level;
|
||||
parts[lang] ??= [];
|
||||
continue;
|
||||
}
|
||||
if (skip && level <= skip) skip = 0;
|
||||
}
|
||||
if (!skip) parts[lang].push(line);
|
||||
if (!skip) kept.push(line);
|
||||
}
|
||||
return Object.fromEntries(Object.entries(parts).map(([key, lines]) => [key, lines.join("\n").trim()]));
|
||||
};
|
||||
const { "": notes, ...translated } = notesByLanguage(String(release.body ?? ""));
|
||||
const translations = Object.fromEntries(
|
||||
Object.entries(translated).filter(([, text]) => text).map(([lang, text]) => [`notes.${lang}`, text]),
|
||||
);
|
||||
const manifest = {
|
||||
version: tag.replace(/^v/, ""), notes, ...translations, pub_date: new Date().toISOString(), platforms,
|
||||
return kept.join("\n").trim();
|
||||
};
|
||||
const notes = withoutDownloadSection(String(release.body ?? ""));
|
||||
const manifest = { version: tag.replace(/^v/, ""), notes, pub_date: new Date().toISOString(), platforms };
|
||||
const old = assets.find((a) => a.name === "latest.json");
|
||||
if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
|
||||
await github.rest.repos.uploadReleaseAsset({
|
||||
|
||||
@@ -1204,10 +1204,7 @@ impl AgentManager {
|
||||
}
|
||||
|
||||
/// What `provider` reports about itself, from `initialize` alone: no session is opened,
|
||||
/// so no MCP server, hook or sign-in runs. A successful answer is remembered until
|
||||
/// `refresh`; a failed one is not, so a transient startup failure (a CLI updating itself,
|
||||
/// a busy machine) is retried on the next call instead of being shown for the rest of
|
||||
/// the session.
|
||||
/// so no MCP server, hook or sign-in runs. Remembered until `refresh`.
|
||||
pub async fn probe(&self, provider: &str, refresh: bool) -> IdeResult<AgentProbe> {
|
||||
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
|
||||
return Ok(p.clone());
|
||||
@@ -1269,9 +1266,7 @@ impl AgentManager {
|
||||
}
|
||||
Err(e) => probe.error = Some(e),
|
||||
}
|
||||
if probe.error.is_none() {
|
||||
self.shared.probes.lock().insert(spec.id, probe.clone());
|
||||
}
|
||||
self.shared.probes.lock().insert(spec.id, probe.clone());
|
||||
Ok(probe)
|
||||
}
|
||||
|
||||
|
||||
@@ -2474,40 +2474,6 @@ async fn reload_providers_updates_registry_install_clears_stale_probes_and_notif
|
||||
assert!(probe.error.is_none());
|
||||
}
|
||||
|
||||
/// A probe that fails is not remembered, so the next new-task page tries the agent again
|
||||
/// instead of showing the same startup failure until the IDE restarts.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_failed_probe_is_retried_instead_of_remembered() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let calls = Arc::new(Mutex::new(0usize));
|
||||
let connector: Connector = {
|
||||
let calls = calls.clone();
|
||||
Arc::new(move |_spec, _cwd, _client, _stderr| {
|
||||
*calls.lock() += 1;
|
||||
Err(std::io::Error::from(std::io::ErrorKind::NotFound))
|
||||
})
|
||||
};
|
||||
let mgr = AgentManager::with_connector(
|
||||
AgentPaths {
|
||||
project_root: tmp.path().to_path_buf(),
|
||||
store_dir: tmp.path().join("store"),
|
||||
worktrees_dir: tmp.path().join("worktrees"),
|
||||
models_file: tmp.path().join("models.json"),
|
||||
custom_agents_dir: None,
|
||||
home_dir: None,
|
||||
env_secrets: None,
|
||||
catalogs: Arc::default(),
|
||||
},
|
||||
tokio::runtime::Handle::current(),
|
||||
connector,
|
||||
);
|
||||
|
||||
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
|
||||
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
|
||||
assert_eq!(*calls.lock(), 2, "the second call must start the agent again");
|
||||
assert!(!mgr.shared.probes.lock().contains_key("claude"));
|
||||
}
|
||||
|
||||
/// A session report that changes the cached provider config notifies subscribers,
|
||||
/// so the composer re-lists models without waiting for the next task (#1490).
|
||||
/// Reports that change nothing stay silent.
|
||||
|
||||
@@ -12,8 +12,6 @@ use std::collections::BTreeMap;
|
||||
pub struct EditorGeneralSettings {
|
||||
/// Change font size with ⌘ + mouse wheel.
|
||||
pub wheel_zoom: bool,
|
||||
/// Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors.
|
||||
pub wheel_zoom_scope: String,
|
||||
pub markdown_image_folder: String,
|
||||
pub markdown_image_name_pattern: String,
|
||||
/// Drag-and-drop of selected text inside the editor.
|
||||
@@ -39,7 +37,6 @@ impl Default for EditorGeneralSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
wheel_zoom: false,
|
||||
wheel_zoom_scope: "active".into(),
|
||||
markdown_image_folder: "assets".into(),
|
||||
markdown_image_name_pattern: "image-{timestamp}".into(),
|
||||
drag_and_drop: true,
|
||||
|
||||
@@ -69,9 +69,6 @@ pub struct GitSettings {
|
||||
pub push_dialog_only_protected: bool,
|
||||
/// Stashes and shelves share one tab.
|
||||
pub combine_stash_and_shelf: bool,
|
||||
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
|
||||
/// stage and unstage instead of inclusion checkboxes, and no change lists.
|
||||
pub staging_area: bool,
|
||||
}
|
||||
|
||||
impl Default for GitSettings {
|
||||
@@ -93,7 +90,6 @@ impl Default for GitSettings {
|
||||
show_push_dialog: true,
|
||||
push_dialog_only_protected: false,
|
||||
combine_stash_and_shelf: false,
|
||||
staging_area: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,252 +0,0 @@
|
||||
//! HTTP Client tools: list and run requests from project `.http` / `.rest` files.
|
||||
|
||||
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde_json::json;
|
||||
use std::path::Path;
|
||||
|
||||
/// Response body characters returned at most (keeps agent context bounded).
|
||||
const MAX_BODY_CHARS: usize = 8_192;
|
||||
|
||||
pub fn tools() -> Vec<Tool> {
|
||||
vec![http_list_requests(), http_run_request()]
|
||||
}
|
||||
|
||||
fn is_http_file(path: &Path) -> bool {
|
||||
path.extension()
|
||||
.and_then(|e| e.to_str())
|
||||
.is_some_and(|e| e.eq_ignore_ascii_case("http") || e.eq_ignore_ascii_case("rest"))
|
||||
}
|
||||
|
||||
async fn resolve_http_file(call: &Call, path: &str) -> IdeResult<std::path::PathBuf> {
|
||||
let path = call.resolve_inside(path)?;
|
||||
if !is_http_file(&path) {
|
||||
return Err(IdeError::invalid("path must be a .http or .rest file"));
|
||||
}
|
||||
if !path.is_file() {
|
||||
return Err(IdeError::not_found(format!("No such file: {}", call.display(&path))));
|
||||
}
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
fn http_list_requests() -> Tool {
|
||||
Tool::new(
|
||||
"http_list_requests",
|
||||
"Lists the HTTP requests in a project `.http` or `.rest` file (IntelliJ-style HTTP Client).
|
||||
Returns each request's 0-based `index`, optional `name`, `method`, URL as written (variables not substituted), and `line`.
|
||||
Use `http_run_request` with the same `path` and an `index` to send one.",
|
||||
|call| async move {
|
||||
let path = resolve_http_file(&call, &call.str("path")?).await?;
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
|
||||
let requests: Vec<_> = ide_http::parse::requests(&text)
|
||||
.into_iter()
|
||||
.map(|b| {
|
||||
json!({
|
||||
"index": b.index,
|
||||
"name": b.name,
|
||||
"method": b.method,
|
||||
"url": b.url,
|
||||
"line": b.line,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Output::json(json!({ "requests": requests }))
|
||||
},
|
||||
)
|
||||
.param(Param::required(
|
||||
"path",
|
||||
ParamType::String,
|
||||
"Project-relative path to a `.http` or `.rest` file",
|
||||
))
|
||||
.output(json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"requests": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"index": { "type": "integer" },
|
||||
"name": { "type": ["string", "null"] },
|
||||
"method": { "type": "string" },
|
||||
"url": { "type": "string" },
|
||||
"line": { "type": "integer" },
|
||||
},
|
||||
"required": ["index", "method", "url", "line"],
|
||||
},
|
||||
},
|
||||
},
|
||||
"required": ["requests"],
|
||||
}))
|
||||
}
|
||||
|
||||
fn truncate_chars(text: &str, max: usize) -> (String, bool) {
|
||||
let count = text.chars().count();
|
||||
if count <= max {
|
||||
return (text.to_owned(), false);
|
||||
}
|
||||
(text.chars().take(max).collect(), true)
|
||||
}
|
||||
|
||||
/// Drop resolved URLs from transport errors so MCP JSON does not echo env-substituted targets.
|
||||
fn redact_transport_error(error: Option<String>, resolved_url: &str) -> Option<String> {
|
||||
let error = error?;
|
||||
let mut out = error.replace(resolved_url, "<url>");
|
||||
// reqwest often embeds `https://host/...` even when the primary URL string differs slightly.
|
||||
out = redact_urls(&out);
|
||||
Some(out)
|
||||
}
|
||||
|
||||
fn redact_urls(s: &str) -> String {
|
||||
let mut out = String::with_capacity(s.len());
|
||||
let mut rest = s;
|
||||
loop {
|
||||
// Prefer `https://` so we don't match the `http://` prefix inside it.
|
||||
let start = match (rest.find("https://"), rest.find("http://")) {
|
||||
(Some(a), Some(b)) => Some(a.min(b)),
|
||||
(Some(a), None) => Some(a),
|
||||
(None, Some(b)) => Some(b),
|
||||
(None, None) => None,
|
||||
};
|
||||
let Some(start) = start else {
|
||||
out.push_str(rest);
|
||||
break;
|
||||
};
|
||||
out.push_str(&rest[..start]);
|
||||
out.push_str("<url>");
|
||||
let after = &rest[start..];
|
||||
let end = after.find(|c: char| c.is_whitespace() || c == '\'' || c == '"' || c == ')').unwrap_or(after.len());
|
||||
rest = &after[end..];
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn http_run_request() -> Tool {
|
||||
Tool::new(
|
||||
"http_run_request",
|
||||
"Runs one request from a project `.http` or `.rest` file by 0-based `index`, using the IDE HTTP Client
|
||||
(same as Run Request in the editor). Variables resolve from `http-client.env.json` / `http-client.private.env.json`
|
||||
for the optional `env` name. Asks for confirmation with the resolved URL (and header names) first.
|
||||
Returns status, timing and a truncated response body — not request headers or body (those may hold secrets).
|
||||
The `url` field in the result is as written in the file (unsubstituted); transport errors redact URLs.",
|
||||
|call| async move {
|
||||
let rel = call.str("path")?;
|
||||
let path = resolve_http_file(&call, &rel).await?;
|
||||
let index =
|
||||
call.opt_i64("index")?.ok_or_else(|| IdeError::invalid("missing or invalid argument `index`"))?;
|
||||
if index < 0 {
|
||||
return Err(IdeError::invalid("index must be >= 0"));
|
||||
}
|
||||
let index = index as u32;
|
||||
let env = call.opt_str("env")?;
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
|
||||
let blocks = ide_http::parse::requests(&text);
|
||||
let block =
|
||||
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
|
||||
|
||||
let input = ide_http::RunInput {
|
||||
text: &text,
|
||||
index,
|
||||
file: Some(&path),
|
||||
root: Some(call.root()),
|
||||
env: env.as_deref(),
|
||||
};
|
||||
// Prepare before confirm so the dialog shows the real destination (after env substitution).
|
||||
let prepared = ide_http::prepare(&input)?;
|
||||
let subject = prepared.name.clone().unwrap_or_else(|| format!("{} {}", prepared.method, prepared.url));
|
||||
let headers: Vec<_> = prepared.headers.iter().map(|(k, _)| k.as_str()).collect();
|
||||
let mut detail = format!("{} {}\nFile: {rel}\nIndex: {index}", prepared.method, prepared.url);
|
||||
if let Some(env) = &env {
|
||||
detail.push_str(&format!("\nEnvironment: {env}"));
|
||||
}
|
||||
if !headers.is_empty() {
|
||||
detail.push_str(&format!("\nHeaders: {}", headers.join(", ")));
|
||||
}
|
||||
if prepared.body.is_some() {
|
||||
detail.push_str("\nBody: present");
|
||||
}
|
||||
call.confirm(&subject, Some(detail)).await?;
|
||||
|
||||
let exchange = ide_http::run(input, &call.cancel).await?;
|
||||
let history = call.project().http_history.clone();
|
||||
let saved = exchange.clone();
|
||||
let _ = call.host().blocking(move || history.add(&saved)).await;
|
||||
|
||||
let (body, body_truncated) = match exchange.response.as_ref().and_then(|r| r.body.as_deref()) {
|
||||
Some(b) => {
|
||||
let (t, truncated) = truncate_chars(b, MAX_BODY_CHARS);
|
||||
(Some(t), truncated)
|
||||
}
|
||||
None => (None, false),
|
||||
};
|
||||
let response = exchange.response.as_ref();
|
||||
Output::json(json!({
|
||||
"index": index,
|
||||
"name": block.name,
|
||||
"method": block.method,
|
||||
"url": block.url,
|
||||
"status": response.map(|r| r.status),
|
||||
"statusText": response.map(|r| r.status_text.clone()),
|
||||
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
|
||||
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
|
||||
"body": body,
|
||||
"bodyTruncated": body_truncated,
|
||||
}))
|
||||
},
|
||||
)
|
||||
.write()
|
||||
.param(Param::required("path", ParamType::String, "Project-relative path to a `.http` or `.rest` file"))
|
||||
.param(Param::required("index", ParamType::Integer, "0-based request index from `http_list_requests`"))
|
||||
.param(Param::optional(
|
||||
"env",
|
||||
ParamType::String,
|
||||
"Environment name from `http-client.env.json` / `http-client.private.env.json`",
|
||||
))
|
||||
.output(json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"index": { "type": "integer" },
|
||||
"name": { "type": ["string", "null"] },
|
||||
"method": { "type": "string" },
|
||||
"url": { "type": "string" },
|
||||
"status": { "type": ["integer", "null"] },
|
||||
"statusText": { "type": ["string", "null"] },
|
||||
"totalMs": { "type": ["number", "null"] },
|
||||
"error": { "type": ["string", "null"] },
|
||||
"body": { "type": ["string", "null"] },
|
||||
"bodyTruncated": { "type": "boolean" },
|
||||
},
|
||||
"required": ["index", "method", "url", "bodyTruncated"],
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn accepts_http_and_rest_extensions() {
|
||||
assert!(is_http_file(Path::new("a.http")));
|
||||
assert!(is_http_file(Path::new("a.REST")));
|
||||
assert!(!is_http_file(Path::new("a.txt")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn truncates_long_bodies() {
|
||||
let long = "x".repeat(MAX_BODY_CHARS + 10);
|
||||
let (t, truncated) = truncate_chars(&long, MAX_BODY_CHARS);
|
||||
assert!(truncated);
|
||||
assert_eq!(t.chars().count(), MAX_BODY_CHARS);
|
||||
assert_eq!(truncate_chars("ok", MAX_BODY_CHARS), ("ok".into(), false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn redacts_urls_in_transport_errors() {
|
||||
let url = "https://secret.example/v1?token=abc";
|
||||
assert_eq!(
|
||||
redact_transport_error(Some(format!("error sending request for {url}")), url).as_deref(),
|
||||
Some("error sending request for <url>")
|
||||
);
|
||||
assert_eq!(redact_urls("fail https://a.example/x and http://b/y"), "fail <url> and <url>");
|
||||
}
|
||||
}
|
||||
@@ -7,7 +7,6 @@ pub(crate) mod run;
|
||||
mod vcs;
|
||||
pub use requests::Requests;
|
||||
mod files;
|
||||
mod http;
|
||||
mod page;
|
||||
mod reports;
|
||||
mod search;
|
||||
@@ -40,7 +39,6 @@ fn tools() -> Vec<tool::Tool> {
|
||||
tools.extend(edit::tools());
|
||||
tools.extend(run::tools());
|
||||
tools.extend(vcs::tools());
|
||||
tools.extend(http::tools());
|
||||
tools
|
||||
}
|
||||
|
||||
|
||||
@@ -1057,11 +1057,6 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
|
||||
blocking(move || apply_edit(&documents, &edit)).await?;
|
||||
}
|
||||
open_plugin_action_target(&action, window);
|
||||
if let Some(command) = &action.command
|
||||
&& let Some(result) = run_plugin_server_command(host, window, doc, None, command).await
|
||||
{
|
||||
return result;
|
||||
}
|
||||
if let Some(command) = action.command
|
||||
&& !(action.edit.is_some() && is_client_follow_up(&project, doc, None, &command).await)
|
||||
{
|
||||
@@ -1613,47 +1608,9 @@ pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command:
|
||||
return blocking(move || plugins.run_language_command(&plugin, &command_id, argument.as_deref(), invocation))
|
||||
.await;
|
||||
}
|
||||
if let Some(result) = run_plugin_server_command(host, window, doc, None, &command).await {
|
||||
return result;
|
||||
}
|
||||
host.project(window)?.lsp.execute_command(doc, command).await
|
||||
}
|
||||
|
||||
/// Runs `command` through the plugin that claims it (`[[contributes.serverCommands]]`)
|
||||
/// when no server of the document executes it itself: a code lens, code action or inlay
|
||||
/// hint may carry a command the server leaves to the client. `None` when no plugin does.
|
||||
async fn run_plugin_server_command(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
doc: DocId,
|
||||
server: Option<ServerId>,
|
||||
command: &Command,
|
||||
) -> Option<IdeResult<()>> {
|
||||
let plugins = crate::plugins::editor_plugin_host()?;
|
||||
let project = host.project(window).ok()?;
|
||||
if project.lsp.provides_command(doc, server, &command.command).await {
|
||||
return None;
|
||||
}
|
||||
let (plugin, run) = plugins.server_command(&project.lsp.server_names(doc, server), &command.command)?;
|
||||
let snap = match project.documents.snapshot(doc) {
|
||||
Ok(snap) => snap,
|
||||
Err(e) => return Some(Err(e)),
|
||||
};
|
||||
let invocation = ide_plugin::Invocation {
|
||||
client: Some(window.into()),
|
||||
workspace_root: Some(project.root.clone()),
|
||||
editor: Some(ide_plugin::EditorContext {
|
||||
path: snap.path.0.clone(),
|
||||
language: snap.language.0,
|
||||
selections: vec![],
|
||||
}),
|
||||
selected_paths: vec![snap.path.0],
|
||||
..Default::default()
|
||||
};
|
||||
let arguments = serde_json::Value::Array(command.arguments.clone()).to_string();
|
||||
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
|
||||
}
|
||||
|
||||
/// Resolves an interactive command without applying edits or executing it.
|
||||
pub async fn lsp_resolve_command(
|
||||
host: &Host,
|
||||
@@ -1695,11 +1652,6 @@ pub async fn lsp_execute_code_action(
|
||||
.await
|
||||
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
|
||||
}
|
||||
if let Some(command) = &action.command
|
||||
&& let Some(result) = run_plugin_server_command(host, window, doc, Some(action.server), command).await
|
||||
{
|
||||
return result.map(|()| Vec::new());
|
||||
}
|
||||
match action.command {
|
||||
Some(command) if edited && is_client_follow_up(&project, doc, Some(action.server), &command).await => {
|
||||
Ok(Vec::new())
|
||||
|
||||
@@ -54,9 +54,8 @@ pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<Extensi
|
||||
Ok(host.project(window)?.index.file_extensions())
|
||||
}
|
||||
|
||||
pub async fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.find_files(&query, limit as usize))).await
|
||||
pub fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
Ok(host.project(window)?.index.find_files(&query, limit as usize))
|
||||
}
|
||||
|
||||
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
|
||||
@@ -64,33 +63,18 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
|
||||
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
|
||||
}
|
||||
|
||||
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.find_dirs(&query, limit as usize))).await
|
||||
pub fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
Ok(host.project(window)?.index.find_dirs(&query, limit as usize))
|
||||
}
|
||||
|
||||
pub async fn find_symbols(
|
||||
pub fn find_symbols(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
query: String,
|
||||
filter: SymbolFilter,
|
||||
limit: u32,
|
||||
) -> IdeResult<Vec<SymbolMatch>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.find_symbols(&query, filter, limit as usize))).await
|
||||
}
|
||||
|
||||
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder),
|
||||
/// at most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
|
||||
pub async fn find_symbols_named(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
names: Vec<String>,
|
||||
within: IpcPath,
|
||||
) -> IdeResult<Vec<SymbolMatch>> {
|
||||
const SYMBOLS_PER_NAME: usize = 50;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.symbols_named_any(&names, &PathBuf::from(within), SYMBOLS_PER_NAME))).await
|
||||
Ok(host.project(window)?.index.find_symbols(&query, filter, limit as usize))
|
||||
}
|
||||
|
||||
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
@@ -334,14 +318,11 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
|
||||
d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
|
||||
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
|
||||
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
|
||||
d.add("find_files_named", |c| async move { find_files_named(&c.host, &c.window, c.arg("name")?).await });
|
||||
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
|
||||
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
|
||||
d.add("find_symbols", |c| async move {
|
||||
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?).await
|
||||
});
|
||||
d.add("find_symbols_named", |c| async move {
|
||||
find_symbols_named(&c.host, &c.window, c.arg("names")?, c.arg("within")?).await
|
||||
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
|
||||
});
|
||||
d.add("mark_recent", |c| async move { mark_recent(&c.host, &c.window, c.arg("path")?) });
|
||||
d.add("remove_recent", |c| async move { remove_recent(&c.host, &c.window, c.arg("path")?) });
|
||||
|
||||
@@ -313,35 +313,6 @@ impl PluginHost {
|
||||
}
|
||||
}
|
||||
|
||||
impl PluginHost {
|
||||
/// The plugin command that runs `command`, which one of the language servers
|
||||
/// `servers` handed to the client (`[[contributes.serverCommands]]`): the plugin
|
||||
/// and its command id. A plugin counts while it holds `lsp:<server>`; when several
|
||||
/// claim the same server and command, the first one loaded keeps it.
|
||||
pub(crate) fn server_command(&self, servers: &[String], command: &str) -> Option<(String, String)> {
|
||||
let mut claims = self.ui.items(super::ui_points::SERVER_COMMANDS, None).into_iter().filter_map(|item| {
|
||||
let decl: super::ui_points::ServerCommandDecl = serde_json::from_value(item.decl).ok()?;
|
||||
let claimed = decl.command == command && servers.contains(&decl.server);
|
||||
let grant = ide_extension::Capability::Lsp(decl.server.clone());
|
||||
let granted = claimed
|
||||
&& self.get(&item.plugin_id).is_ok_and(|p| p.meta.lock().granted.iter().any(|g| g.covers(&grant)));
|
||||
granted.then_some((item.plugin_id, decl.server, decl.run))
|
||||
});
|
||||
let (plugin, server, run) = claims.next()?;
|
||||
for (other, _, _) in claims.filter(|(other, s, _)| *other != plugin && *s == server) {
|
||||
static LOGGED: parking_lot::Mutex<std::collections::BTreeSet<(String, String, String)>> =
|
||||
parking_lot::Mutex::new(std::collections::BTreeSet::new());
|
||||
if LOGGED.lock().insert((other.clone(), server.clone(), command.to_owned())) {
|
||||
tracing::warn!(
|
||||
"plugins {plugin} and {other} both claim command `{command}` of language server {server}; \
|
||||
{plugin} was loaded first and keeps it"
|
||||
);
|
||||
}
|
||||
}
|
||||
Some((plugin, run))
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn signature_help(h: SignatureHelp) -> ide_lsp::types::SignatureHelp {
|
||||
let signatures: Vec<_> = h
|
||||
.signatures
|
||||
|
||||
@@ -93,7 +93,6 @@ pub fn register_builtin_points(
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::COMMIT_CHECKS, ui.clone(), p::commit_check)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::SERVER_COMMANDS, ui.clone(), p::server_command)))?;
|
||||
registry.register(Arc::new(UiPoint::new(ide_extension::LOCALES_POINT, ui.clone(), p::locales)))?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -46,11 +46,6 @@
|
||||
//! id = "conventional"
|
||||
//! title = "Conventional Commits" # Commit Options › Before Commit; `commit-checker.check` runs it
|
||||
//!
|
||||
//! [[contributes.serverCommands]]
|
||||
//! server = "phoxite" # the language server whose results carry the command
|
||||
//! command = "laravel.modelView" # a command the server leaves to the client
|
||||
//! run = "model-view" # this plugin's command; needs `lsp:phoxite`
|
||||
//!
|
||||
//! [[contributes.fileTemplates]]
|
||||
//! id = "drawing"
|
||||
//! name = "Excalidraw Drawing"
|
||||
@@ -77,7 +72,6 @@ pub const FILE_ICONS: &str = "fileIcons";
|
||||
pub const MARKER_ICONS: &str = "markerIcons";
|
||||
pub const FILE_TEMPLATES: &str = "fileTemplates";
|
||||
pub const COMMIT_CHECKS: &str = "commitChecks";
|
||||
pub const SERVER_COMMANDS: &str = "serverCommands";
|
||||
|
||||
const VIEW_ITEM_MENU: &str = "viewItem.context";
|
||||
/// The toolbar above the commit message (Commit tool window and dialog).
|
||||
@@ -970,37 +964,6 @@ pub(super) fn commit_check(pkg: &Package, decl: toml::Value) -> Result<UiDecl, S
|
||||
Ok(UiDecl::new(d.id.clone(), d.title.clone(), json(&d)?))
|
||||
}
|
||||
|
||||
/// A command a language server's code lens, code action or inlay hint carries and
|
||||
/// leaves to the client, and the plugin command that runs it.
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub(super) struct ServerCommandDecl {
|
||||
/// The server's name in its language definition.
|
||||
pub(super) server: String,
|
||||
pub(super) command: String,
|
||||
/// The plugin's command (`[[contributes.commands]]`); it gets the arguments as JSON.
|
||||
pub(super) run: String,
|
||||
}
|
||||
|
||||
/// `[[contributes.serverCommands]]` (API 1.9): routes a command no server executes
|
||||
/// itself to the plugin's own command.
|
||||
pub(super) fn server_command(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
|
||||
let d: ServerCommandDecl = decode(SERVER_COMMANDS, decl)?;
|
||||
pkg.manifest.needs_api(&format!("contributes.{SERVER_COMMANDS}"), 9)?;
|
||||
if d.command.is_empty() || d.command.len() > 256 {
|
||||
return Err(format!("contributes.{SERVER_COMMANDS}: command names are 1–256 bytes"));
|
||||
}
|
||||
declared_command(pkg, SERVER_COMMANDS, &d.run)?;
|
||||
let grant: ide_extension::Capability =
|
||||
format!("lsp:{}", d.server).parse().map_err(|e| format!("contributes.{SERVER_COMMANDS}: {e}"))?;
|
||||
if !pkg.manifest.capabilities.all().any(|c| *c == grant) {
|
||||
return Err(format!(
|
||||
"contributes.{SERVER_COMMANDS}: needs the `{grant}` capability (the command comes from that server)"
|
||||
));
|
||||
}
|
||||
Ok(UiDecl::new(format!("{}:{}", d.server, d.command), d.command.clone(), json(&d)?))
|
||||
}
|
||||
|
||||
const MAX_CATALOG_ENTRIES: usize = 20_000;
|
||||
|
||||
pub fn locale_asset(tag: &str) -> String {
|
||||
|
||||
@@ -500,7 +500,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
|
||||
| "find_files_named"
|
||||
| "find_dirs"
|
||||
| "find_symbols"
|
||||
| "find_symbols_named"
|
||||
| "mark_recent"
|
||||
| "remove_recent"
|
||||
| "recent_files"
|
||||
|
||||
@@ -697,76 +697,3 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
|
||||
let interrupted = h.json("wait_for_run", json!({"name": "interrupt", "timeout": 10000})).await;
|
||||
assert_eq!(interrupted["state"], "stoppedByAgent", "{interrupted}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn http_list_and_run_require_confirmation() {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
|
||||
let h = Harness::new();
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
tokio::spawn(async move {
|
||||
let (mut socket, _) = listener.accept().await.unwrap();
|
||||
let mut buf = [0u8; 1024];
|
||||
let _ = socket.read(&mut buf).await;
|
||||
let body = b"{\"ok\":true}";
|
||||
let response = format!(
|
||||
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
|
||||
body.len(),
|
||||
std::str::from_utf8(body).unwrap()
|
||||
);
|
||||
let _ = socket.write_all(response.as_bytes()).await;
|
||||
});
|
||||
|
||||
std::fs::write(
|
||||
h.root.join("api.http"),
|
||||
format!(
|
||||
"### Health\nGET http://{addr}/health\nAccept: application/json\n\n### Echo\n# @name echo\nGET http://{addr}/echo\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(h.root.join("http-client.env.json"), r#"{"dev":{"unused":"x"}}"#).unwrap();
|
||||
|
||||
let listed = h.json("http_list_requests", json!({"path": "api.http"})).await;
|
||||
assert_eq!(listed["requests"].as_array().unwrap().len(), 2, "{listed}");
|
||||
assert_eq!(listed["requests"][0]["index"], 0);
|
||||
assert_eq!(listed["requests"][0]["name"], "Health");
|
||||
assert_eq!(listed["requests"][0]["method"], "GET");
|
||||
assert_eq!(listed["requests"][1]["name"], "echo");
|
||||
assert!(listed["requests"][0]["url"].as_str().unwrap().contains("/health"));
|
||||
|
||||
// Write tool is hidden until the project is trusted.
|
||||
assert!(Registry::new(h.host.clone()).tools(&h.root).unwrap().iter().all(|t| t.name != "http_run_request"));
|
||||
h.trust().await;
|
||||
assert!(
|
||||
Registry::new(h.host.clone())
|
||||
.tools(&h.root)
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|t| t.name == "http_run_request" && !t.read_only)
|
||||
);
|
||||
|
||||
h.host.mcp_requests.set_ready("main", true);
|
||||
let denied = h.error("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
|
||||
let deny = async {
|
||||
let id = h.request().await;
|
||||
h.host.mcp_requests.answer("main", id, false, None).unwrap();
|
||||
};
|
||||
let (error, ()) = tokio::join!(denied, deny);
|
||||
assert!(error.contains("denied by the user"), "{error}");
|
||||
|
||||
h.events.lock().unwrap().clear();
|
||||
let run = h.json("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
|
||||
let allow = async {
|
||||
let id = h.request().await;
|
||||
h.host.mcp_requests.answer("main", id, true, None).unwrap();
|
||||
};
|
||||
let (result, ()) = tokio::join!(run, allow);
|
||||
assert_eq!(result["status"], 200, "{result}");
|
||||
assert_eq!(result["method"], "GET");
|
||||
assert!(result["body"].as_str().unwrap().contains("ok"), "{result}");
|
||||
assert_eq!(result["bodyTruncated"], false);
|
||||
// Secrets must not appear as request headers/body in the tool payload.
|
||||
assert!(result.get("headers").is_none(), "{result}");
|
||||
assert!(result.get("request").is_none(), "{result}");
|
||||
}
|
||||
@@ -1,184 +0,0 @@
|
||||
//! `[[contributes.serverCommands]]` (plugin API 1.9): a command a language server hands to the
|
||||
//! client runs the plugin command that claims it. The fixture's command sends its argument
|
||||
//! back to the server (`mock/ran`), through the real component runtime and `language-servers`.
|
||||
use ide_host::plugins::{Consent, HostWorkspace, PluginHost, set_editor_providers};
|
||||
use ide_host::{Host, HostConfig, ops};
|
||||
use ide_jsonrpc::{Handler, Peer};
|
||||
use ide_lsp::types::Command;
|
||||
use ide_plugin::Limits;
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
use std::{path::Path, sync::Arc, time::Duration};
|
||||
|
||||
const ID: &str = "test.lsp-requests";
|
||||
const SECOND: &str = "test.lsp-second";
|
||||
|
||||
fn fixture() -> std::path::PathBuf {
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/lsp-requests")
|
||||
}
|
||||
|
||||
/// The fixture under `dir` with `edit` applied to its manifest.
|
||||
fn variant(dir: &Path, edit: impl Fn(&str) -> String) -> std::path::PathBuf {
|
||||
fn copy(from: &Path, to: &Path) {
|
||||
std::fs::create_dir_all(to).unwrap();
|
||||
for entry in std::fs::read_dir(from).unwrap() {
|
||||
let entry = entry.unwrap();
|
||||
match entry.file_type().unwrap().is_dir() {
|
||||
true if entry.file_name() != "target" => copy(&entry.path(), &to.join(entry.file_name())),
|
||||
true => {}
|
||||
false => drop(std::fs::copy(entry.path(), to.join(entry.file_name())).unwrap()),
|
||||
}
|
||||
}
|
||||
}
|
||||
copy(&fixture(), dir);
|
||||
let manifest = dir.join("plugin.toml");
|
||||
std::fs::write(&manifest, edit(&std::fs::read_to_string(&manifest).unwrap())).unwrap();
|
||||
dir.to_path_buf()
|
||||
}
|
||||
|
||||
/// A language server named `mock`: it executes `mock.own` itself and records what it gets.
|
||||
#[derive(Default)]
|
||||
struct Mock {
|
||||
requests: Mutex<Vec<(String, Value)>>,
|
||||
notifications: Mutex<Vec<(String, Value)>>,
|
||||
}
|
||||
|
||||
impl Mock {
|
||||
fn ran(&self) -> Vec<Value> {
|
||||
self.notifications.lock().iter().filter(|(m, _)| m == "mock/ran").map(|(_, p)| p.clone()).collect()
|
||||
}
|
||||
fn executed(&self) -> Vec<Value> {
|
||||
let requests = self.requests.lock();
|
||||
requests.iter().filter(|(m, _)| m == "workspace/executeCommand").map(|(_, p)| p["command"].clone()).collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl Handler for Mock {
|
||||
fn on_notification(&self, method: &str, p: Value) {
|
||||
self.notifications.lock().push((method.to_owned(), p));
|
||||
}
|
||||
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
|
||||
self.requests.lock().push((method.to_owned(), p));
|
||||
Ok(match method {
|
||||
"initialize" => json!({ "capabilities": {
|
||||
"textDocumentSync": { "openClose": true, "change": 1 },
|
||||
"executeCommandProvider": { "commands": ["mock.own"] },
|
||||
} }),
|
||||
_ => Value::Null,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
async fn eventually(what: &str, mut f: impl FnMut() -> bool) {
|
||||
for _ in 0..500 {
|
||||
if f() {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
panic!("timed out waiting for {what}");
|
||||
}
|
||||
|
||||
fn command(name: &str, arguments: Vec<Value>) -> Command {
|
||||
Command { title: "Lens".into(), command: name.into(), arguments }
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_command_the_server_leaves_to_the_client_runs_the_plugin_that_claims_it() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
|
||||
std::fs::create_dir(&root).unwrap();
|
||||
let host = Arc::new(Host::new(HostConfig {
|
||||
config_dir: tmp.path().join("config"),
|
||||
data_dir: tmp.path().join("data"),
|
||||
local_data_dir: tmp.path().join("local"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(ide_core::NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
}));
|
||||
// Language servers start only in a trusted project.
|
||||
host.set_project_trust(&root, true, false).await.unwrap();
|
||||
host.open_project("main", &root).unwrap();
|
||||
let plugins = Arc::new(
|
||||
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
|
||||
);
|
||||
plugins.set_workspace(Some(Arc::new(HostWorkspace(Arc::downgrade(&host)))));
|
||||
set_editor_providers(Some(&plugins));
|
||||
|
||||
// The manifest must hold the grant of the server whose commands it claims.
|
||||
let ungranted = variant(&tmp.path().join("ungranted"), |m| m.replace("optional = [\"lsp:mock\"]", "optional = []"));
|
||||
let err = plugins.install_from_dir(&ungranted, &Consent::all()).unwrap_err();
|
||||
assert!(err.message.contains("needs the `lsp:mock` capability"), "{err:?}");
|
||||
plugins.install_from_dir(&fixture(), &Consent::all()).unwrap();
|
||||
|
||||
// The server `mock` serves the project's text files.
|
||||
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let mock = Arc::new(Mock::default());
|
||||
let peers = Arc::new(Mutex::new(Vec::<Peer>::new()));
|
||||
let (accepted, state) = (peers.clone(), mock.clone());
|
||||
let server = tokio::spawn(async move {
|
||||
while let Ok((stream, _)) = listener.accept().await {
|
||||
let (r, w) = stream.into_split();
|
||||
accepted.lock().push(Peer::connect(r, w, state.clone()));
|
||||
}
|
||||
});
|
||||
let cfg: ide_language::LanguageServerConfig =
|
||||
toml::from_str(&format!("name='mock'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
|
||||
let project = host.project("main").unwrap();
|
||||
project.lsp.set_servers_hook(Box::new(move |_, _| vec![cfg.clone()]));
|
||||
let path = root.join("a.txt");
|
||||
std::fs::write(&path, "class Post {}\n").unwrap();
|
||||
let doc = ops::doc::open(&host, "main", path.clone()).await.unwrap().id;
|
||||
project.lsp.did_open(
|
||||
doc,
|
||||
&path,
|
||||
&ide_core::LanguageId::plain_text(),
|
||||
0,
|
||||
"class Post {}
|
||||
",
|
||||
);
|
||||
eventually("the server to be ready", || {
|
||||
project.lsp.servers().iter().any(|s| s.name == "mock" && s.status == ide_core::event::ServerStatus::Ready)
|
||||
})
|
||||
.await;
|
||||
|
||||
// A lens command the server does not execute: the plugin's command gets the arguments as JSON.
|
||||
let lens = command("mock.modelView", vec![json!("App\\Models\\Post"), json!({ "line": 3 })]);
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
|
||||
eventually("the plugin's command", || !mock.ran().is_empty()).await;
|
||||
assert_eq!(mock.ran(), [json!(["App\\Models\\Post", { "line": 3 }])]);
|
||||
assert!(mock.executed().is_empty(), "the server was not asked to execute it");
|
||||
|
||||
// A command in the server's `executeCommandProvider` still goes to the server.
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.own", vec![])).await.unwrap();
|
||||
assert_eq!(mock.executed(), [json!("mock.own")]);
|
||||
assert_eq!(mock.ran().len(), 1);
|
||||
|
||||
// A command nobody claims fails as before.
|
||||
let err = ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.unclaimed", vec![])).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
|
||||
|
||||
// Two plugins claim the same server and command: the first one loaded keeps it.
|
||||
let second = variant(&tmp.path().join("second"), |m| m.replace(ID, SECOND));
|
||||
plugins.install_from_dir(&second, &Consent::all()).unwrap();
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
|
||||
eventually("the first plugin's command again", || mock.ran().len() == 2).await;
|
||||
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 0, "the second plugin never ran");
|
||||
|
||||
// A claim counts only while the plugin holds the server's grant.
|
||||
plugins.set_capability(ID, "lsp:mock", false).unwrap();
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
|
||||
eventually("the second plugin's command", || mock.ran().len() == 3).await;
|
||||
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 1);
|
||||
plugins.set_capability(SECOND, "lsp:mock", false).unwrap();
|
||||
let err = ops::lsp::lsp_execute_command(&host, "main", doc, lens).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
|
||||
assert_eq!(mock.ran().len(), 3);
|
||||
|
||||
set_editor_providers(None);
|
||||
server.abort();
|
||||
}
|
||||
@@ -70,14 +70,10 @@ async fn open(fixture: &str) -> Opened {
|
||||
}
|
||||
|
||||
/// Polls `check` until it holds; fails with its last answer.
|
||||
async fn until<T: std::fmt::Debug, F, Fut>(what: &str, timeout: Duration, mut check: F)
|
||||
where
|
||||
F: FnMut() -> Fut,
|
||||
Fut: std::future::Future<Output = Result<(), T>>,
|
||||
{
|
||||
async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: impl FnMut() -> Result<(), T>) {
|
||||
let deadline = Instant::now() + timeout;
|
||||
loop {
|
||||
match check().await {
|
||||
match check() {
|
||||
Ok(()) => return,
|
||||
Err(last) if Instant::now() > deadline => panic!("{what}: timed out after {timeout:?}; last: {last:?}"),
|
||||
Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,
|
||||
@@ -86,25 +82,25 @@ where
|
||||
}
|
||||
|
||||
impl Opened {
|
||||
async fn files(&self, query: &str) -> Vec<String> {
|
||||
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).await.unwrap();
|
||||
fn files(&self, query: &str) -> Vec<String> {
|
||||
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).unwrap();
|
||||
found.into_iter().map(|f| f.rel_path).collect()
|
||||
}
|
||||
|
||||
async fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
|
||||
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).await.unwrap();
|
||||
fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
|
||||
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).unwrap();
|
||||
found.into_iter().map(|s| (s.name, s.rel_path)).collect()
|
||||
}
|
||||
|
||||
async fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
|
||||
let found = self.symbols(name, filter).await;
|
||||
fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
|
||||
let found = self.symbols(name, filter);
|
||||
if found.iter().any(|(n, f)| n == name && f == file) { Ok(()) } else { Err(found) }
|
||||
}
|
||||
}
|
||||
|
||||
async fn smoke(f: Fixture) {
|
||||
let p = open(f.dir).await;
|
||||
until("indexing", Duration::from_secs(30), || async {
|
||||
until("indexing", Duration::from_secs(30), || {
|
||||
let s = ops::nav::index_status(&p.host, WINDOW).unwrap();
|
||||
if !s.indexing && s.files > 0 && s.symbols > 0 { Ok(()) } else { Err(s) }
|
||||
})
|
||||
@@ -119,12 +115,12 @@ async fn smoke(f: Fixture) {
|
||||
);
|
||||
}
|
||||
|
||||
let files = p.files(f.file.0).await;
|
||||
let files = p.files(f.file.0);
|
||||
assert!(files.iter().any(|r| r == f.file.1), "{}: files for {:?}: {files:?}", f.dir, f.file.0);
|
||||
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types).await {
|
||||
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types) {
|
||||
panic!("{}: Go to Class {:?}: {found:?}", f.dir, f.class.0);
|
||||
}
|
||||
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All).await {
|
||||
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All) {
|
||||
panic!("{}: Go to Symbol {:?}: {found:?}", f.dir, f.symbol.0);
|
||||
}
|
||||
|
||||
@@ -134,8 +130,8 @@ async fn smoke(f: Fixture) {
|
||||
until("a new file's class", Duration::from_secs(20), || p.has_symbol("FreshWidget", added, SymbolFilter::Types))
|
||||
.await;
|
||||
std::fs::remove_file(p.root.join(added)).unwrap();
|
||||
until("a deleted file's class", Duration::from_secs(20), || async {
|
||||
let found = p.symbols("FreshWidget", SymbolFilter::Types).await;
|
||||
until("a deleted file's class", Duration::from_secs(20), || {
|
||||
let found = p.symbols("FreshWidget", SymbolFilter::Types);
|
||||
if found.is_empty() { Ok(()) } else { Err(found) }
|
||||
})
|
||||
.await;
|
||||
|
||||
@@ -646,16 +646,8 @@ impl IndexData {
|
||||
}
|
||||
}
|
||||
|
||||
/// Refreshes on-disk metadata of an unchanged-content file in place and
|
||||
/// returns its persisted record.
|
||||
pub(crate) fn refresh_metadata(&mut self, path: &Path, mtime: u64, size: u64, ignored: bool) -> Option<FileRecord> {
|
||||
let slot = *self.by_path.get(path)?;
|
||||
let e = self.files[slot as usize].as_mut()?;
|
||||
e.mtime = mtime;
|
||||
e.size = size;
|
||||
e.ignored = ignored;
|
||||
let e = self.files[slot as usize].as_ref()?;
|
||||
Some(self.record(e))
|
||||
pub(crate) fn record_of(&self, path: &Path) -> Option<FileRecord> {
|
||||
self.get(path).map(|e| self.record(e))
|
||||
}
|
||||
|
||||
/// The symbols of one file, in declaration order.
|
||||
|
||||
@@ -323,11 +323,6 @@ impl ProjectIndex {
|
||||
matching::symbols_named_within(&self.shared.data.read(), name, kind, roots, limit)
|
||||
}
|
||||
|
||||
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per name.
|
||||
pub fn symbols_named_any(&self, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
|
||||
matching::symbols_named_any(&self.shared.data.read(), names, root, limit)
|
||||
}
|
||||
|
||||
/// Incrementally re-indexes changed paths (called from the vfs watcher).
|
||||
/// Cheap: the work is queued for the indexing thread.
|
||||
pub fn update(&self, changed: &[PathBuf], removed: &[PathBuf]) {
|
||||
|
||||
@@ -632,41 +632,6 @@ pub(crate) fn symbols_named_within(
|
||||
out
|
||||
}
|
||||
|
||||
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per
|
||||
/// name, by path then position: one walk over the index for every name an agent reply shows.
|
||||
pub(crate) fn symbols_named_any(data: &IndexData, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
|
||||
let wanted: Vec<(u64, &str)> = names.iter().map(|name| (char_mask(name), name.as_str())).collect();
|
||||
let syms = &data.syms;
|
||||
let mut out: Vec<SymbolMatch> = data
|
||||
.files
|
||||
.iter()
|
||||
.flatten()
|
||||
.filter(|entry| entry.path.starts_with(root))
|
||||
.flat_map(|entry| {
|
||||
(entry.sym_start..entry.sym_start + entry.sym_len)
|
||||
.filter(|&at| wanted.iter().any(|&(mask, name)| syms.mask(at) == mask && syms.name(at) == name))
|
||||
.map(move |at| SymbolMatch {
|
||||
name: syms.name(at).to_string(),
|
||||
kind: syms.kind(at),
|
||||
container: syms.container(at).map(str::to_owned),
|
||||
path: entry.path.clone().into(),
|
||||
rel_path: entry.rel.to_string(),
|
||||
range: syms.range(at),
|
||||
score: 0,
|
||||
indices: Vec::new(),
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
out.sort_by(|left, right| left.rel_path.cmp(&right.rel_path).then_with(|| left.range.cmp(&right.range)));
|
||||
let mut kept: HashMap<String, usize> = HashMap::new();
|
||||
out.retain(|symbol| {
|
||||
let count = kept.entry(symbol.name.clone()).or_default();
|
||||
*count += 1;
|
||||
*count <= limit
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -549,24 +549,6 @@ fn symbols_named_within_keeps_out_of_root_matches_from_evicting_a_root() {
|
||||
assert!(idx.symbols_named_within("Decoder", None, &[f.root.join("none")], 3).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
|
||||
let fixture = Fixture::new(&[
|
||||
("app/a.rs", "struct Config;\nfn load() {}\nfn load_all() {}\n"),
|
||||
("app/b.rs", "fn load() {}\nfn load() {}\n"),
|
||||
("other/c.rs", "struct Config;\n"),
|
||||
]);
|
||||
let idx = fixture.open();
|
||||
let names = ["Config".to_string(), "load".to_string(), "missing".to_string()];
|
||||
let found: Vec<(String, String)> = idx
|
||||
.symbols_named_any(&names, &fixture.root.join("app"), 2)
|
||||
.into_iter()
|
||||
.map(|symbol| (symbol.name, symbol.rel_path))
|
||||
.collect();
|
||||
let expected = [("Config", "app/a.rs"), ("load", "app/a.rs"), ("load", "app/b.rs")];
|
||||
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn content_roots_and_excludes_change_without_reopening() {
|
||||
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
|
||||
@@ -797,13 +779,8 @@ fn incremental_changes_refresh_the_warm_start_snapshot() {
|
||||
let changed = f.write("src/a.rs", "fn renamed() {}\n");
|
||||
idx.update(&[changed], &[]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
// The snapshot is written after a short delay, on the worker's next round.
|
||||
let snapshot = f.cache.join("index.snapshot");
|
||||
let deadline = std::time::Instant::now() + WAIT;
|
||||
while !snapshot.exists() && std::time::Instant::now() < deadline {
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
assert!(snapshot.exists(), "a watcher update must regenerate the snapshot");
|
||||
std::thread::sleep(Duration::from_millis(150));
|
||||
assert!(f.cache.join("index.snapshot").exists(), "a watcher update must regenerate the snapshot");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -985,85 +962,3 @@ fn warm_start_sees_edits_deletions_and_renames_made_while_closed() {
|
||||
assert_eq!(idx.status().files, 3);
|
||||
assert_eq!(symbols(&idx, "zzzz", SymbolFilter::All), ["zzzz"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn queries_during_streaming_scan_do_not_deadlock() {
|
||||
// More than `2 * SCAN_BATCH` (4,096) files so a scan both flushes mid-pass
|
||||
// (`publish` -> `data.write()`) and fills the bounded parse channel while
|
||||
// concurrent queries hold `data.read()` and dispatch onto Rayon.
|
||||
const FILES: usize = 4_600;
|
||||
let f = Fixture::new(&[]);
|
||||
for m in 0..32 {
|
||||
std::fs::create_dir_all(f.root.join(format!("mod{m}"))).unwrap();
|
||||
}
|
||||
for i in 0..FILES {
|
||||
std::fs::write(
|
||||
f.root.join(format!("mod{}/File{i}.rs", i % 32)),
|
||||
format!("pub struct Type{i};\npub fn sym{i}() {{}}\n"),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
let (done_tx, done_rx) = std::sync::mpsc::channel();
|
||||
std::thread::spawn(move || {
|
||||
let languages = Arc::new(LanguageRegistry::load(None).unwrap());
|
||||
let syntax = Arc::new(Syntax::new());
|
||||
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
let idx =
|
||||
ProjectIndex::open(&f.root, &f.cache, Vec::new(), vec![], languages, syntax, Arc::new(NullSink)).unwrap();
|
||||
|
||||
let readers: Vec<_> = (0..4usize)
|
||||
.map(|r| {
|
||||
let idx = idx.clone();
|
||||
let stop = stop.clone();
|
||||
std::thread::spawn(move || {
|
||||
let mut n = r;
|
||||
while !stop.load(Ordering::Relaxed) {
|
||||
match n % 3 {
|
||||
0 => {
|
||||
let _ = idx.find_files("File1", 20);
|
||||
}
|
||||
1 => {
|
||||
let _ = idx.find_dirs("mod", 20);
|
||||
}
|
||||
_ => {
|
||||
let _ = idx.find_symbols("sym1", SymbolFilter::All, 20);
|
||||
}
|
||||
}
|
||||
n = n.wrapping_add(1);
|
||||
}
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
assert!(idx.wait_idle(WAIT), "initial streaming scan did not finish");
|
||||
let parsed_before = idx.shared.parsed.load(Ordering::SeqCst);
|
||||
assert_eq!(parsed_before, FILES);
|
||||
|
||||
// Touch every file without changing its contents so `parse_found` takes
|
||||
// the `Extracted::Unchanged` path across multiple `SCAN_BATCH` flushes.
|
||||
let bumped = std::fs::FileTimes::new().set_modified(std::time::SystemTime::now() + Duration::from_secs(10));
|
||||
for i in 0..FILES {
|
||||
let path = f.root.join(format!("mod{}/File{i}.rs", i % 32));
|
||||
std::fs::File::options().write(true).open(path).unwrap().set_times(bumped).unwrap();
|
||||
}
|
||||
idx.shared.enqueue(Job::Rescan);
|
||||
assert!(idx.wait_idle(WAIT), "rescan of unchanged-content files did not finish");
|
||||
assert_eq!(idx.shared.parsed.load(Ordering::SeqCst), parsed_before, "unchanged content is not re-parsed");
|
||||
assert_eq!(symbols(&idx, "sym4599", SymbolFilter::All), ["sym4599"]);
|
||||
|
||||
stop.store(true, Ordering::Relaxed);
|
||||
for h in readers {
|
||||
h.join().unwrap();
|
||||
}
|
||||
assert_eq!(idx.status().files, FILES as u32);
|
||||
drop(idx);
|
||||
|
||||
let reopened = f.open();
|
||||
assert_eq!(reopened.shared.parsed.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(symbols(&reopened, "sym4599", SymbolFilter::All), ["sym4599"]);
|
||||
let _ = done_tx.send(());
|
||||
});
|
||||
|
||||
done_rx.recv_timeout(Duration::from_secs(60)).expect("concurrent index queries deadlocked with streaming scan");
|
||||
}
|
||||
@@ -11,21 +11,9 @@ use rayon::prelude::*;
|
||||
use std::collections::{HashMap, HashSet, VecDeque};
|
||||
use std::io::Read;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::LazyLock;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::time::{Duration, Instant, SystemTime};
|
||||
|
||||
/// Dedicated pool for background indexing and snapshot hydration: queries hold
|
||||
/// `IndexData::read` while scanning on the global Rayon pool, so indexing work
|
||||
/// (which may block on channel backpressure while the index thread waits for
|
||||
/// `IndexData::write`) must never compete for the same workers.
|
||||
static INDEX_POOL: LazyLock<rayon::ThreadPool> = LazyLock::new(|| {
|
||||
rayon::ThreadPoolBuilder::new()
|
||||
.thread_name(|i| format!("openidea-index-{i}"))
|
||||
.build()
|
||||
.expect("cannot build index thread pool")
|
||||
});
|
||||
|
||||
/// Files larger than this are listed but not parsed for symbols.
|
||||
pub const MAX_SYMBOL_FILE: u64 = 2 * 1024 * 1024;
|
||||
const CHUNK: usize = 512;
|
||||
@@ -266,19 +254,17 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
let build_started = Instant::now();
|
||||
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
|
||||
(0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.map(|i| {
|
||||
let path = root.join(snapshot.rel(i));
|
||||
let meta = std::fs::symlink_metadata(&path).ok()?;
|
||||
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
|
||||
return None;
|
||||
}
|
||||
Some(snapshot.entry(i, root))
|
||||
})
|
||||
.collect()
|
||||
});
|
||||
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = (0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.map(|i| {
|
||||
let path = root.join(snapshot.rel(i));
|
||||
let meta = std::fs::symlink_metadata(&path).ok()?;
|
||||
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
|
||||
return None;
|
||||
}
|
||||
Some(snapshot.entry(i, root))
|
||||
})
|
||||
.collect();
|
||||
let built = build_started.elapsed();
|
||||
if entries.iter().any(Option::is_none) {
|
||||
return false;
|
||||
@@ -347,19 +333,17 @@ impl Shared {
|
||||
let started = Instant::now();
|
||||
match store.load_snapshot() {
|
||||
Some(snapshot) => {
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
|
||||
(0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.filter_map(|i| {
|
||||
let rel = snapshot.rel(i);
|
||||
if !safe_rel(rel) {
|
||||
return None;
|
||||
}
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
|
||||
})
|
||||
.collect()
|
||||
});
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = (0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.filter_map(|i| {
|
||||
let rel = snapshot.rel(i);
|
||||
if !safe_rel(rel) {
|
||||
return None;
|
||||
}
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
|
||||
})
|
||||
.collect();
|
||||
let mut d = self.data.write();
|
||||
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
|
||||
d.reserve(entries.len(), symbols, 0);
|
||||
@@ -379,18 +363,16 @@ impl Shared {
|
||||
Ok(records) => {
|
||||
// Fallback for an index that changed since the snapshot: redb
|
||||
// records are decoded one file at a time and filtered by the walk.
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
|
||||
records
|
||||
.into_par_iter()
|
||||
.filter(|(rel, _)| {
|
||||
safe_rel(rel) && {
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path())
|
||||
}
|
||||
})
|
||||
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
|
||||
.collect()
|
||||
});
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = records
|
||||
.into_par_iter()
|
||||
.filter(|(rel, _)| {
|
||||
safe_rel(rel) && {
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path())
|
||||
}
|
||||
})
|
||||
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
|
||||
.collect();
|
||||
let mut d = self.data.write();
|
||||
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
|
||||
d.reserve(entries.len(), symbols, 0);
|
||||
@@ -464,11 +446,10 @@ impl Shared {
|
||||
}
|
||||
let classify_started = Instant::now();
|
||||
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
|
||||
let (todo, stale) = {
|
||||
let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
|
||||
let d = self.data.read();
|
||||
let todo: Vec<(&Found, Option<ContentHash>)> =
|
||||
found.iter().filter_map(|f| prev_hash_if_stale(&d, f).map(|h| (f, h))).collect();
|
||||
let stale: Vec<PathBuf> = d
|
||||
let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
|
||||
let stale = d
|
||||
.paths()
|
||||
.filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
|
||||
.filter(|p| !seen.contains(p.as_path()))
|
||||
@@ -489,7 +470,7 @@ impl Shared {
|
||||
let total = todo.len();
|
||||
let mut laps = ChunkLaps::default();
|
||||
{
|
||||
// One streaming parallel pass: parse on `INDEX_POOL` without
|
||||
// One streaming parallel pass: parse on the rayon pool without
|
||||
// per-chunk joins (a straggler file at a join's tail idles every
|
||||
// other core), while parsed files flow to this thread to be
|
||||
// inserted and persisted in batches. `filter` moves into the
|
||||
@@ -504,14 +485,12 @@ impl Shared {
|
||||
let pass_started = Instant::now();
|
||||
std::thread::scope(|scope| -> () {
|
||||
scope.spawn(move || {
|
||||
INDEX_POOL.install(|| {
|
||||
todo.par_iter().for_each(|&(f, prev_hash)| {
|
||||
if cancelled.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
let Some(out) = self.parse_found(f, prev_hash, &filter) else { return };
|
||||
let _ = tx.send(out);
|
||||
});
|
||||
todo.par_iter().for_each(|f| {
|
||||
if cancelled.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
let Some(out) = self.parse_found(f, &filter, false) else { return };
|
||||
let _ = tx.send(out);
|
||||
});
|
||||
// `tx` drops here: the consumer's loop ends with the channel.
|
||||
});
|
||||
@@ -591,13 +570,13 @@ impl Shared {
|
||||
}
|
||||
|
||||
/// Extracts records in parallel, then publishes them to memory and disk.
|
||||
fn index_files(&self, files: &[(Found, Option<ContentHash>)]) -> ChunkLaps {
|
||||
/// `force` re-parses files whose content is unchanged (their language changed).
|
||||
fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) -> ChunkLaps {
|
||||
let mut laps = ChunkLaps::default();
|
||||
let files: Vec<&Found> = files.collect();
|
||||
let filter = self.filter();
|
||||
let started = Instant::now();
|
||||
let extracted: Vec<ParsedFile> = INDEX_POOL.install(|| {
|
||||
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
|
||||
});
|
||||
let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
|
||||
laps.extract = started.elapsed();
|
||||
if extracted.is_empty() {
|
||||
return laps;
|
||||
@@ -606,69 +585,49 @@ impl Shared {
|
||||
laps
|
||||
}
|
||||
|
||||
/// Reads and parses one file on `INDEX_POOL` without locking `self.data`,
|
||||
/// serializing new records for the cache alongside the parse. `None` when
|
||||
/// the file is outside the scope or the scan was cancelled.
|
||||
fn parse_found(
|
||||
&self,
|
||||
f: &Found,
|
||||
prev_hash: Option<ContentHash>,
|
||||
filter: &std::sync::Arc<PathFilter>,
|
||||
) -> Option<ParsedFile> {
|
||||
/// Reads and parses one file (parallel-safe), serializing its record for
|
||||
/// the cache alongside the parse. `None` when the file is outside the
|
||||
/// scope or the scan was cancelled.
|
||||
fn parse_found(&self, f: &Found, filter: &std::sync::Arc<PathFilter>, force: bool) -> Option<ParsedFile> {
|
||||
if self.is_cancelled() {
|
||||
return None;
|
||||
}
|
||||
let rel = filter.rel(&f.path)?;
|
||||
let key = filter.store_key(&f.path);
|
||||
let outcome = match self.extract(f, prev_hash) {
|
||||
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
|
||||
Extracted::New(rec) => {
|
||||
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
|
||||
ParsedOutcome::New { rec, bytes }
|
||||
let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
|
||||
let rec = match self.extract(f, prev_hash) {
|
||||
Extracted::Unchanged => {
|
||||
// Same content, new mtime: keep the symbols, refresh metadata.
|
||||
let mut rec = self.data.read().record_of(&f.path)?;
|
||||
rec.mtime = f.mtime;
|
||||
rec.size = f.size;
|
||||
rec.ignored = f.ignored;
|
||||
rec
|
||||
}
|
||||
Extracted::New(rec) => rec,
|
||||
};
|
||||
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
|
||||
let key = filter.store_key(&f.path);
|
||||
let bytes = postcard::to_allocvec(&rec).ok();
|
||||
Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
|
||||
}
|
||||
|
||||
/// Inserts a parsed batch into the in-memory index and persists the records.
|
||||
fn publish(&self, batch: impl Iterator<Item = ParsedFile>) -> ChunkLaps {
|
||||
let mut laps = ChunkLaps::default();
|
||||
let started = Instant::now();
|
||||
let mut inserts: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
|
||||
let mut refreshes: Vec<MetadataRefresh> = Vec::new();
|
||||
let mut entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
|
||||
let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
|
||||
for out in batch {
|
||||
let ParsedFile { rel, key, outcome, path } = out;
|
||||
match outcome {
|
||||
ParsedOutcome::New { rec, bytes } => {
|
||||
if let (Some(key), Some(bytes)) = (key, bytes) {
|
||||
puts.push((key, bytes));
|
||||
}
|
||||
inserts.push(FileEntry::new(path, rel, rec));
|
||||
}
|
||||
ParsedOutcome::Unchanged { mtime, size, ignored } => {
|
||||
refreshes.push(MetadataRefresh { path, key, mtime, size, ignored });
|
||||
}
|
||||
let ParsedFile { rel, rec, key, bytes, path } = out;
|
||||
if let (Some(key), Some(bytes)) = (key, bytes) {
|
||||
puts.push((key, bytes));
|
||||
}
|
||||
entries.push(FileEntry::new(path, rel, rec));
|
||||
}
|
||||
let mut refreshed_records: Vec<(String, FileRecord)> = Vec::new();
|
||||
{
|
||||
let mut d = self.data.write();
|
||||
for (e, symbols) in inserts {
|
||||
for (e, symbols) in entries {
|
||||
d.insert(e, symbols);
|
||||
}
|
||||
for r in refreshes {
|
||||
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
|
||||
&& let Some(key) = r.key
|
||||
{
|
||||
refreshed_records.push((key, rec));
|
||||
}
|
||||
}
|
||||
}
|
||||
for (key, rec) in refreshed_records {
|
||||
if let Ok(bytes) = postcard::to_allocvec(&rec) {
|
||||
puts.push((key, bytes));
|
||||
}
|
||||
}
|
||||
laps.insert = started.elapsed();
|
||||
let started = Instant::now();
|
||||
@@ -859,9 +818,9 @@ impl Shared {
|
||||
for (dir, wanted) in by_dir {
|
||||
files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));
|
||||
}
|
||||
let files: Vec<(Found, Option<ContentHash>)> = {
|
||||
let files: Vec<Found> = {
|
||||
let d = self.data.read();
|
||||
files.into_iter().filter_map(|f| prev_hash_if_stale(&d, &f).map(|h| (f, h))).collect()
|
||||
files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
|
||||
};
|
||||
if !files.is_empty() {
|
||||
touched = true;
|
||||
@@ -869,17 +828,17 @@ impl Shared {
|
||||
if self.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
self.index_files(chunk);
|
||||
self.index_files(chunk.iter(), false);
|
||||
}
|
||||
}
|
||||
for before in reparse {
|
||||
let affected: Vec<(Found, Option<ContentHash>)> = {
|
||||
let affected: Vec<Found> = {
|
||||
let d = self.data.read();
|
||||
d.paths()
|
||||
.filter(|p| before.detect(p, None) != self.languages.detect(p, None))
|
||||
.filter_map(|p| {
|
||||
let e = d.get(p)?;
|
||||
Some((Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, None))
|
||||
Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
@@ -889,7 +848,7 @@ impl Shared {
|
||||
if self.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
self.index_files(chunk);
|
||||
self.index_files(chunk.iter(), true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -907,18 +866,6 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
|
||||
type ContentHash = [u8; 32];
|
||||
|
||||
/// `Some(prev_hash)` when `f` is missing or stale in `d` (`None` inner hash when
|
||||
/// the file must be parsed fresh); `None` when `d` is already current for `f`.
|
||||
fn prev_hash_if_stale(d: &IndexData, f: &Found) -> Option<Option<ContentHash>> {
|
||||
match d.get(&f.path) {
|
||||
None => Some(None),
|
||||
Some(e) if e.stale_for(f) => Some((!e.ignored).then_some(e.hash)),
|
||||
Some(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The first line, capped at 256 bytes (for shebang / `<?xml` detection).
|
||||
fn first_line(text: &str) -> &str {
|
||||
let line = text.lines().next().unwrap_or_default();
|
||||
@@ -951,26 +898,14 @@ impl ChunkLaps {
|
||||
}
|
||||
}
|
||||
|
||||
struct MetadataRefresh {
|
||||
path: PathBuf,
|
||||
key: Option<String>,
|
||||
mtime: u64,
|
||||
size: u64,
|
||||
ignored: bool,
|
||||
}
|
||||
|
||||
enum ParsedOutcome {
|
||||
Unchanged { mtime: u64, size: u64, ignored: bool },
|
||||
New { rec: FileRecord, bytes: Option<Vec<u8>> },
|
||||
}
|
||||
|
||||
/// One file parsed off the index thread: its outcome ready to publish, with new
|
||||
/// records already serialized for the cache in parallel with the parse.
|
||||
/// One file parsed off the index thread: its record ready to publish, already
|
||||
/// serialized for the cache (in parallel with the parse).
|
||||
struct ParsedFile {
|
||||
rel: String,
|
||||
/// Cache key; `None` when outside the persisted root.
|
||||
rec: FileRecord,
|
||||
/// Cache key and postcard bytes; `None` when outside the persisted root.
|
||||
key: Option<String>,
|
||||
outcome: ParsedOutcome,
|
||||
bytes: Option<Vec<u8>>,
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
|
||||
@@ -194,9 +194,6 @@ pub mod codes {
|
||||
pub const METHOD_NOT_FOUND: i64 = -32601;
|
||||
pub const INVALID_PARAMS: i64 = -32602;
|
||||
pub const INTERNAL_ERROR: i64 = -32603;
|
||||
/// LSP `RequestFailed`: the request was understood and could not be carried out; the
|
||||
/// message says why.
|
||||
pub const REQUEST_FAILED: i64 = -32803;
|
||||
/// LSP `ServerCancelled`.
|
||||
pub const SERVER_CANCELLED: i64 = -32802;
|
||||
/// LSP `ContentModified`.
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
//! Pull Members Up / Push Members Down through the app-owned JDT extension
|
||||
//! (`java/java-usages`), or through Phoxite's own requests when the document's
|
||||
//! server advertises them (`crate::phoxite`). The server checks the move and computes the edit; the UI
|
||||
//! (`java/java-usages`). The server checks the move and computes the edit; the UI
|
||||
//! shows its problems and applies the edit itself.
|
||||
use super::COMMAND_TIMEOUT;
|
||||
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
|
||||
@@ -76,9 +75,6 @@ impl LspManager {
|
||||
kind: HierarchyRefactoring,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<HierarchyMembers> {
|
||||
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
|
||||
return self.phoxite_hierarchy_members(&phoxite, pos, kind, &cancel).await;
|
||||
}
|
||||
let (members, _, _) = self.hierarchy_command(doc, pos, kind, MEMBERS, &[], &cancel).await?;
|
||||
Ok(members)
|
||||
}
|
||||
@@ -93,9 +89,6 @@ impl LspManager {
|
||||
choices: Vec<HierarchyChoice>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<HierarchyRefactored> {
|
||||
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
|
||||
return self.phoxite_hierarchy_refactor(&phoxite, pos, kind, target, &choices, &cancel).await;
|
||||
}
|
||||
let choices: Vec<Value> = choices.iter().map(|c| json!({ "id": c.id, "abstract": c.make_abstract })).collect();
|
||||
let (refactored, _, t): (Refactored, _, _) =
|
||||
self.hierarchy_command(doc, pos, kind, REFACTOR, &[json!(target), json!(choices)], &cancel).await?;
|
||||
|
||||
@@ -26,7 +26,6 @@ mod launch;
|
||||
mod library_source;
|
||||
mod loading;
|
||||
mod notebook;
|
||||
mod phoxite;
|
||||
mod plugin_requests;
|
||||
mod pull;
|
||||
mod scope;
|
||||
|
||||
@@ -1,97 +0,0 @@
|
||||
//! Pull Members Up / Push Members Down through Phoxite's own requests
|
||||
//! (`phoxite/refactor/hierarchyMembers` and `phoxite/refactor/hierarchy`). A server says it
|
||||
//! answers them with `experimental.phoxite.refactor` in its capabilities, so the server is
|
||||
//! found by what it advertises, not by its name. As with the JDT extension, the server
|
||||
//! checks the move and computes the edit; the UI shows its problems and applies the edit.
|
||||
use crate::caps::ServerCaps;
|
||||
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
|
||||
use crate::{DocSnap, LspManager, Target, convert, rpc_err};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
|
||||
use ide_jsonrpc::RpcError;
|
||||
use serde::Deserialize;
|
||||
use serde::de::DeserializeOwned;
|
||||
use serde_json::{Value, json};
|
||||
use std::time::Duration;
|
||||
|
||||
const MEMBERS: &str = "phoxite/refactor/hierarchyMembers";
|
||||
const REFACTOR: &str = "phoxite/refactor/hierarchy";
|
||||
/// The move is computed over the whole project.
|
||||
const TIMEOUT: Duration = Duration::from_secs(120);
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Refactored {
|
||||
problems: Vec<RefactoringProblem>,
|
||||
edit: Option<lsp_types::WorkspaceEdit>,
|
||||
}
|
||||
|
||||
/// Whether the server answers the `phoxite/refactor/*` requests.
|
||||
fn refactors(caps: &ServerCaps) -> bool {
|
||||
caps.raw.pointer("/experimental/phoxite/refactor").and_then(Value::as_bool) == Some(true)
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
/// The server of `doc` that answers `phoxite/refactor/*`, when one is attached.
|
||||
pub(crate) async fn phoxite_refactor_target(&self, doc: DocId) -> Option<(DocSnap, Target)> {
|
||||
let (snap, mut targets) = self.doc_targets(doc, "refactorings", refactors).await.ok()?;
|
||||
Some((snap, targets.swap_remove(0)))
|
||||
}
|
||||
|
||||
/// Sends one of the hierarchy requests. The server refuses a position it can't
|
||||
/// refactor with LSP's `RequestFailed` and a message for the user: that is invalid
|
||||
/// input, as the JDT extension's `refused` is. Any other error is the server failing.
|
||||
async fn phoxite_hierarchy<R: DeserializeOwned>(
|
||||
&self,
|
||||
(snap, t): &(DocSnap, Target),
|
||||
method: &str,
|
||||
pos: Pos,
|
||||
kind: HierarchyRefactoring,
|
||||
extra: Value,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<R> {
|
||||
let mut params = json!({ "uri": snap.uri, "position": snap.position(t, pos), "kind": kind });
|
||||
if let (Some(params), Value::Object(extra)) = (params.as_object_mut(), extra) {
|
||||
params.extend(extra);
|
||||
}
|
||||
let request = t.run.peer.request::<Value, Value>(method, params, Some(cancel.clone()));
|
||||
let answer = match tokio::time::timeout(TIMEOUT, request).await {
|
||||
Ok(Ok(value)) => value,
|
||||
Ok(Err(RpcError::Server { code, message, .. })) if code == ide_jsonrpc::codes::REQUEST_FAILED => {
|
||||
return Err(IdeError::invalid(message));
|
||||
}
|
||||
Ok(Err(e)) => return Err(rpc_err(&t.server.name, method, e)),
|
||||
Err(_) => return Err(rpc_err(&t.server.name, method, RpcError::Timeout)),
|
||||
};
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
serde_json::from_value(answer).map_err(|e| rpc_err(&t.server.name, method, RpcError::Protocol(e.to_string())))
|
||||
}
|
||||
|
||||
pub(crate) async fn phoxite_hierarchy_members(
|
||||
&self,
|
||||
target: &(DocSnap, Target),
|
||||
pos: Pos,
|
||||
kind: HierarchyRefactoring,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HierarchyMembers> {
|
||||
self.phoxite_hierarchy(target, MEMBERS, pos, kind, Value::Null, cancel).await
|
||||
}
|
||||
|
||||
pub(crate) async fn phoxite_hierarchy_refactor(
|
||||
&self,
|
||||
target: &(DocSnap, Target),
|
||||
pos: Pos,
|
||||
kind: HierarchyRefactoring,
|
||||
destination: Option<String>,
|
||||
choices: &[HierarchyChoice],
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HierarchyRefactored> {
|
||||
let extra = json!({ "target": destination, "choices": choices });
|
||||
let refactored: Refactored = self.phoxite_hierarchy(target, REFACTOR, pos, kind, extra, cancel).await?;
|
||||
let conv = self.conv(target.1.enc());
|
||||
Ok(HierarchyRefactored {
|
||||
problems: refactored.problems,
|
||||
edit: refactored.edit.map(|e| convert::workspace_edit(&conv, e)),
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -57,16 +57,6 @@ impl LspManager {
|
||||
Ok(running.swap_remove(at))
|
||||
}
|
||||
|
||||
/// Names (in the language definition) of the servers attached to `doc`, or of every
|
||||
/// server of the project when the document is not open; only `server`'s when given.
|
||||
pub fn server_names(&self, doc: ide_core::DocId, server: Option<ide_core::ServerId>) -> Vec<String> {
|
||||
let servers = match self.snapshot(doc) {
|
||||
Ok(snap) => snap.servers,
|
||||
Err(_) => self.servers.lock().clone(),
|
||||
};
|
||||
servers.iter().filter(|s| server.is_none_or(|id| s.id == id)).map(|s| s.name.clone()).collect()
|
||||
}
|
||||
|
||||
/// Sends a plugin's request to the running server named `server` (its name in the
|
||||
/// language definition) and returns the result. `not_found` when it is not running,
|
||||
/// `invalid` for a method that is not the server's own.
|
||||
|
||||
@@ -7429,91 +7429,3 @@ async fn a_plugin_request_reaches_only_a_running_servers_own_methods() {
|
||||
let e = h.mgr.server_request(&h.root, "main", "mock/routes", None, &cancel, timeout).await.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
}
|
||||
|
||||
/// A server that advertises `experimental.phoxite.refactor` gets Pull Members Up / Push
|
||||
/// Members Down as its own `phoxite/refactor/*` requests, whatever its name.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hierarchy_refactorings_use_phoxites_requests_when_the_server_advertises_them() {
|
||||
let mut caps = incremental_caps();
|
||||
caps["experimental"] = json!({ "phoxite": { "laravel": true, "refactor": true } });
|
||||
let h = harness_for("php", "php", &[("any-name", caps)], &[]);
|
||||
let s = h.launcher.state("any-name");
|
||||
*s.responder.lock() = Some(Arc::new(|_, method, params| {
|
||||
let uri = params["uri"].clone();
|
||||
match (method, params["position"]["line"].as_u64()) {
|
||||
("phoxite/refactor/hierarchyMembers", Some(0)) => Some(json!({
|
||||
"className": "Dog",
|
||||
"targets": [{ "id": "App\\Animal", "name": "Animal", "qualifiedName": "App\\Animal", "interface": false }],
|
||||
"members": [
|
||||
{ "id": "method:bark", "label": "bark(): string", "kind": "method", "selected": true, "abstractable": true },
|
||||
{ "id": "constant:LEGS", "label": "LEGS", "kind": "field", "selected": false, "abstractable": false },
|
||||
],
|
||||
})),
|
||||
("phoxite/refactor/hierarchy", _) => Some(json!({
|
||||
"problems": [{ "severity": "warning", "message": "bark() uses $tail, which stays in Dog" }],
|
||||
"edit": { "changes": { uri.as_str().unwrap(): [
|
||||
{ "range": { "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 5 } }, "newText": "<?php" }
|
||||
] } },
|
||||
})),
|
||||
_ => None,
|
||||
}
|
||||
}));
|
||||
let text =
|
||||
format!("<?php class Dog extends Animal {{ function bark(): string {{ return ''; }} }}{}", "\n".repeat(9));
|
||||
let (doc, path) = h.open("Dog.php", &text);
|
||||
h.wait_status("any-name", ServerStatus::Ready).await;
|
||||
eventually(|| s.docs.lock().len() == 1).await;
|
||||
|
||||
let info =
|
||||
h.mgr.hierarchy_members(doc, Pos::new(0, 40), HierarchyRefactoring::PullUp, Default::default()).await.unwrap();
|
||||
assert_eq!((info.class_name.as_str(), info.targets[0].qualified_name.as_str()), ("Dog", "App\\Animal"));
|
||||
assert!(info.members[0].selected && info.members[0].abstractable);
|
||||
assert_eq!(
|
||||
info.members.iter().map(|m| m.kind).collect::<Vec<_>>(),
|
||||
[HierarchyMemberKind::Method, HierarchyMemberKind::Field]
|
||||
);
|
||||
assert_eq!(
|
||||
s.requested("phoxite/refactor/hierarchyMembers"),
|
||||
[json!({ "uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp" })]
|
||||
);
|
||||
|
||||
let choices = vec![HierarchyChoice { id: "method:bark".into(), make_abstract: true }];
|
||||
let done = h
|
||||
.mgr
|
||||
.hierarchy_refactor(
|
||||
doc,
|
||||
Pos::new(0, 40),
|
||||
HierarchyRefactoring::PullUp,
|
||||
Some("App\\Animal".into()),
|
||||
choices,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(done.problems[0].severity, ProblemSeverity::Warning);
|
||||
let edit = done.edit.unwrap();
|
||||
assert!(matches!(&edit.files[..], [FileEdit::Edit { path: p, edits, .. }] if p == &path && edits.len() == 1));
|
||||
assert_eq!(
|
||||
s.requested("phoxite/refactor/hierarchy"),
|
||||
[json!({
|
||||
"uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp",
|
||||
"target": "App\\Animal", "choices": [{ "id": "method:bark", "makeAbstract": true }],
|
||||
})]
|
||||
);
|
||||
assert!(s.requested("workspace/executeCommand").is_empty(), "not the JDT extension's commands");
|
||||
|
||||
// The server refuses a position with `RequestFailed` and a message for the user.
|
||||
let refusal = (-32803, "'Dog' has no parent class or interface in the project".to_owned());
|
||||
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), refusal);
|
||||
let refused = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
|
||||
let e = refused.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::InvalidInput);
|
||||
assert_eq!(e.message, "'Dog' has no parent class or interface in the project");
|
||||
|
||||
// Any other error is the server failing, not a reason to show as the user's mistake.
|
||||
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), (-32603, "index out of bounds".to_owned()));
|
||||
let failed = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
|
||||
let e = failed.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::Protocol);
|
||||
assert_eq!(e.message, "any-name: index out of bounds");
|
||||
}
|
||||
@@ -1022,82 +1022,3 @@ async fn basedpyright_and_ruff_serve_notebook_cells() {
|
||||
mgr.close_notebook(&path);
|
||||
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
|
||||
}
|
||||
|
||||
/// Pull Members Up through Phoxite's own requests: the real server moves a method to
|
||||
/// the parent class in another file.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires phoxite-lsp on PATH (or OPENIDEA_TEST_PHOXITE_LSP)"]
|
||||
async fn phoxite_pulls_a_member_up_end_to_end() {
|
||||
use ide_core::FileEdit;
|
||||
use ide_lsp::types::{HierarchyChoice, HierarchyRefactoring};
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
std::fs::create_dir(root.join("src")).unwrap();
|
||||
std::fs::write(root.join("composer.json"), r#"{"autoload":{"psr-4":{"App\\":"src/"}}}"#).unwrap();
|
||||
let animal = root.join("src").join("Animal.php");
|
||||
std::fs::write(&animal, "<?php\n\nnamespace App;\n\nclass Animal\n{\n}\n").unwrap();
|
||||
let path = root.join("src").join("Dog.php");
|
||||
let source = "<?php\n\nnamespace App;\n\nclass Dog extends Animal\n{\n public function bark(): string\n {\n return 'woof';\n }\n}\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut php = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("php")).unwrap();
|
||||
php.language_servers.retain(|s| s.name == "phoxite");
|
||||
assert_eq!(php.language_servers.len(), 1);
|
||||
php.language_servers[0].fallback = false;
|
||||
if let Ok(bin) = std::env::var("OPENIDEA_TEST_PHOXITE_LSP") {
|
||||
php.language_servers[0].command = bin;
|
||||
}
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![php]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("php"), 1, source);
|
||||
retry("phoxite ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "phoxite");
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("phoxite failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
// On `bark`; the parent is known once the project is indexed.
|
||||
let at = Pos::new(6, 22);
|
||||
let info = retry("the movable members", Duration::from_secs(60), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.hierarchy_members(doc, at, HierarchyRefactoring::PullUp, Default::default()).await.ok() }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(info.class_name, "Dog");
|
||||
assert_eq!(
|
||||
info.targets.iter().map(|t| t.qualified_name.trim_start_matches('\\')).collect::<Vec<_>>(),
|
||||
["App\\Animal"]
|
||||
);
|
||||
let bark = info.members.iter().find(|m| m.label.starts_with("bark")).expect("bark is movable");
|
||||
assert!(bark.selected, "{bark:?}");
|
||||
let choices = vec![HierarchyChoice { id: bark.id.clone(), make_abstract: false }];
|
||||
let done = mgr
|
||||
.hierarchy_refactor(
|
||||
doc,
|
||||
at,
|
||||
HierarchyRefactoring::PullUp,
|
||||
Some(info.targets[0].id.clone()),
|
||||
choices,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let edit = done.edit.expect("an edit");
|
||||
let mut edited: Vec<_> = edit
|
||||
.files
|
||||
.iter()
|
||||
.filter_map(|f| match f {
|
||||
FileEdit::Edit { path, edits, .. } if !edits.is_empty() => path.0.file_name()?.to_str().map(str::to_owned),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
edited.sort();
|
||||
assert_eq!(edited, ["Animal.php", "Dog.php"], "the method leaves Dog and arrives in Animal");
|
||||
// Outside any class the server refuses with `RequestFailed`: the reason reaches the user.
|
||||
let refused = mgr.hierarchy_members(doc, Pos::new(0, 0), HierarchyRefactoring::PullUp, Default::default()).await;
|
||||
let refused = refused.unwrap_err();
|
||||
assert_eq!(refused.kind, ide_core::error::ErrorKind::InvalidInput, "{refused:?}");
|
||||
assert!(!refused.message.is_empty() && !refused.message.starts_with("phoxite:"), "{refused:?}");
|
||||
mgr.shutdown_all().await;
|
||||
}
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
6a36bd56db7148032c1fe101bec8c38e326528b1de1ee26b5d7c5b9dd80b3e94
|
||||
4788f82b35966e155dbf51af520acb2d5e7773ddf9f36f4239b9bd51d51b0fb3
|
||||
@@ -22,13 +22,3 @@ title = "Send a method of LSP itself"
|
||||
[[contributes.commands]]
|
||||
id = "ungranted"
|
||||
title = "Ask a server the manifest does not name"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "ran"
|
||||
title = "Run a command the mock server left to the client"
|
||||
|
||||
# The mock server's code lenses carry `mock.modelView` without executing it.
|
||||
[[contributes.serverCommands]]
|
||||
server = "mock"
|
||||
command = "mock.modelView"
|
||||
run = "ran"
|
||||
@@ -10,8 +10,6 @@ impl Plugin for LspRequests {
|
||||
"request" => project.language_server_request("mock", "mock/routes", arg).map(Some),
|
||||
"notify" => project.language_server_notify("mock", "mock/changed", arg).map(|()| None),
|
||||
"standard" => project.language_server_request("mock", "textDocument/hover", arg).map(Some),
|
||||
// Shows the server what arrived: the arguments of the command it handed to the client.
|
||||
"ran" => project.language_server_notify("mock", "mock/ran", arg).map(|()| None),
|
||||
"ungranted" => project.language_server_request("other", "other/status", arg).map(Some),
|
||||
_ => Err(Error::NotFound(id.into())),
|
||||
}
|
||||
|
||||
@@ -128,7 +128,7 @@ With tabs placed left or right, the tab column is as wide as its longest name, u
|
||||
| **Scroll to Center** | `⌃L` | `Ctrl+M` |
|
||||
|
||||
- **View › Active Editor › Soft-Wrap** wraps long lines in the current editor. To wrap some file types by default, use **Settings › Editor › General**, section **Soft Wraps**.
|
||||
- **View › Reset Font Size** undoes font zoom in the active editor or focused surface (**View › Reset Font Size in All Editors** resets every open editor). Changing the font size with `⌘` / `Ctrl` + mouse wheel (scoped to **Active editor** by default, or **All editors**) can be turned on in **Settings › Editor › General**, section **Mouse Control**.
|
||||
- **View › Reset Font Size in All Editors** undoes font zoom. Changing the font size with `⌘` / `Ctrl` + mouse wheel can be turned on in **Settings › Editor › General**, section **Mouse Control**.
|
||||
- **View › Appearance › Enter Distraction Free Mode** hides tool windows, tabs, the status bar and the gutter and centres the text. Run the same command again to leave.
|
||||
- Line numbers, whitespace, indent guides, caret style and the intention bulb are in **Settings › Editor › General › Appearance**. Breadcrumbs and sticky lines (the enclosing declarations pinned at the top while you scroll) have their own pages under **Settings › Editor › General**.
|
||||
|
||||
|
||||
@@ -94,7 +94,6 @@ While the server runs, OpenIDEA writes its port and token to `mcp/server.json` i
|
||||
| Commands | `run_command`, `wait_for_run`, `send_run_input`, `stop_run` |
|
||||
| Command state | `get_run_status`, `read_run_output`, `list_runs` |
|
||||
| Git | `get_repositories`, `git_status`, `git_diff` |
|
||||
| HTTP Client | `http_list_requests`, `http_run_request` |
|
||||
|
||||
Notes on what they do:
|
||||
|
||||
@@ -106,7 +105,6 @@ Notes on what they do:
|
||||
- `rename_refactoring` renames through the language server, so references that a text search would miss are updated too. It can preview without writing.
|
||||
- `apply_patch` accepts the Codex `apply_patch` format and unified diffs. Paths must stay inside the project.
|
||||
- `git_diff` compares files on disk, so unsaved editor text is not included.
|
||||
- `http_list_requests` lists requests in a project `.http` / `.rest` file; `http_run_request` sends one by index (optional `env` from `http-client.env.json`), asks first, and returns status plus a truncated body — not request headers or body.
|
||||
|
||||
## Commands in the Run tool window
|
||||
|
||||
@@ -124,7 +122,7 @@ Plugins can add more tools; they appear in the same list. A plugin tool marked a
|
||||
## Safety
|
||||
|
||||
- **Untrusted projects** expose only the read-only tools. Tools that write files, rename, reformat, build or run need a project you have trusted.
|
||||
- **Running and building ask first.** `execute_run_configuration`, `build_project`, `run_command` and `http_run_request` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
|
||||
- **Running and building ask first.** `execute_run_configuration`, `build_project` and `run_command` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
|
||||
- Tools that write refuse paths outside the project.
|
||||
|
||||
## Limits
|
||||
|
||||
@@ -27,8 +27,8 @@ The **Refactor** menu has IntelliJ IDEA's refactorings with their usual shortcut
|
||||
| **Inline…** | `⌥⌘N` | `Ctrl+Alt+N` | Language server |
|
||||
| **Move…** | `F6` | `F6` | Language server (symbols); the IDE (files and folders) |
|
||||
| **Safe Delete…** | `⌘⌦` | `Alt+Delete` | The IDE, using the server's references |
|
||||
| **Pull Members Up…** | — | — | Java; PHP with Phoxite |
|
||||
| **Push Members Down…** | — | — | Java; PHP with Phoxite |
|
||||
| **Pull Members Up…** | — | — | Java only |
|
||||
| **Push Members Down…** | — | — | Java only |
|
||||
|
||||
## Rename
|
||||
|
||||
@@ -80,7 +80,7 @@ In the editor, **Move…** on a symbol runs the server's move refactoring, where
|
||||
|
||||
## Pull Members Up and Push Members Down
|
||||
|
||||
These move fields and methods between a class and its superclasses or subclasses, in Java and, with Phoxite as the PHP server, in PHP (methods, properties and constants). A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. For Java they are provided by the extension bundled with OpenIDEA, for PHP by Phoxite; they are not available for other languages or other PHP servers.
|
||||
These move fields and methods between a Java class and its superclasses or subclasses. A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. They are provided by the Java extension bundled with OpenIDEA, so they are not available for other languages.
|
||||
|
||||
## Undo
|
||||
|
||||
|
||||
@@ -64,7 +64,7 @@ To create a theme or icon theme, see [Themes](/en/plugins/guides/themes) and [Ic
|
||||
- **Enable ligatures** for fonts with programming ligatures.
|
||||
- **Typography Settings**: **Main font weight**, **Bold font weight**, and a **Fallback font** for characters the main font lacks.
|
||||
|
||||
To change the size temporarily in the active editor, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size** (or **View › Reset Font Size in All Editors**) goes back. In **Settings › Editor › General**, **Change font size with Ctrl/Command+Mouse Wheel** enables wheel zoom for the **Active editor** (default) or **All editors**.
|
||||
To change the size temporarily, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size in All Editors** goes back. On macOS, **Change font size with Command+Mouse Wheel** in **Settings › Editor › General** enables wheel zoom.
|
||||
|
||||
### UI font and zoom
|
||||
|
||||
|
||||
@@ -100,31 +100,30 @@ The user approves **required** capabilities as a whole when installing. **Option
|
||||
|
||||
Each contribution point is a table (`[contributes.settings]`) or an array of tables (`[[contributes.commands]]`). Contributions are live as soon as the plugin is enabled, before its code loads.
|
||||
|
||||
| Point | Declaration | Code needed | Guide |
|
||||
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
|
||||
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
|
||||
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
|
||||
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
|
||||
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
|
||||
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
|
||||
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
|
||||
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
|
||||
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
|
||||
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
|
||||
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
|
||||
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
|
||||
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
|
||||
| `serverCommands` | `server`, `command`, `run` (API 1.9) | yes | [README: Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
|
||||
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
|
||||
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
|
||||
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
|
||||
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
|
||||
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
|
||||
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
|
||||
| Point | Declaration | Code needed | Guide |
|
||||
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
|
||||
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
|
||||
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
|
||||
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
|
||||
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
|
||||
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
|
||||
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
|
||||
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
|
||||
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
|
||||
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
|
||||
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
|
||||
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
|
||||
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
|
||||
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
|
||||
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
|
||||
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
|
||||
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
|
||||
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
|
||||
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
|
||||
|
||||
Item ids (commands, views, themes, …) match `[a-z0-9][a-z0-9._-]*`, at most 64 characters. Menus, shortcuts and status bar items refer to the plugin's own declared commands; inside the IDE a command's action id is `plugin.<plugin id>.<command id>`.
|
||||
|
||||
|
||||
@@ -128,7 +128,7 @@ description: "多光标与选区、行编辑、剪贴板历史、代码折叠、
|
||||
| **滚动到中央** | `⌃L` | `Ctrl+M` |
|
||||
|
||||
- **视图 › 活动编辑器 › 软换行** 让当前编辑器的长行自动折行。想让某些文件类型默认软换行,在 **设置 › 编辑器 › 常规** 的 **软换行** 一节中设置。
|
||||
- **视图 › 重置字体大小** 撤销当前编辑器或焦点区域的字体缩放(**视图 › 重置所有编辑器中的字体大小** 会重置所有打开的编辑器)。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
|
||||
- **视图 › 重置所有编辑器中的字体大小** 撤销字体缩放。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开。
|
||||
- **视图 › 外观 › 进入无干扰模式** 隐藏工具窗口、标签页、状态栏和装订区域,并让正文居中。再执行一次即可退出。
|
||||
- 行号、空白字符、缩进参考线、光标样式和意图灯泡在 **设置 › 编辑器 › 常规 › 外观** 中设置。痕迹导航和粘滞行(滚动时把所在的声明固定在顶部)在 **设置 › 编辑器 › 常规** 下各有单独的页面。
|
||||
|
||||
|
||||
@@ -82,18 +82,17 @@ stdio 配置大致如下(路径以你机器上的为准):
|
||||
|
||||
## 工具
|
||||
|
||||
| 类别 | 工具 |
|
||||
| ----------- | --------------------------------------------------------------------------- |
|
||||
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
|
||||
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
|
||||
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
|
||||
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
|
||||
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
|
||||
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
|
||||
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
|
||||
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
|
||||
| Git | `get_repositories`、`git_status`、`git_diff` |
|
||||
| HTTP 客户端 | `http_list_requests`、`http_run_request` |
|
||||
| 类别 | 工具 |
|
||||
| ---------- | --------------------------------------------------------------------------- |
|
||||
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
|
||||
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
|
||||
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
|
||||
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
|
||||
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
|
||||
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
|
||||
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
|
||||
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
|
||||
| Git | `get_repositories`、`git_status`、`git_diff` |
|
||||
|
||||
几点说明:
|
||||
|
||||
@@ -105,7 +104,6 @@ stdio 配置大致如下(路径以你机器上的为准):
|
||||
- `rename_refactoring` 通过语言服务器重命名,文本搜索找不到的引用也会一并更新;也可以只预览不写入。
|
||||
- `apply_patch` 接受 Codex 的 `apply_patch` 格式和 unified diff,路径必须在项目内。
|
||||
- `git_diff` 比较的是磁盘上的文件,不包含编辑器中尚未保存的内容。
|
||||
- `http_list_requests` 列出项目中 `.http` / `.rest` 文件里的请求;`http_run_request` 按索引发送其中一个(可选 `env`,来自 `http-client.env.json`),会先询问,并返回状态和截断后的响应体——不含请求头或请求体。
|
||||
|
||||
## 在运行工具窗口中执行命令
|
||||
|
||||
@@ -123,7 +121,7 @@ stdio 配置大致如下(路径以你机器上的为准):
|
||||
## 安全
|
||||
|
||||
- **未受信任的项目** 只开放只读工具。写文件、重命名、重新格式化、构建或运行的工具都要求项目已被信任。
|
||||
- **运行和构建会先询问。** `execute_run_configuration`、`build_project`、`run_command` 和 `http_run_request` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
|
||||
- **运行和构建会先询问。** `execute_run_configuration`、`build_project` 和 `run_command` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
|
||||
- 会写入的工具拒绝项目之外的路径。
|
||||
|
||||
## 限制
|
||||
|
||||
@@ -27,8 +27,8 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
|
||||
| **内联…** | `⌥⌘N` | `Ctrl+Alt+N` | 语言服务器 |
|
||||
| **移动…** | `F6` | `F6` | 语言服务器(符号);IDE(文件和文件夹) |
|
||||
| **安全删除…** | `⌘⌦` | `Alt+Delete` | IDE,借助服务器查找引用 |
|
||||
| **上拉成员…** | — | — | Java;PHP(使用 Phoxite) |
|
||||
| **下推成员…** | — | — | Java;PHP(使用 Phoxite) |
|
||||
| **上拉成员…** | — | — | 仅 Java |
|
||||
| **下推成员…** | — | — | 仅 Java |
|
||||
|
||||
## 重命名
|
||||
|
||||
@@ -73,7 +73,7 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
|
||||
|
||||
## 上拉成员与下推成员
|
||||
|
||||
用于在类和它的父类或子类之间移动字段和方法:支持 Java,以及使用 Phoxite 作为 PHP 服务器时的 PHP(方法、属性和常量)。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。Java 由 OpenIDEA 自带的扩展提供,PHP 由 Phoxite 提供;其他语言和其他 PHP 服务器不可用。
|
||||
用于在 Java 类和它的父类或子类之间移动字段和方法。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。这两项由 OpenIDEA 自带的 Java 扩展提供,其他语言不可用。
|
||||
|
||||
## 撤销
|
||||
|
||||
|
||||
@@ -64,7 +64,7 @@ OpenIDEA 会把主题(以及其中附带的编辑器配色方案)转换为
|
||||
- **启用连字**:用于带编程连字的字体。
|
||||
- **排版设置**:**主字重**、**粗体字重**,以及主字体缺少字符时使用的 **备用字体**。
|
||||
|
||||
在当前编辑器中临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置字体大小**(或 **视图 › 重置所有编辑器中的字体大小**)恢复。在 **设置 › 编辑器 › 常规** 中开启 **使用 Ctrl/Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
|
||||
临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置所有编辑器中的字体大小** 恢复。在 macOS 上,开启 **设置 › 编辑器 › 常规** 中的 **使用 Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放。
|
||||
|
||||
### 界面字体与缩放
|
||||
|
||||
|
||||
@@ -100,31 +100,30 @@ optional = ["net:api.openai.com", "secrets"]
|
||||
|
||||
每个贡献点是一张表(`[contributes.settings]`)或一个表数组(`[[contributes.commands]]`)。插件启用后贡献立即生效,不需要等代码加载。
|
||||
|
||||
| 贡献点 | 声明字段 | 需要代码 | 指南 |
|
||||
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
|
||||
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
|
||||
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
|
||||
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
|
||||
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
|
||||
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
|
||||
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
|
||||
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
|
||||
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
|
||||
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
|
||||
| `serverCommands` | `server`、`command`、`run`(API 1.9) | 是 | [README:Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
|
||||
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
|
||||
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
|
||||
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
|
||||
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
|
||||
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
|
||||
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
|
||||
| 贡献点 | 声明字段 | 需要代码 | 指南 |
|
||||
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
|
||||
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
|
||||
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
|
||||
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
|
||||
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
|
||||
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
|
||||
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
|
||||
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
|
||||
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
|
||||
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
|
||||
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
|
||||
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
|
||||
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
|
||||
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
|
||||
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
|
||||
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
|
||||
|
||||
条目 id(命令、视图、主题等)匹配 `[a-z0-9][a-z0-9._-]*`,不超过 64 个字符。菜单、快捷键和状态栏项只能引用插件自己声明的命令;在 IDE 内部,命令的操作 id 是 `plugin.<plugin id>.<command id>`。
|
||||
|
||||
|
||||
@@ -255,8 +255,7 @@ async function selectDraft(page: Page) {
|
||||
}
|
||||
async function chooseModel(page: Page, name: string) {
|
||||
await modelButton(page).click();
|
||||
// A model row also holds its Configure button, whose label joins the option's name.
|
||||
await page.getByRole("option", { name: new RegExp(`^${name}\\b`) }).click();
|
||||
await page.getByRole("option", { name, exact: true }).click();
|
||||
await page.keyboard.press("Escape");
|
||||
await box(page).focus();
|
||||
}
|
||||
|
||||
@@ -761,61 +761,3 @@ test("Find in Conversation skips user-select:none summaries and closed <details>
|
||||
}));
|
||||
expect(expandedHighlights).toEqual({ thoughtOpen: true, findCount: 2, currentCount: 1 });
|
||||
});
|
||||
|
||||
test("keeps ordered, bulleted and task list markers unclipped inside measured rows when zoomed in", async ({
|
||||
page,
|
||||
}) => {
|
||||
const numbered = Array.from({ length: 10 }, (_, i) => `${i + 1}. **Item ${i + 1}**\n - Nested bullet`).join("\n");
|
||||
await openReply(page, `## Feature Gaps\n\n${numbered}\n\n- [x] Checked task\n- [ ] Open task`);
|
||||
await page.evaluate(async (task) => {
|
||||
const storePath = "/src/features/agents/store.ts";
|
||||
const actionsPath = "/src/platform/actions.ts";
|
||||
const store = await import(storePath);
|
||||
const { executeAction } = await import(actionsPath);
|
||||
store.openTaskInEditorLocation(task.id);
|
||||
await new Promise((r) => setTimeout(r, 150));
|
||||
const stream = document.querySelector<HTMLElement>("[class*='_stream_']");
|
||||
stream?.focus();
|
||||
for (let i = 0; i < 12; i++) await executeAction("editor.increaseFontSize");
|
||||
}, TASK);
|
||||
|
||||
const stream = page.locator("[class*='_stream_']:visible");
|
||||
const row = stream.locator("[class*='_conversationRow_'][data-measured]", { has: page.locator("ol") });
|
||||
await expect(row).toBeVisible();
|
||||
|
||||
const bounds = await row.evaluate((rowEl) => {
|
||||
const rowLeft = rowEl.getBoundingClientRect().left;
|
||||
const items = [...rowEl.querySelectorAll<HTMLElement>("ol > li, ul > li")];
|
||||
const markers = items
|
||||
.filter((li) => getComputedStyle(li, "::before").content !== "none")
|
||||
.map((li) => {
|
||||
const rect = li.getBoundingClientRect();
|
||||
const before = getComputedStyle(li, "::before");
|
||||
const lineHeight = Number.parseFloat(getComputedStyle(li).lineHeight);
|
||||
const markerRight = rect.right - Number.parseFloat(before.right);
|
||||
const markerLeft = markerRight - Number.parseFloat(before.width);
|
||||
return {
|
||||
text: li.firstChild?.textContent?.trim() ?? "",
|
||||
offsetFromRowLeft: Math.round((markerLeft - rowLeft) * 100) / 100,
|
||||
singleLine: Number.parseFloat(before.height) <= lineHeight * 1.15,
|
||||
};
|
||||
});
|
||||
const checkboxes = [...rowEl.querySelectorAll<HTMLInputElement>('li > input[type="checkbox"]')].map((input) => ({
|
||||
offsetFromRowLeft: Math.round((input.getBoundingClientRect().left - rowLeft) * 100) / 100,
|
||||
}));
|
||||
return { fontSize: getComputedStyle(streamElement()!).fontSize, markers, checkboxes };
|
||||
function streamElement() {
|
||||
return rowEl.closest<HTMLElement>("[class*='_stream_']");
|
||||
}
|
||||
});
|
||||
|
||||
expect(bounds.fontSize).toBe("25px");
|
||||
expect(bounds.markers.length).toBeGreaterThanOrEqual(10);
|
||||
for (const m of bounds.markers) {
|
||||
expect(m.singleLine, `single-line marker for ${m.text}`).toBe(true);
|
||||
expect(m.offsetFromRowLeft, `marker for ${m.text}`).toBeGreaterThanOrEqual(0);
|
||||
}
|
||||
for (const cb of bounds.checkboxes) {
|
||||
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
|
||||
}
|
||||
});
|
||||
@@ -1,3 +0,0 @@
|
||||
# Per-user IDE state
|
||||
/shelf/
|
||||
/changelists.json
|
||||
@@ -157,7 +157,6 @@ work), but 0.1 code no longer runs: rebuild it against the 1.0 SDK.
|
||||
| `fileIcons` | `id`, `patterns` (file names), `icon` (SVG), `iconDark?` — whatever icon theme is in use | no |
|
||||
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables = [{ name, prompt }]` — New menu | no |
|
||||
| `commitChecks` | `id`, `title` — a before-commit check in Commit Options (see _Commits_) | yes |
|
||||
| `serverCommands` | `server`, `command`, `run` — a language server's client command run by this plugin's command (API 1.9; see _Commands a server hands to the client_) |
|
||||
|
||||
A `viewItem.context` menu needs `view`, the id of one of the plugin's own
|
||||
views. It adds the commands to the right-click menu of the items in that
|
||||
@@ -433,8 +432,6 @@ matching SDK. Released 1.8 plugins keep working. New in 1.9:
|
||||
(Debug runs the configuration and attaches to a process the run starts). See
|
||||
_Environment and debugger_ under _Runs, terminal sessions and test results_.
|
||||
|
||||
- **`[[contributes.serverCommands]]`** routes a command a language server leaves
|
||||
to the client (a code lens's, a code action's) to the plugin's own command.
|
||||
- **Requests to a language server.** `Project::language_server_request` and
|
||||
`language_server_notify` send a running server its own methods, behind the
|
||||
high-risk `lsp:<server>` capability. See _Requests to a language server_.
|
||||
@@ -784,34 +781,6 @@ project.language_server_notify("phoxite", "phoxite/refresh", None)?;
|
||||
is at most 256 bytes, params at most 1 MiB.
|
||||
- The project must be trusted; otherwise the call is `denied`.
|
||||
|
||||
#### Commands a server hands to the client
|
||||
|
||||
A server's code lens, code action or inlay hint can carry a command the server
|
||||
does not execute itself (it is not in its `executeCommandProvider`): the client
|
||||
is meant to. A plugin claims such a command in its manifest, and the IDE runs
|
||||
the plugin's own command instead of failing with "no language server provides
|
||||
command":
|
||||
|
||||
```toml
|
||||
[[contributes.commands]]
|
||||
id = "model-view"
|
||||
title = "Show the Eloquent Model"
|
||||
|
||||
[[contributes.serverCommands]]
|
||||
server = "phoxite" # the server whose results carry the command
|
||||
command = "laravel.modelView" # the command name in the server's result
|
||||
run = "model-view" # this plugin's command
|
||||
```
|
||||
|
||||
- `run` gets the command's `arguments` array as JSON in `arg`, in the window and
|
||||
editor where the lens or action was activated.
|
||||
- The manifest must declare `lsp:<server>`, and the claim counts only while the
|
||||
plugin holds that grant.
|
||||
- A command listed in the server's `executeCommandProvider` still goes to the
|
||||
server.
|
||||
- When two installed plugins claim the same `server` and `command`, the first
|
||||
one loaded keeps it and the conflict is logged.
|
||||
|
||||
In tests, `MockHost::set_language_server_response(server, method, json)` makes
|
||||
a server run and answer, and `language_server_requests()` /
|
||||
`language_server_notifications()` list what the plugin sent.
|
||||
|
||||
@@ -250,7 +250,6 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
|
||||
nav::find_files_named,
|
||||
nav::find_dirs,
|
||||
nav::find_symbols,
|
||||
nav::find_symbols_named,
|
||||
nav::mark_recent,
|
||||
nav::recent_files,
|
||||
nav::remove_recent,
|
||||
|
||||
@@ -24,13 +24,8 @@ pub fn index_file_extensions(window: Window, state: State<'_, AppState>) -> IdeR
|
||||
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn find_files(
|
||||
window: Window,
|
||||
state: State<'_, AppState>,
|
||||
query: String,
|
||||
limit: u32,
|
||||
) -> IdeResult<Vec<FileMatch>> {
|
||||
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit).await
|
||||
pub fn find_files(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
@@ -42,13 +37,8 @@ pub async fn find_files_named(window: Window, state: State<'_, AppState>, name:
|
||||
/// Folders holding indexed files, for `@` references.
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn find_dirs(
|
||||
window: Window,
|
||||
state: State<'_, AppState>,
|
||||
query: String,
|
||||
limit: u32,
|
||||
) -> IdeResult<Vec<FileMatch>> {
|
||||
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit).await
|
||||
pub fn find_dirs(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit)
|
||||
}
|
||||
|
||||
/// Spring Web mapping sources for the request-path index of Search Everywhere.
|
||||
@@ -63,26 +53,14 @@ pub fn spring_route_sources(
|
||||
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn find_symbols(
|
||||
pub fn find_symbols(
|
||||
window: Window,
|
||||
state: State<'_, AppState>,
|
||||
query: String,
|
||||
filter: SymbolFilter,
|
||||
limit: u32,
|
||||
) -> IdeResult<Vec<SymbolMatch>> {
|
||||
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit).await
|
||||
}
|
||||
|
||||
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder).
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn find_symbols_named(
|
||||
window: Window,
|
||||
state: State<'_, AppState>,
|
||||
names: Vec<String>,
|
||||
within: IpcPath,
|
||||
) -> IdeResult<Vec<SymbolMatch>> {
|
||||
ide_host::ops::nav::find_symbols_named(&state.host, window.label(), names, within).await
|
||||
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
|
||||
@@ -439,8 +439,7 @@ pub fn spec(os: Os) -> Vec<Entry> {
|
||||
SEP,
|
||||
act("view.quickSwitchScheme", "Quick Switch Scheme…"),
|
||||
SEP,
|
||||
act("editor.resetFontSize", "Reset Font Size"),
|
||||
act("editor.resetFontSizeAll", "Reset Font Size in All Editors"),
|
||||
act("editor.resetFontSize", "Reset Font Size in All Editors"),
|
||||
SEP,
|
||||
act("view.notifications", "Notifications"),
|
||||
],
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
//! Tauri runs a command declared without `async` on the main thread, so disk I/O or a
|
||||
//! large diff there freezes the window (input, painting, every other IPC call).
|
||||
|
||||
/// Commands that read or write project files, Local History or `.env` files, diff two
|
||||
/// arbitrary texts, or scan the project index in parallel: they must be `async` and do
|
||||
/// that work on the blocking pool.
|
||||
/// Commands that read or write project files, Local History or `.env` files, or diff two
|
||||
/// arbitrary texts: they must be `async` and do that work on the blocking pool.
|
||||
const OFF_MAIN_THREAD: &[(&str, &[&str])] = &[
|
||||
("doc.rs", &["history_list", "history_content"]),
|
||||
("nav.rs", &["find_files", "find_dirs", "find_symbols"]),
|
||||
(
|
||||
"vcs.rs",
|
||||
&[
|
||||
|
||||
@@ -216,11 +216,10 @@ docker_snapshot trusted desktop bin
|
||||
end_process trusted desktop bindings async
|
||||
env_reload always project_host bindings async
|
||||
file_dialog_needs_gtk trusted desktop bindings async
|
||||
find_dirs always project_host bindings async
|
||||
find_files always project_host bindings async
|
||||
find_dirs always project_host bindings sync
|
||||
find_files always project_host bindings sync
|
||||
find_files_named always project_host bindings async
|
||||
find_symbols always project_host bindings async
|
||||
find_symbols_named always project_host bindings async
|
||||
find_symbols always project_host bindings sync
|
||||
fs_compare_directories always project_host bindings async
|
||||
fs_copy always project_host bindings async
|
||||
fs_copy_merge always project_host bindings async
|
||||
|
||||
@@ -491,8 +491,6 @@ export const commands = {
|
||||
/** Folders holding indexed files, for `@` references. */
|
||||
findDirs: (query: string, limit: number) => typedError<FileMatch[], IdeError>(__TAURI_INVOKE("find_dirs", { query, limit })),
|
||||
findSymbols: (query: string, filter: SymbolFilter, limit: number) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols", { query, filter, limit })),
|
||||
/** Index symbols named exactly one of `names` inside `within` (an agent task's folder). */
|
||||
findSymbolsNamed: (names: string[], within: IpcPath) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols_named", { names, within })),
|
||||
markRecent: (path: string) => typedError<null, IdeError>(__TAURI_INVOKE("mark_recent", { path })),
|
||||
/** Recently opened files, most recent first (⌘E). */
|
||||
recentFiles: () => typedError<IpcPath[], IdeError>(__TAURI_INVOKE("recent_files")),
|
||||
@@ -4901,8 +4899,6 @@ export type EditorConfigProps = {
|
||||
export type EditorGeneralSettings = {
|
||||
/** Change font size with ⌘ + mouse wheel. */
|
||||
wheelZoom?: boolean,
|
||||
/** Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors. */
|
||||
wheelZoomScope?: string,
|
||||
markdownImageFolder?: string,
|
||||
markdownImageNamePattern?: string,
|
||||
/** Drag-and-drop of selected text inside the editor. */
|
||||
@@ -5727,11 +5723,6 @@ export type GitSettings = {
|
||||
pushDialogOnlyProtected?: boolean,
|
||||
/** Stashes and shelves share one tab. */
|
||||
combineStashAndShelf?: boolean,
|
||||
/**
|
||||
* The non-modal Commit tool window works on the index: Staged / Unstaged groups,
|
||||
* stage and unstage instead of inclusion checkboxes, and no change lists.
|
||||
*/
|
||||
stagingArea?: boolean,
|
||||
};
|
||||
|
||||
export type GoBuildTags = {
|
||||
|
||||
@@ -8,7 +8,7 @@ import { acceptCompletion, completionStatus } from "@codemirror/autocomplete";
|
||||
import { executeAction, registerActions, type Action } from "@/platform/actions";
|
||||
import { getContext } from "@/platform/context";
|
||||
import { focusedSoftWrapSurface } from "@/workbench/softWrap";
|
||||
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom, stepSurfaceFontZoomIn } from "@/workbench/contributions";
|
||||
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom } from "@/workbench/contributions";
|
||||
import { editorController, useGotoLine, useTabs } from "./controller";
|
||||
import {
|
||||
addCaretsToLineEnds,
|
||||
@@ -71,7 +71,7 @@ import { copyReferenceToClipboard, declaredName, qualifiedReference, referenceOf
|
||||
import { declarationChain } from "./view/outline";
|
||||
import { recordClipboard } from "./clipboardHistory";
|
||||
import { useDocMeta, useOutline } from "./model/document";
|
||||
import { resetAllEditorsFontZoom, resetConfiguredEditorsFontZoom, stepConfiguredEditorsFontZoom } from "./cm/prefs";
|
||||
import { resetAllEditorsFontZoom, stepAllEditorsFontZoom } from "./cm/prefs";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { call, commands } from "@/platform/ipc";
|
||||
import { editorPrefs } from "@/platform/editorSettings";
|
||||
@@ -117,12 +117,7 @@ function withView(run: (view: EditorView, slot: EditorSlot) => unknown) {
|
||||
};
|
||||
}
|
||||
|
||||
function activePaneEditorFocus(): Element | null {
|
||||
if (typeof document === "undefined") return null;
|
||||
return document.querySelector(`[data-pane-id="${useTabs.getState().activePane}"] [data-editor-focus]`);
|
||||
}
|
||||
|
||||
/** Routes keyboard font zoom to focus, then the active editor slot or pane surface. */
|
||||
/** Routes keyboard font zoom to focus, then the active editor slot. */
|
||||
function stepSurfaceFontSize(delta: 1 | -1): void {
|
||||
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
|
||||
if (activeEl) {
|
||||
@@ -131,55 +126,18 @@ function stepSurfaceFontSize(delta: 1 | -1): void {
|
||||
if (cmEl) {
|
||||
const cmView = EditorView.findFromDOM(cmEl);
|
||||
if (cmView) {
|
||||
stepConfiguredEditorsFontZoom(cmView, delta);
|
||||
stepAllEditorsFontZoom(cmView, delta);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const slot = activeSlot();
|
||||
if (!slot?.view) {
|
||||
stepSurfaceFontZoomIn(activePaneEditorFocus(), delta);
|
||||
return;
|
||||
}
|
||||
stepConfiguredEditorsFontZoom(slot.view, delta);
|
||||
if (!slot?.view) return;
|
||||
stepAllEditorsFontZoom(slot.view, delta);
|
||||
if (!slot.view.hasFocus && !getContext().popupOpen) slot.view.focus();
|
||||
}
|
||||
|
||||
function resetFontSize(): void {
|
||||
const allScope = editorPrefs().general.wheelZoomScope === "all";
|
||||
const surfaceOpts = allScope ? { isolatedOnly: true } : undefined;
|
||||
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
|
||||
if (activeEl) {
|
||||
if (stepFocusedSurfaceFontZoom(0, surfaceOpts)) return;
|
||||
if (!allScope) {
|
||||
const cmEl = activeEl.closest?.(".cm-editor") as HTMLElement | null;
|
||||
if (cmEl) {
|
||||
const cmView = EditorView.findFromDOM(cmEl);
|
||||
if (cmView) {
|
||||
resetConfiguredEditorsFontZoom(cmView);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const slot = activeSlot();
|
||||
if (!allScope && slot?.view) {
|
||||
resetConfiguredEditorsFontZoom(slot.view);
|
||||
return;
|
||||
}
|
||||
if (!slot?.view && stepSurfaceFontZoomIn(activePaneEditorFocus(), 0, surfaceOpts)) return;
|
||||
if (allScope) resetAllFontSize();
|
||||
}
|
||||
|
||||
function resetAllFontSize(): void {
|
||||
resetAllEditorsFontZoom();
|
||||
if (typeof document !== "undefined") {
|
||||
resetSurfaceFontZoom();
|
||||
}
|
||||
}
|
||||
|
||||
// --- extend / shrink selection ---------------------------------------------------
|
||||
|
||||
/** One stack per selection range (by index): ⌥↑ / ⌥↓ work on every caret. */
|
||||
@@ -976,19 +934,16 @@ export function registerEditorActions(): () => void {
|
||||
},
|
||||
{
|
||||
id: "editor.resetFontSize",
|
||||
title: "Reset Font Size",
|
||||
category: "View",
|
||||
keywords: ["zoom", "font size", "mouse wheel"],
|
||||
when: "projectOpen",
|
||||
run: resetFontSize,
|
||||
},
|
||||
{
|
||||
id: "editor.resetFontSizeAll",
|
||||
title: "Reset Font Size in All Editors",
|
||||
category: "View",
|
||||
keywords: ["zoom", "font size", "mouse wheel"],
|
||||
when: "projectOpen",
|
||||
run: resetAllFontSize,
|
||||
run: () => {
|
||||
resetAllEditorsFontZoom();
|
||||
if (typeof document !== "undefined") {
|
||||
resetSurfaceFontZoom();
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "editor.increaseFontSize",
|
||||
|
||||
@@ -270,7 +270,7 @@ describe("language modes", () => {
|
||||
}
|
||||
});
|
||||
|
||||
it("colours `this`, `super` and Rust's `self` as keywords", async () => {
|
||||
it("colours `this` and `super` as keywords in Java, JavaScript, TypeScript and C++", async () => {
|
||||
const highlighter = tagHighlighter([
|
||||
{ tag: t.keyword, class: "keyword" },
|
||||
{ tag: t.self, class: "self" },
|
||||
@@ -281,7 +281,6 @@ describe("language modes", () => {
|
||||
["JavaScript", "/p/a.js", "class A extends B { m() { super.m(); this.a = 1; } }", ["super", "this"]],
|
||||
["TypeScript", "/p/a.ts", "class A extends B { m() { super.m(); this.a = 1; } }", ["super", "this"]],
|
||||
["C++", "/p/a.cpp", "void A::m() { this->a = 1; }", ["this"]],
|
||||
["Rust", "/p/a.rs", "impl A { fn m(&self) { self.a = 1; } }", ["self", "self"]],
|
||||
] as const) {
|
||||
const support = await loadSupport(findLanguageDescription(mode, path)!);
|
||||
const found: Array<[string, string]> = [];
|
||||
|
||||
@@ -308,9 +308,8 @@ const EXTRA_TAGS: Record<string, Parameters<typeof styleTags>[0]> = {
|
||||
JSX: JS_TAGS,
|
||||
TSX: JS_TAGS,
|
||||
Java: JAVA_TAGS,
|
||||
// CLion colours `this` as a keyword, RustRover `self`.
|
||||
// CLion colours `this` as a keyword.
|
||||
"C++": { this: t.keyword },
|
||||
Rust: { self: t.keyword },
|
||||
PHP: {
|
||||
"; ,": t.separator,
|
||||
"ClassDeclaration/Name BaseClause/Name InterfaceClause/Name": t.className,
|
||||
|
||||
@@ -37,7 +37,7 @@ import { markdownImages } from "./markdownImages";
|
||||
import { selectionMarks } from "./selectionMarks";
|
||||
import { seamlessSelection } from "./selectionLayer";
|
||||
import { useEditorRegistry } from "@/editor/api";
|
||||
import { editorPrefs, type EditorExtras } from "@/platform/editorSettings";
|
||||
import type { EditorExtras } from "@/platform/editorSettings";
|
||||
import { openideaHighlightStyle } from "./highlight";
|
||||
import {
|
||||
cursorHumpLeft,
|
||||
@@ -426,27 +426,11 @@ export function stepAllEditorsFontZoom(origin: EditorView, delta: number): void
|
||||
}
|
||||
}
|
||||
|
||||
/** Resets one editor's font zoom to 0. */
|
||||
export function resetEditorFontZoom(view: EditorView): void {
|
||||
if (view.state.field(fontZoom, false)) view.dispatch({ effects: setFontZoom.of(0) });
|
||||
}
|
||||
|
||||
/** Resets every open editor's font zoom, and the value new editors start from. */
|
||||
export function resetAllEditorsFontZoom(): void {
|
||||
sharedFontZoom = 0;
|
||||
for (const ed of useEditorRegistry.getState().editors) resetEditorFontZoom(ed.view);
|
||||
}
|
||||
|
||||
/** Steps font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
|
||||
export function stepConfiguredEditorsFontZoom(origin: EditorView, delta: number): void {
|
||||
if (editorPrefs().general.wheelZoomScope === "all") stepAllEditorsFontZoom(origin, delta);
|
||||
else stepFontZoom(origin, delta);
|
||||
}
|
||||
|
||||
/** Resets font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
|
||||
export function resetConfiguredEditorsFontZoom(origin: EditorView): void {
|
||||
if (editorPrefs().general.wheelZoomScope === "all") resetAllEditorsFontZoom();
|
||||
else resetEditorFontZoom(origin);
|
||||
for (const ed of useEditorRegistry.getState().editors)
|
||||
if (ed.view.state.field(fontZoom, false)) ed.view.dispatch({ effects: setFontZoom.of(0) });
|
||||
}
|
||||
|
||||
/** Exported for tests: the ⌘/Ctrl+wheel handler of the prefs compartment. */
|
||||
@@ -454,7 +438,7 @@ export const wheelZoom = EditorView.domEventHandlers({
|
||||
wheel(e, view) {
|
||||
if (!e.metaKey && !e.ctrlKey) return false;
|
||||
e.preventDefault();
|
||||
stepConfiguredEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
|
||||
stepAllEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
|
||||
return true;
|
||||
},
|
||||
});
|
||||
|
||||
@@ -331,20 +331,12 @@ export class EditorController implements SlotHost {
|
||||
this.disposers.push(
|
||||
useTabs.subscribe((s, previous) => {
|
||||
const open = openKeys(s);
|
||||
const live = new Set<string>();
|
||||
for (const pane of Object.values(s.panes)) for (const tab of pane.tabs) live.add(tab.id);
|
||||
const closed = new Map<string, EditorInput>();
|
||||
const closedTabs: Tab[] = [];
|
||||
for (const pane of Object.values(previous.panes))
|
||||
for (const tab of pane.tabs) {
|
||||
if (!live.has(tab.id)) closedTabs.push(tab);
|
||||
if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
|
||||
}
|
||||
if (!this.replacingProject) {
|
||||
const kinds = useContributions.getState().editorKinds;
|
||||
for (const tab of closedTabs) kinds.get(tab.input.kind)?.onTabClose?.(tab.id, tab.input);
|
||||
for (const input of closed.values()) kinds.get(input.kind)?.onClose?.(input);
|
||||
}
|
||||
for (const tab of pane.tabs) if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
|
||||
if (!this.replacingProject)
|
||||
for (const input of closed.values())
|
||||
useContributions.getState().editorKinds.get(input.kind)?.onClose?.(input);
|
||||
const prev = prevTabs;
|
||||
prevTabs = s;
|
||||
if (
|
||||
|
||||
@@ -2,12 +2,11 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
|
||||
import { EditorState } from "@codemirror/state";
|
||||
import { EditorView } from "@codemirror/view";
|
||||
import { useEditorRegistry, type TextEditorHandle } from "@/editor/api";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { fontZoom, resetAllEditorsFontZoom, setFontZoom, stepAllEditorsFontZoom, wheelZoom } from "./cm/prefs";
|
||||
|
||||
const zoomOf = (view: EditorView) => view.state.field(fontZoom, false);
|
||||
|
||||
describe("editor font zoom (active editor by default, all editors when configured)", () => {
|
||||
describe("shared editor font zoom (#2480)", () => {
|
||||
const handles: TextEditorHandle[] = [];
|
||||
const makeView = (extensions = [fontZoom, wheelZoom]) => {
|
||||
const parent = document.createElement("div");
|
||||
@@ -18,10 +17,7 @@ describe("editor font zoom (active editor by default, all editors when configure
|
||||
handles.push(handle);
|
||||
return view;
|
||||
};
|
||||
beforeEach(() => {
|
||||
resetAllEditorsFontZoom();
|
||||
useProject.setState({ settings: null });
|
||||
});
|
||||
beforeEach(() => resetAllEditorsFontZoom());
|
||||
afterEach(() => {
|
||||
for (const handle of handles) {
|
||||
useEditorRegistry.getState().editors.delete(handle);
|
||||
@@ -30,23 +26,9 @@ describe("editor font zoom (active editor by default, all editors when configure
|
||||
}
|
||||
handles.length = 0;
|
||||
resetAllEditorsFontZoom();
|
||||
useProject.setState({ settings: null });
|
||||
});
|
||||
|
||||
it("zooms only the active editor from ⌘/Ctrl+wheel by default (IDEA parity)", () => {
|
||||
const first = makeView();
|
||||
const second = makeView();
|
||||
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
|
||||
expect(zoomOf(first)).toBe(1);
|
||||
expect(zoomOf(second)).toBe(0);
|
||||
expect(zoomOf(makeView())).toBe(0);
|
||||
second.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: 10 }));
|
||||
expect(zoomOf(first)).toBe(1);
|
||||
expect(zoomOf(second)).toBe(-1);
|
||||
});
|
||||
|
||||
it("zooms every open editor from ⌘/Ctrl+wheel when wheelZoomScope is 'all' (#2480)", () => {
|
||||
useProject.setState({ settings: { editor: { general: { wheelZoomScope: "all" } } } } as never);
|
||||
it("zooms every open editor from ⌘/Ctrl+wheel on one of them", () => {
|
||||
const first = makeView();
|
||||
const second = makeView();
|
||||
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
|
||||
|
||||
@@ -13,8 +13,6 @@ import {
|
||||
import { _provideCodePreview, _provideDocumentAttacher, editorsFor } from "@/editor/api";
|
||||
import { isUntitledUri } from "@/platform/virtualDocs";
|
||||
import { formatDocument } from "@/editor/lsp/format";
|
||||
import { chooserTitle, locationItems, pinToFind } from "@/editor/lsp/navigation";
|
||||
import { openPopup } from "@/editor/lsp/popupStore";
|
||||
import { editorController } from "./controller";
|
||||
import { attachDocument } from "./model/attachment";
|
||||
import { previewExtensions } from "./cm/preview";
|
||||
@@ -66,14 +64,6 @@ export function activate(): void | (() => void) {
|
||||
forgetSavedTabs: () => ctrl.forgetSavedTabs(),
|
||||
keepSavedTabs: () => ctrl.keepSavedTabs(),
|
||||
documentHistory: (command) => ctrl.documentHistory(command),
|
||||
chooseDeclaration: async (targets, name, anchor) =>
|
||||
openPopup({
|
||||
kind: "list",
|
||||
anchor,
|
||||
title: chooserTitle("declaration", name, targets.length),
|
||||
items: await locationItems(targets),
|
||||
pin: pinToFind(name, targets),
|
||||
}),
|
||||
reformat: async (path) => {
|
||||
const handle = editorsFor(path)[0];
|
||||
return !!handle && (await formatDocument(handle.view, { explicit: false, selectionOnly: false })).applied;
|
||||
|
||||
@@ -12,13 +12,11 @@ afterEach(() => {
|
||||
describe("custom editor close lifecycle", () => {
|
||||
it("notifies once when the last split showing an input closes", async () => {
|
||||
const close = vi.fn();
|
||||
const tabClose = vi.fn();
|
||||
const dispose = registerEditorKind({
|
||||
kind: "close-probe",
|
||||
title: () => "Probe",
|
||||
component: () => null,
|
||||
onClose: close,
|
||||
onTabClose: tabClose,
|
||||
});
|
||||
controller = new EditorController(createMemoryBackend({}));
|
||||
controller.start();
|
||||
@@ -28,14 +26,9 @@ describe("custom editor close lifecycle", () => {
|
||||
controller.split(useTabs.getState().activePane, "row");
|
||||
const panes = Object.values(useTabs.getState().panes);
|
||||
expect(panes).toHaveLength(2);
|
||||
const firstTabId = panes[0]!.tabs[0]!.id;
|
||||
const secondTabId = panes[1]!.tabs[0]!.id;
|
||||
await controller.closeTab(panes[0]!.id, firstTabId);
|
||||
expect(tabClose).toHaveBeenCalledExactlyOnceWith(firstTabId, input);
|
||||
await controller.closeTab(panes[0]!.id, panes[0]!.tabs[0]!.id);
|
||||
expect(close).not.toHaveBeenCalled();
|
||||
await controller.closeInput(input.key);
|
||||
expect(tabClose).toHaveBeenCalledTimes(2);
|
||||
expect(tabClose).toHaveBeenLastCalledWith(secondTabId, input);
|
||||
expect(close).toHaveBeenCalledExactlyOnceWith(input);
|
||||
} finally {
|
||||
dispose();
|
||||
|
||||
@@ -21,7 +21,6 @@ import {
|
||||
prepareMenuGroups,
|
||||
textEditorWrapperFor,
|
||||
EditorShownProvider,
|
||||
EditorTabIdProvider,
|
||||
useContributions,
|
||||
useFileDecorations,
|
||||
useEditorDocumentRevision,
|
||||
@@ -480,11 +479,9 @@ function KindEditor({ tab, shown, kept = false }: { tab: Tab; shown: boolean; ke
|
||||
tabIndex={-1}
|
||||
aria-hidden={shown ? undefined : true}
|
||||
>
|
||||
<EditorTabIdProvider value={tab.id}>
|
||||
<EditorShownProvider value={shown}>
|
||||
<Component input={tab.input} />
|
||||
</EditorShownProvider>
|
||||
</EditorTabIdProvider>
|
||||
<EditorShownProvider value={shown}>
|
||||
<Component input={tab.input} />
|
||||
</EditorShownProvider>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -135,21 +135,6 @@ describe("list popup", () => {
|
||||
expect(onClose).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it("focuses the rows, not the header's pin button, when it opens", () => {
|
||||
openPopup({
|
||||
kind: "list",
|
||||
anchor: { x: 0, y: 0 },
|
||||
title: "Choose Declaration of foo (2 found)",
|
||||
items: [
|
||||
{ id: "a", label: "foo", run: vi.fn() },
|
||||
{ id: "b", label: "foo", run: vi.fn() },
|
||||
],
|
||||
pin: { label: "Open in Find Tool Window", run: vi.fn() },
|
||||
});
|
||||
render(<LspPopups />);
|
||||
expect(document.activeElement).toBe(screen.getByRole("listbox"));
|
||||
});
|
||||
|
||||
it("pins the results elsewhere from the header button", () => {
|
||||
const pin = vi.fn();
|
||||
openPopup({
|
||||
|
||||
@@ -210,7 +210,6 @@ function ListPopup({ popup }: { popup: Extract<LspPopup, { kind: "list" }> }) {
|
||||
activeIndex={activeIndex}
|
||||
onActiveChange={setActive}
|
||||
hoverSelects
|
||||
autoFocus
|
||||
aria-label={popup.title}
|
||||
onActivate={(r) => activate(r.item)}
|
||||
empty={
|
||||
|
||||
@@ -64,11 +64,6 @@ describe("semanticRanges", () => {
|
||||
]);
|
||||
});
|
||||
|
||||
it("colours rust-analyzer's `self` as a keyword", () => {
|
||||
const input = { tokenTypes: ["selfKeyword"], tokenModifiers: [], data: [0, 0, 3, 0, 0] };
|
||||
expect(semanticRanges(doc, input)[0]?.className).toBe("cm-sem-keyword");
|
||||
});
|
||||
|
||||
it("colours a constructor (jdtls: class + `constructor`) as a function", () => {
|
||||
const input = { tokenTypes: ["class"], tokenModifiers: ["constructor", "declaration"], data: [0, 0, 3, 0, 0b11] };
|
||||
expect(semanticRanges(doc, input)[0]?.className).toBe("cm-sem-function cm-sem-declaration");
|
||||
|
||||
@@ -61,8 +61,7 @@ const TYPE_CLASS: Record<string, string> = {
|
||||
lifetime: "annotation",
|
||||
selfParameter: "self",
|
||||
clsParameter: "self",
|
||||
// rust-analyzer's `self`: RustRover colours the self parameter as a keyword.
|
||||
selfKeyword: "keyword",
|
||||
selfKeyword: "self",
|
||||
};
|
||||
|
||||
const MODIFIER_CLASS: Record<string, string> = {
|
||||
|
||||
@@ -41,8 +41,8 @@ import {
|
||||
import { safeDelete } from "./safeDelete";
|
||||
import { startHierarchyRefactoring } from "./hierarchy";
|
||||
|
||||
/** Languages with a server that runs the class-hierarchy refactorings (the app-owned JDT extension; Phoxite for PHP). */
|
||||
const HIERARCHY_LANGUAGES = new Set(["java", "php"]);
|
||||
/** Languages whose server runs the class-hierarchy refactorings (the app-owned JDT extension). */
|
||||
const HIERARCHY_LANGUAGES = new Set(["java"]);
|
||||
|
||||
/** Outcome of the server query: its answer, or why there is none. */
|
||||
export type ServerAnswer =
|
||||
|
||||
@@ -30,7 +30,7 @@
|
||||
.field :global(.cm-editor) {
|
||||
background: transparent;
|
||||
color: var(--fg-strong);
|
||||
font-size: var(--agent-fs-ui, var(--fs-ui));
|
||||
font-size: var(--fs-ui);
|
||||
}
|
||||
.field :global(.cm-editor.cm-focused) {
|
||||
outline: none;
|
||||
|
||||
@@ -1,7 +1,4 @@
|
||||
.home {
|
||||
--agent-fs-ui: calc(var(--fs-ui) + var(--agent-font-zoom, 0px));
|
||||
--agent-fs-small: calc(var(--fs-small) + var(--agent-font-zoom, 0px));
|
||||
--agent-fs-code: calc(var(--fs-code) + var(--agent-font-zoom, 0px));
|
||||
flex: 1;
|
||||
min-height: 0;
|
||||
overflow: auto;
|
||||
@@ -25,7 +22,7 @@
|
||||
}
|
||||
.heading {
|
||||
margin: 0 0 10px;
|
||||
font-size: calc(18px + var(--agent-font-zoom, 0px));
|
||||
font-size: 18px;
|
||||
font-weight: 600;
|
||||
text-align: center;
|
||||
color: var(--fg-strong);
|
||||
|
||||
@@ -14,8 +14,7 @@ import { SubmitButton } from "./SubmitButton";
|
||||
import { canSend, emptyDraft } from "./composerModel";
|
||||
import { ConfigPickers } from "./ConfigPickers";
|
||||
import { useEffortFocus } from "./effortFocus";
|
||||
import { useAgentFontZoomSurface } from "./fontZoom";
|
||||
import { HOME_KEY, providerIcon } from "./model";
|
||||
import { providerIcon } from "./model";
|
||||
import { ADD_AGENT, providerOptions as agentOptions } from "./providerOptions";
|
||||
import {
|
||||
HOME,
|
||||
@@ -32,7 +31,7 @@ import {
|
||||
import { useAgentSettings } from "./agentSettings";
|
||||
import styles from "./Home.module.css";
|
||||
|
||||
export function HomeEditor({ docked = false, input }: { docked?: boolean; input?: EditorInput }) {
|
||||
export function HomeEditor({ docked = false }: { docked?: boolean; input?: EditorInput }) {
|
||||
const tx = useTx();
|
||||
const txTemplate = useTxTemplate();
|
||||
const draft = useAgents((s) => s.draft);
|
||||
@@ -98,7 +97,6 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input?
|
||||
const { defaults, fitWindowWidth } = useAgentSettings();
|
||||
const config = draftConfig(provider, draft, (provider && defaults[provider.id]) || {});
|
||||
const homeRoot = useRef<HTMLDivElement>(null);
|
||||
const { zoomStyle } = useAgentFontZoomSurface(homeRoot, input?.key ?? HOME_KEY, docked);
|
||||
const unavailableModel = config.some(
|
||||
(o) =>
|
||||
o.category === "model" &&
|
||||
@@ -129,11 +127,7 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input?
|
||||
};
|
||||
|
||||
return (
|
||||
<div
|
||||
ref={homeRoot}
|
||||
className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}
|
||||
style={zoomStyle}
|
||||
>
|
||||
<div ref={homeRoot} className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}>
|
||||
<div className={styles.inner}>
|
||||
{!docked && (
|
||||
<h1 className={styles.heading}>
|
||||
|
||||
@@ -3,20 +3,17 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { clearMocks, mockIPC } from "@tauri-apps/api/mocks";
|
||||
import { resetMermaidForTests } from "../viewers/markdown/mermaid";
|
||||
import { StrictMode } from "react";
|
||||
import { useProject } from "@/platform/project";
|
||||
import type { SymbolMatch } from "@/platform/ipc";
|
||||
import { Markdown, markdownBlocks, markdownHtml } from "./Markdown";
|
||||
|
||||
const { openFile, chooseDeclaration, openExternalUrl } = vi.hoisted(() => ({
|
||||
const { openFile, openExternalUrl } = vi.hoisted(() => ({
|
||||
openFile: vi.fn().mockResolvedValue(undefined),
|
||||
chooseDeclaration: vi.fn().mockResolvedValue(undefined),
|
||||
openExternalUrl: vi.fn().mockResolvedValue(undefined),
|
||||
}));
|
||||
const copyText = vi.hoisted(() => vi.fn());
|
||||
const readImage = vi.fn<(path: string) => Promise<string>>();
|
||||
const PIXEL = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
|
||||
vi.mock("@/workbench/contributions", () => ({
|
||||
editorService: () => ({ openFile, chooseDeclaration }),
|
||||
editorService: () => ({ openFile }),
|
||||
}));
|
||||
vi.mock("@/platform/openUrl", () => ({ openExternalUrl }));
|
||||
vi.mock("@/ui", async (importOriginal) => ({
|
||||
@@ -352,86 +349,3 @@ describe("streamed replies", () => {
|
||||
expect(container.textContent?.trim()).toBe("Something else");
|
||||
});
|
||||
});
|
||||
|
||||
describe("symbol links", () => {
|
||||
const symbol = (name: string, path: string, line: number): SymbolMatch => ({
|
||||
name,
|
||||
kind: "class",
|
||||
container: null,
|
||||
path,
|
||||
relPath: path.slice("/repo/".length),
|
||||
range: { start: { line, col: 6 }, end: { line, col: 6 + name.length } },
|
||||
score: 0,
|
||||
indices: [],
|
||||
});
|
||||
const index = [
|
||||
symbol("FooView", "/repo/src/view.ts", 4),
|
||||
symbol("BarView", "/repo/src/bar.ts", 1),
|
||||
symbol("BarView", "/repo/web/bar.ts", 9),
|
||||
symbol("StreamView", "/repo/src/stream.ts", 2),
|
||||
symbol("SinkView", "/repo/src/sink.ts", 1),
|
||||
symbol("SinkView", "/repo/web/sink.ts", 7),
|
||||
];
|
||||
let lookups: string[][];
|
||||
|
||||
beforeEach(() => {
|
||||
lookups = [];
|
||||
useProject.setState({ project: { root: "/repo" } as never });
|
||||
mockIPC((cmd, args) => {
|
||||
if (cmd === "fs_probe") throw new Error("missing");
|
||||
if (cmd !== "find_symbols_named") return null;
|
||||
const { names } = args as { names: string[] };
|
||||
lookups.push(names);
|
||||
return index.filter((symbol) => names.includes(symbol.name));
|
||||
});
|
||||
});
|
||||
afterEach(() => useProject.setState({ project: null }));
|
||||
|
||||
const code = (container: HTMLElement, text: string) =>
|
||||
[...container.querySelectorAll<HTMLElement>("code")].find((span) => span.textContent === text)!;
|
||||
|
||||
it("opens the one definition a name has, and leaves other code plain", async () => {
|
||||
const { container } = render(<Markdown text={"`FooView` runs `cargo test`, see `Missing`."} cwd="/repo/one" />);
|
||||
await waitFor(() => expect(code(container, "FooView").dataset.path).toBe("/repo/src/view.ts"));
|
||||
expect(code(container, "cargo test").dataset.path).toBeUndefined();
|
||||
expect(code(container, "Missing").dataset.path).toBeUndefined();
|
||||
expect(lookups).toEqual([["FooView", "Missing"]]);
|
||||
fireEvent.click(code(container, "FooView"));
|
||||
expect(openFile).toHaveBeenCalledWith("/repo/src/view.ts", { focus: true, selection: { line: 4, col: 6 } });
|
||||
});
|
||||
|
||||
it("looks a streamed reply's names up once, after its text settles", async () => {
|
||||
const reply = "First `StreamView`.\n\nThen `SinkView` in `web/sink.ts` and `StreamView` again.";
|
||||
const { container, rerender } = render(<Markdown text={reply.slice(0, 10)} cwd="/repo/two" />);
|
||||
for (let end = 12; end <= reply.length; end += 6) rerender(<Markdown text={reply.slice(0, end)} cwd="/repo/two" />);
|
||||
rerender(<Markdown text={reply} cwd="/repo/two" />);
|
||||
await waitFor(() => expect(code(container, "SinkView").dataset.path).toBe("/repo/web/sink.ts"));
|
||||
expect(lookups).toEqual([["StreamView", "SinkView"]]);
|
||||
rerender(<Markdown text={`${reply}\n\nDone with \`StreamView\`.`} cwd="/repo/two" />);
|
||||
await new Promise((resolve) => setTimeout(resolve, 600));
|
||||
expect(lookups).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("shows Go to Declaration's chooser when several files define the name", async () => {
|
||||
const { container } = render(<Markdown text={"Both define `BarView`."} cwd="/repo" />);
|
||||
await waitFor(() => expect(code(container, "BarView").className).not.toBe(""));
|
||||
expect(code(container, "BarView").dataset.path).toBeUndefined();
|
||||
fireEvent.click(code(container, "BarView"));
|
||||
expect(openFile).not.toHaveBeenCalled();
|
||||
expect(chooseDeclaration).toHaveBeenCalledWith(
|
||||
[expect.objectContaining({ path: "/repo/src/bar.ts" }), expect.objectContaining({ path: "/repo/web/bar.ts" })],
|
||||
"BarView",
|
||||
expect.objectContaining({ x: expect.any(Number), y: expect.any(Number) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("keeps a file a span names over a symbol of the same name", async () => {
|
||||
mockIPC((cmd, args) => {
|
||||
if (cmd === "fs_probe") return null;
|
||||
if (cmd === "find_symbols_named") lookups.push((args as { names: string[] }).names);
|
||||
return null;
|
||||
});
|
||||
const { container } = render(<Markdown text={"Open `Config.load`."} cwd="/repo/three" />);
|
||||
await waitFor(() => expect(code(container, "Config.load").dataset.path).toBe("/repo/three/Config.load"));
|
||||
});
|
||||
});
|
||||
@@ -1,28 +1,25 @@
|
||||
/**
|
||||
* Agent messages: Markdown → sanitized HTML (marked + DOMPurify). Fenced code is
|
||||
* highlighted and gets a Copy button; inline code naming a file of the task, or a symbol
|
||||
* the index has, opens it.
|
||||
* highlighted and gets a Copy button; inline code naming a file of the task opens it.
|
||||
* Mermaid fences become `[data-mermaid]` placeholders drawn by the Markdown viewer's
|
||||
* shared renderer after each render; the block keeps a Copy button of its own, since
|
||||
* the drawn diagram hides the code block, and `onDiagramDrawn` lets the conversation
|
||||
* follow the end when a diagram draws after the last streamed chunk.
|
||||
*/
|
||||
import { useEffect, useLayoutEffect, useRef, useSyncExternalStore } from "react";
|
||||
import { useLayoutEffect, useRef, useSyncExternalStore } from "react";
|
||||
import { Marked } from "marked";
|
||||
import DOMPurify from "dompurify";
|
||||
import { highlightInto } from "@/editor/lsp/markdown";
|
||||
import { iconNode } from "@/ui/iconNode";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { openExternalUrl } from "@/platform/openUrl";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { copyText } from "@/ui";
|
||||
import { editorService, type DeclarationChoice } from "@/workbench/contributions";
|
||||
import { editorService } from "@/workbench/contributions";
|
||||
import { hasMermaid, renderMermaidIn } from "@/features/viewers/markdown/mermaid";
|
||||
import { subscribeTheme, themeKey } from "@/platform/themeWatch";
|
||||
import { fileHref, pathLink, symbolRef, type PathLink, type SymbolRef } from "./conversation";
|
||||
import { fileHref, pathLink, type PathLink } from "./conversation";
|
||||
import { loadImages, type MessageImages } from "./markdownImages";
|
||||
import { fileExists } from "./ReferenceChip";
|
||||
import { inTaskFolder, lookupSymbols, symbolTargets } from "./symbolLinks";
|
||||
import styles from "./Session.module.css";
|
||||
|
||||
const escapeHtml = (s: string) =>
|
||||
@@ -175,58 +172,6 @@ export function openPathLink(link: PathLink) {
|
||||
void editorService().openFile(link.path, { selection, focus: true });
|
||||
}
|
||||
|
||||
/** The symbol each inline code span names. */
|
||||
const symbolRefs = new WeakMap<Element, SymbolRef>();
|
||||
/** Whether inline code that names a symbol also names an existing file (which it then opens). */
|
||||
const fileChecks = new WeakMap<Element, Promise<boolean>>();
|
||||
/** Inline code naming a symbol defined in several places: the chooser's targets. */
|
||||
const choices = new WeakMap<Element, DeclarationChoice[]>();
|
||||
/** How long a reply's text stays unchanged before its symbols are looked up. */
|
||||
const SETTLE_MS = 400;
|
||||
|
||||
function mentionedPaths(root: HTMLElement): string[] {
|
||||
const codePaths = [...root.querySelectorAll("code")].map((code) => pathLink(code.textContent ?? "", "")?.path);
|
||||
const linkPaths = [...root.querySelectorAll("a[href]")].map(
|
||||
(anchor) => fileHref(anchor.getAttribute("href") ?? "", "")?.path,
|
||||
);
|
||||
return [...codePaths, ...linkPaths].filter((path): path is string => !!path);
|
||||
}
|
||||
|
||||
function markPath(element: HTMLElement, link: PathLink) {
|
||||
element.classList.add(styles.fileLink!);
|
||||
element.dataset.path = link.path;
|
||||
if (link.line !== undefined) element.dataset.line = String(link.line);
|
||||
if (link.col !== undefined) element.dataset.col = String(link.col);
|
||||
element.title = tx`Open ${link.path}`;
|
||||
}
|
||||
|
||||
/** Links `spans` of the reply in `root` to their definitions: one index lookup for all their names. */
|
||||
async function linkSymbols(root: HTMLElement, spans: HTMLElement[], cwd: string) {
|
||||
const projectRoot = useProject.getState().project?.root ?? cwd;
|
||||
const refs = spans.map((code) => symbolRefs.get(code)!);
|
||||
const answers = lookupSymbols(
|
||||
projectRoot,
|
||||
refs.map((ref) => ref.name),
|
||||
);
|
||||
const mentioned = mentionedPaths(root);
|
||||
await Promise.all(
|
||||
spans.map(async (code, at) => {
|
||||
if (await fileChecks.get(code)) return;
|
||||
const ref = refs[at]!;
|
||||
const found = (await answers.get(ref.name)!).map((symbol) => inTaskFolder(symbol, projectRoot, cwd));
|
||||
const targets = symbolTargets(ref, found, mentioned, cwd);
|
||||
if (!code.isConnected || !targets.length) return;
|
||||
if (targets.length > 1) {
|
||||
code.classList.add(styles.fileLink!);
|
||||
choices.set(code, targets);
|
||||
return;
|
||||
}
|
||||
const { path, range } = targets[0]!;
|
||||
markPath(code, { path, line: range.start.line, col: range.start.col });
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
/** Highlighting, Copy buttons and file links over freshly rendered `root`. */
|
||||
function enhance(root: HTMLElement, cwd: string, images: MessageImages): () => void {
|
||||
let alive = true;
|
||||
@@ -252,15 +197,15 @@ function enhance(root: HTMLElement, cwd: string, images: MessageImages): () => v
|
||||
});
|
||||
root.querySelectorAll<HTMLElement>("code").forEach((code) => {
|
||||
if (code.parentElement?.tagName === "PRE" || code.closest("a")) return;
|
||||
const text = code.textContent ?? "";
|
||||
const ref = symbolRef(text);
|
||||
if (ref) symbolRefs.set(code, ref);
|
||||
const link = pathLink(text, cwd);
|
||||
const link = pathLink(code.textContent ?? "", cwd);
|
||||
if (!link) return;
|
||||
const exists = fileExists(link.path);
|
||||
if (ref) fileChecks.set(code, exists);
|
||||
void exists.then((found) => {
|
||||
if (alive && found) markPath(code, link);
|
||||
void fileExists(link.path).then((exists) => {
|
||||
if (!alive || !exists) return;
|
||||
code.classList.add(styles.fileLink!);
|
||||
code.dataset.path = link.path;
|
||||
if (link.line !== undefined) code.dataset.line = String(link.line);
|
||||
if (link.col !== undefined) code.dataset.col = String(link.col);
|
||||
code.title = tx`Open ${link.path}`;
|
||||
});
|
||||
});
|
||||
return () => {
|
||||
@@ -331,9 +276,6 @@ export function Markdown({
|
||||
const diagrams = useRef<Node[]>([]);
|
||||
// Diagrams are drawn in the active theme's colours: a theme change redraws them.
|
||||
const theme = useSyncExternalStore(subscribeTheme, themeKey, () => "");
|
||||
useLayoutEffect(() => {
|
||||
images.current.onLoaded = onDiagramDrawn;
|
||||
}, [onDiagramDrawn]);
|
||||
useLayoutEffect(() => {
|
||||
const root = ref.current;
|
||||
if (!root) return;
|
||||
@@ -351,39 +293,6 @@ export function Markdown({
|
||||
const blocks = painted.current;
|
||||
return () => clearBlocks(blocks, 0);
|
||||
}, []);
|
||||
/** Symbol spans already looked up (or being looked up). */
|
||||
const looked = useRef(new WeakSet<Element>());
|
||||
// Symbols: once the text stops changing (a streamed reply changes its last block on every
|
||||
// chunk), the spans not looked up yet, as they come into view.
|
||||
useEffect(() => {
|
||||
const root = ref.current;
|
||||
if (!root) return;
|
||||
let observer: IntersectionObserver | null = null;
|
||||
const lookUp = (spans: HTMLElement[]) => {
|
||||
spans.forEach((span) => looked.current.add(span));
|
||||
if (spans.length) void linkSymbols(root, spans, cwd);
|
||||
};
|
||||
const timer = setTimeout(() => {
|
||||
const spans = [...root.querySelectorAll<HTMLElement>("code")].filter(
|
||||
(code) => symbolRefs.has(code) && !looked.current.has(code),
|
||||
);
|
||||
if (!spans.length) return;
|
||||
if (typeof IntersectionObserver === "undefined") {
|
||||
lookUp(spans);
|
||||
return;
|
||||
}
|
||||
observer = new IntersectionObserver((entries) => {
|
||||
const shown = entries.filter((entry) => entry.isIntersecting).map((entry) => entry.target as HTMLElement);
|
||||
shown.forEach((span) => observer!.unobserve(span));
|
||||
lookUp(shown);
|
||||
});
|
||||
spans.forEach((span) => observer!.observe(span));
|
||||
}, SETTLE_MS);
|
||||
return () => {
|
||||
clearTimeout(timer);
|
||||
observer?.disconnect();
|
||||
};
|
||||
}, [text, cwd]);
|
||||
// Mermaid diagrams: before paint, so cached ones don't flash their source. Only a
|
||||
// draw that lands after the render needs the follow — cached ones are in place by
|
||||
// the time the conversation's own render pass scrolls.
|
||||
@@ -409,14 +318,6 @@ export function Markdown({
|
||||
void copyText(copy.dataset.copy ?? "");
|
||||
return;
|
||||
}
|
||||
const code = target.closest<HTMLElement>("code");
|
||||
const targets = code && choices.get(code);
|
||||
if (targets && !window.getSelection()?.toString()) {
|
||||
const rect = code.getBoundingClientRect();
|
||||
const name = symbolRefs.get(code)!.name;
|
||||
void editorService().chooseDeclaration?.(targets, name, { x: rect.left, y: rect.bottom + 2 });
|
||||
return;
|
||||
}
|
||||
const file = target.closest<HTMLElement>("code[data-path]");
|
||||
if (file && !window.getSelection()?.toString()) {
|
||||
const line = file.dataset.line === undefined ? undefined : Number(file.dataset.line);
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
align-items: center;
|
||||
gap: var(--space-1);
|
||||
max-width: 100%;
|
||||
height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
|
||||
height: 20px;
|
||||
padding: 0 6px 0 4px;
|
||||
margin: 0 1px;
|
||||
vertical-align: -4px;
|
||||
@@ -12,8 +12,8 @@
|
||||
background: color-mix(in srgb, var(--fg) 9%, transparent);
|
||||
box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--fg) 14%, transparent);
|
||||
color: var(--fg-strong);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
line-height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
|
||||
font-size: var(--fs-small);
|
||||
line-height: 20px;
|
||||
white-space: nowrap;
|
||||
cursor: pointer;
|
||||
user-select: none;
|
||||
@@ -243,7 +243,7 @@
|
||||
padding: 6px 10px;
|
||||
color: var(--fg-editor);
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
line-height: 1.5;
|
||||
white-space: pre;
|
||||
overflow-x: auto;
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
.session {
|
||||
--session-content-width: var(--agent-conversation-width);
|
||||
--session-card-width: 80%;
|
||||
--agent-fs-ui: calc(var(--fs-ui) + var(--agent-font-zoom, 0px));
|
||||
--agent-fs-small: calc(var(--fs-small) + var(--agent-font-zoom, 0px));
|
||||
--agent-fs-code: calc(var(--fs-code) + var(--agent-font-zoom, 0px));
|
||||
flex: 1;
|
||||
min-height: 0;
|
||||
min-width: 0;
|
||||
@@ -255,7 +252,6 @@
|
||||
padding: var(--space-3);
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
font-size: var(--agent-fs-ui, var(--fs-ui));
|
||||
}
|
||||
/* Actual row heights keep WebKit's scrollbar and cross-message selections anchored. */
|
||||
.stream > * {
|
||||
@@ -326,7 +322,7 @@
|
||||
-webkit-user-select: none;
|
||||
user-select: none;
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
white-space: nowrap;
|
||||
}
|
||||
.messageHead > .role {
|
||||
@@ -361,7 +357,7 @@
|
||||
gap: 5px;
|
||||
margin-bottom: 3px;
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
-webkit-user-select: none;
|
||||
user-select: none;
|
||||
}
|
||||
@@ -555,7 +551,7 @@
|
||||
}
|
||||
.markdown :global(code) {
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
padding: 0 2px;
|
||||
border-radius: 3px;
|
||||
background: var(--md-code-bg);
|
||||
@@ -624,19 +620,12 @@
|
||||
display: none;
|
||||
}
|
||||
.markdown :global(.mermaid-output) {
|
||||
overflow-x: auto;
|
||||
overflow-y: hidden;
|
||||
overflow: hidden;
|
||||
text-align: center;
|
||||
/* Node labels are drawing, not text: selecting across a reply skips them. */
|
||||
-webkit-user-select: none;
|
||||
user-select: none;
|
||||
}
|
||||
.markdown :global(.mermaid-output svg[data-natural-width]) {
|
||||
display: block;
|
||||
margin: 0 auto;
|
||||
width: calc(min(var(--diagram-width), 100%) * var(--markdown-zoom-scale, 1));
|
||||
height: auto;
|
||||
}
|
||||
.markdown :global([data-mermaid-state="error"] > .mermaid-output) {
|
||||
margin-top: 6px;
|
||||
padding: 6px 10px;
|
||||
@@ -645,7 +634,7 @@
|
||||
background: var(--bg-elev);
|
||||
color: var(--danger);
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
text-align: left;
|
||||
white-space: pre-wrap;
|
||||
}
|
||||
@@ -659,17 +648,10 @@
|
||||
|
||||
.markdown :global(ul),
|
||||
.markdown :global(ol) {
|
||||
--md-list-indent: 1.55em;
|
||||
margin: 0 0 8px;
|
||||
padding-left: var(--md-list-indent);
|
||||
padding-left: 20px;
|
||||
list-style: none;
|
||||
}
|
||||
.markdown :global(ol) {
|
||||
--md-list-indent: 2.1em;
|
||||
}
|
||||
.markdown :global(ol:has(> li:nth-child(100))) {
|
||||
--md-list-indent: 2.75em;
|
||||
}
|
||||
/* Markers are drawn as pseudo-elements: WebKit paints a selection box around a native marker,
|
||||
leaving a broken stripe down the gutter when a list is selected. */
|
||||
.markdown :global(li) {
|
||||
@@ -677,8 +659,7 @@
|
||||
}
|
||||
.markdown :global(li)::before {
|
||||
position: absolute;
|
||||
right: calc(100% + 0.45em);
|
||||
white-space: nowrap;
|
||||
right: calc(100% + 6px);
|
||||
-webkit-user-select: none;
|
||||
user-select: none;
|
||||
}
|
||||
@@ -740,11 +721,7 @@
|
||||
border-top: 1px solid var(--border);
|
||||
}
|
||||
.markdown :global(img) {
|
||||
max-width: calc(100% * var(--markdown-zoom-scale, 1));
|
||||
}
|
||||
.markdown :global(img[data-natural-width]) {
|
||||
width: calc(min(var(--image-width), 100%) * var(--markdown-zoom-scale, 1));
|
||||
height: auto;
|
||||
max-width: 100%;
|
||||
}
|
||||
.loadImage {
|
||||
padding: 2px 8px;
|
||||
@@ -759,7 +736,7 @@
|
||||
background: var(--bg-hover);
|
||||
}
|
||||
.markdown :global(li:has(> input[type="checkbox"])) {
|
||||
margin-left: calc(-1 * var(--md-list-indent));
|
||||
margin-left: -20px;
|
||||
}
|
||||
.markdown :global(li:has(> input[type="checkbox"]))::before {
|
||||
content: none;
|
||||
@@ -785,9 +762,9 @@
|
||||
align-items: center;
|
||||
gap: var(--space-1);
|
||||
min-width: 0;
|
||||
min-height: var(--h-row);
|
||||
height: var(--h-row);
|
||||
color: var(--fg-muted);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
-webkit-user-select: none;
|
||||
user-select: none;
|
||||
}
|
||||
@@ -840,7 +817,7 @@
|
||||
}
|
||||
.toolTitle {
|
||||
min-width: 0;
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
@@ -853,7 +830,7 @@
|
||||
}
|
||||
.toolDiff {
|
||||
font: inherit;
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
border: 0;
|
||||
background: none;
|
||||
padding: 0 4px;
|
||||
@@ -884,7 +861,7 @@
|
||||
padding: 0 calc(var(--space-2) / 2);
|
||||
border-radius: var(--radius-row);
|
||||
color: var(--fg-muted);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
-webkit-user-select: none;
|
||||
user-select: none;
|
||||
}
|
||||
@@ -940,7 +917,7 @@
|
||||
border: 1px solid var(--border);
|
||||
background: var(--bg-elev);
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
white-space: pre-wrap;
|
||||
overflow-wrap: anywhere;
|
||||
color: var(--fg-secondary);
|
||||
@@ -997,7 +974,7 @@
|
||||
.permissionCommand {
|
||||
min-width: 0;
|
||||
max-width: 100%;
|
||||
max-height: calc((var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6) * 6);
|
||||
max-height: calc(var(--lh-code) * 6);
|
||||
box-sizing: border-box;
|
||||
margin: 0;
|
||||
padding: var(--space-2);
|
||||
@@ -1007,8 +984,8 @@
|
||||
background: var(--bg-editor);
|
||||
color: var(--fg);
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-code, var(--fs-code));
|
||||
line-height: calc(var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6);
|
||||
font-size: var(--fs-code);
|
||||
line-height: var(--lh-code);
|
||||
white-space: pre-wrap;
|
||||
overflow-wrap: anywhere;
|
||||
tab-size: 2;
|
||||
@@ -1046,7 +1023,7 @@
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.permissionDone {
|
||||
padding: calc(var(--space-2) / 2) 0;
|
||||
@@ -1054,7 +1031,7 @@
|
||||
border-radius: var(--radius-small);
|
||||
background: none;
|
||||
color: var(--fg-muted);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.permissionRecord {
|
||||
display: block;
|
||||
@@ -1143,7 +1120,6 @@
|
||||
padding: 0 4px 0 8px;
|
||||
border-radius: var(--radius-row);
|
||||
background: var(--bg-elev);
|
||||
font-size: var(--agent-fs-ui, var(--fs-ui));
|
||||
}
|
||||
.queuedText {
|
||||
flex: 1;
|
||||
@@ -1236,7 +1212,7 @@
|
||||
flex-wrap: wrap;
|
||||
gap: var(--space-1) var(--space-1-5);
|
||||
margin-top: 4px;
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.attachment {
|
||||
display: inline-flex;
|
||||
@@ -1449,7 +1425,7 @@
|
||||
flex: none;
|
||||
margin-left: auto;
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
font-variant-numeric: tabular-nums;
|
||||
white-space: nowrap;
|
||||
}
|
||||
@@ -1457,7 +1433,7 @@
|
||||
padding-left: 22px;
|
||||
color: var(--fg-muted);
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
@@ -1465,7 +1441,7 @@
|
||||
.subagentSection > summary {
|
||||
padding-left: 22px;
|
||||
color: var(--fg-muted);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
cursor: pointer;
|
||||
list-style: none;
|
||||
}
|
||||
@@ -1534,7 +1510,7 @@
|
||||
.messageFrom {
|
||||
margin-bottom: 2px;
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
|
||||
.readOnly {
|
||||
@@ -1591,7 +1567,6 @@
|
||||
border: 1px solid var(--border-strong);
|
||||
border-radius: var(--radius-control);
|
||||
background: var(--bg-elev);
|
||||
font-size: var(--agent-fs-ui, var(--fs-ui));
|
||||
container: question-card / inline-size;
|
||||
}
|
||||
.questionTabCheck {
|
||||
@@ -1642,7 +1617,7 @@
|
||||
border-radius: var(--radius-small);
|
||||
background: var(--bg-hover);
|
||||
color: var(--fg-muted);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.questionLabel .questionTag {
|
||||
margin: 0 0 0 8px;
|
||||
@@ -1699,13 +1674,13 @@
|
||||
}
|
||||
.questionDescription {
|
||||
color: var(--fg-muted);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
.questionKey {
|
||||
flex: none;
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.questionOther {
|
||||
margin: 2px 0 0 30px;
|
||||
@@ -1750,7 +1725,7 @@
|
||||
}
|
||||
.questionPreviewCaption {
|
||||
color: var(--fg-muted);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.questionPreviewBody {
|
||||
margin: 0;
|
||||
@@ -1760,14 +1735,14 @@
|
||||
border-radius: var(--radius-small);
|
||||
background: var(--bg-editor);
|
||||
font-family: var(--font-mono);
|
||||
font-size: var(--agent-fs-code, var(--fs-code));
|
||||
font-size: var(--fs-code);
|
||||
}
|
||||
.questionPreviewEmpty {
|
||||
padding: 8px;
|
||||
border: 1px dashed var(--border);
|
||||
border-radius: var(--radius-small);
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.questionActions {
|
||||
display: flex;
|
||||
@@ -1783,7 +1758,7 @@
|
||||
}
|
||||
.questionPage {
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--agent-fs-small, var(--fs-small));
|
||||
font-size: var(--fs-small);
|
||||
font-variant-numeric: tabular-nums;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
@@ -81,7 +81,6 @@ import {
|
||||
} from "./composerModel";
|
||||
import { ConfigPickers } from "./ConfigPickers";
|
||||
import { useEffortFocus } from "./effortFocus";
|
||||
import { useAgentFontZoomSurface } from "./fontZoom";
|
||||
import { findRanges, formatDuration, formatSentAt, isFindRangeShown } from "./conversation";
|
||||
import { ImagePreview, imageSrc } from "./ImagePreview";
|
||||
import { useAgentSettings } from "./agentSettings";
|
||||
@@ -116,7 +115,6 @@ import {
|
||||
hasTaskTerminal,
|
||||
isBusy,
|
||||
providerIcon,
|
||||
sessionKey,
|
||||
statusLabel,
|
||||
subagentStatusLabel,
|
||||
subagentTitle,
|
||||
@@ -225,7 +223,6 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
|
||||
const [inputFocus, setInputFocus] = useState(0);
|
||||
const { fitWindowWidth } = useAgentSettings();
|
||||
const sessionRoot = useRef<HTMLDivElement>(null);
|
||||
const { fontZoom, zoomStyle } = useAgentFontZoomSurface(sessionRoot, sessionKey(id), docked, !!task);
|
||||
const canFocusInput = shown && !!task && task.status !== "archived" && !view;
|
||||
const session = useMemo<FocusedSession>(
|
||||
() => ({
|
||||
@@ -258,7 +255,7 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
|
||||
changesOpen && !docked && styles.withChanges,
|
||||
fitWindowWidth && styles.fitWidth,
|
||||
)}
|
||||
style={{ ...changesWidth, ...zoomStyle }}
|
||||
style={changesWidth}
|
||||
onFocusCapture={() => shown && setFocusedSession(session)}
|
||||
onBlurCapture={(e) => {
|
||||
if (!e.currentTarget.contains(e.relatedTarget as Node | null) && focusedSession() === session) {
|
||||
@@ -294,7 +291,6 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
|
||||
onOpenSubagent={openSubagent}
|
||||
finding={finding && shown}
|
||||
findFocus={findFocus}
|
||||
fontZoom={fontZoom}
|
||||
onCloseFind={() => setFinding(false)}
|
||||
/>
|
||||
</FoldedContent.Provider>
|
||||
@@ -615,10 +611,9 @@ function useOffscreenRows(
|
||||
visible: boolean,
|
||||
enabled: boolean,
|
||||
fitWindowWidth: boolean,
|
||||
fontZoom: number,
|
||||
) {
|
||||
// The container width, column mode and font zoom the marked rows were laid out at.
|
||||
const measured = useRef<{ width: number; fitWindowWidth: boolean; fontZoom: number } | null>(null);
|
||||
// The container width and column mode the marked rows were laid out at.
|
||||
const measured = useRef<{ width: number; fitWindowWidth: boolean } | null>(null);
|
||||
useLayoutEffect(() => {
|
||||
const el = ref.current;
|
||||
if (!el) return;
|
||||
@@ -633,15 +628,10 @@ function useOffscreenRows(
|
||||
return;
|
||||
}
|
||||
if (!visible) return;
|
||||
if (
|
||||
measured.current?.width === el.clientWidth &&
|
||||
measured.current.fitWindowWidth === fitWindowWidth &&
|
||||
measured.current.fontZoom === fontZoom
|
||||
)
|
||||
return;
|
||||
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
|
||||
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
|
||||
measured.current = { width: el.clientWidth, fitWindowWidth };
|
||||
unmark();
|
||||
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
|
||||
}, [ref, visible, enabled, fitWindowWidth]);
|
||||
useEffect(() => {
|
||||
const el = ref.current;
|
||||
if (!el || !enabled || !visible) return;
|
||||
@@ -664,13 +654,8 @@ function useOffscreenRows(
|
||||
});
|
||||
};
|
||||
const remeasure = () => {
|
||||
if (
|
||||
measured.current?.width === el.clientWidth &&
|
||||
measured.current.fitWindowWidth === fitWindowWidth &&
|
||||
measured.current.fontZoom === fontZoom
|
||||
)
|
||||
return;
|
||||
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
|
||||
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
|
||||
measured.current = { width: el.clientWidth, fitWindowWidth };
|
||||
unmark();
|
||||
};
|
||||
remeasure();
|
||||
@@ -691,7 +676,7 @@ function useOffscreenRows(
|
||||
rows.disconnect();
|
||||
resize.disconnect();
|
||||
};
|
||||
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
|
||||
}, [ref, visible, enabled, fitWindowWidth]);
|
||||
}
|
||||
|
||||
interface StreamProps {
|
||||
@@ -704,7 +689,6 @@ interface StreamProps {
|
||||
finding: boolean;
|
||||
/** Bumped by Find in Conversation: focus the find field again. */
|
||||
findFocus: number;
|
||||
fontZoom: number;
|
||||
onCloseFind: () => void;
|
||||
}
|
||||
|
||||
@@ -720,17 +704,7 @@ function scrollsInside(target: EventTarget | null, root: HTMLElement): boolean {
|
||||
return false;
|
||||
}
|
||||
|
||||
function Stream({
|
||||
loadError,
|
||||
task,
|
||||
entries,
|
||||
subagent,
|
||||
onOpenSubagent,
|
||||
finding,
|
||||
findFocus,
|
||||
fontZoom,
|
||||
onCloseFind,
|
||||
}: StreamProps) {
|
||||
function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, findFocus, onCloseFind }: StreamProps) {
|
||||
const ref = useRef<HTMLDivElement>(null);
|
||||
useSelectionBoundary(ref);
|
||||
const [openFolds] = useState(() => new Map<string, boolean>());
|
||||
@@ -825,7 +799,7 @@ function Stream({
|
||||
// Hidden behind another tab, it has no layout to scroll; shown again, it follows the end again.
|
||||
const visible = useEditorShown();
|
||||
const { foldTurns, toolCalls, fitWindowWidth } = useAgentSettings();
|
||||
useOffscreenRows(ref, visible, !finding, fitWindowWidth, fontZoom);
|
||||
useOffscreenRows(ref, visible, !finding, fitWindowWidth);
|
||||
/** A diagram that drew after the last streamed chunk grows the conversation: keep following. */
|
||||
const onDiagramDrawn = useCallback(() => {
|
||||
const el = ref.current;
|
||||
@@ -994,10 +968,9 @@ function Stream({
|
||||
className={clsx(styles.stream, selectableText)}
|
||||
tabIndex={-1}
|
||||
onWheel={(e) => {
|
||||
if (e.defaultPrevented) return;
|
||||
markUserScroll();
|
||||
if (e.deltaY < 0 && !e.ctrlKey && !e.metaKey) stopFollowing(e.target);
|
||||
else if (e.deltaY > 0 && !e.ctrlKey && !e.metaKey) scrollingUp.current = false;
|
||||
if (e.deltaY < 0 && !e.ctrlKey && !e.defaultPrevented) stopFollowing(e.target);
|
||||
else if (e.deltaY > 0 && !e.ctrlKey && !e.defaultPrevented) scrollingUp.current = false;
|
||||
}}
|
||||
onTouchStart={(e) => {
|
||||
touchY.current = e.touches.length === 1 ? e.touches[0]!.clientY : null;
|
||||
|
||||
@@ -7,7 +7,6 @@ import {
|
||||
isFindRangeShown,
|
||||
pathLink,
|
||||
quoteText,
|
||||
symbolRef,
|
||||
withQuote,
|
||||
} from "./conversation";
|
||||
|
||||
@@ -47,44 +46,6 @@ describe("pathLink", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("symbolRef", () => {
|
||||
it("reads the forms a reply names a symbol in", () => {
|
||||
expect(symbolRef("FooView")).toMatchObject({ name: "FooView", kinds: expect.arrayContaining(["class"]) });
|
||||
expect(symbolRef("load()")).toMatchObject({ name: "load", kinds: ["function", "method", "constructor"] });
|
||||
expect(symbolRef("validate(input)")).toMatchObject({ name: "validate" });
|
||||
expect(symbolRef("has_header")).toMatchObject({ name: "has_header", kinds: ["function", "method", "constructor"] });
|
||||
expect(symbolRef("loadConfig")).toMatchObject({ name: "loadConfig" });
|
||||
expect(symbolRef("Config.load")).toMatchObject({ name: "load", container: "Config" });
|
||||
expect(symbolRef("Config::load()")).toMatchObject({ name: "load", container: "Config" });
|
||||
expect(symbolRef("lib.rs::has_header")).toMatchObject({ name: "has_header", file: "lib.rs" });
|
||||
expect(symbolRef("src/a.ts#load")).toMatchObject({ name: "load", file: "src/a.ts" });
|
||||
});
|
||||
it("leaves words, keywords, literals, commands and code plain", () => {
|
||||
for (const text of [
|
||||
"true",
|
||||
"null",
|
||||
"inventory",
|
||||
"None",
|
||||
"False",
|
||||
"Self",
|
||||
"Some(x)",
|
||||
"None.value",
|
||||
"42",
|
||||
"1.5",
|
||||
"cargo test",
|
||||
"git log --oneline",
|
||||
"x = 1",
|
||||
"a && b",
|
||||
"$HOME",
|
||||
"foo(bar(1))",
|
||||
"TODO",
|
||||
"src/",
|
||||
]) {
|
||||
expect(symbolRef(text)).toBeNull();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("fileHref", () => {
|
||||
const cwd = "C:/repo";
|
||||
it("resolves a link against the task folder", () => {
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
/** Reading an agent conversation: quoting, file and symbol links, turn times and finding text. */
|
||||
/** Reading an agent conversation: quoting, file links, turn times and finding text. */
|
||||
|
||||
import type { SymbolKind } from "@/platform/ipc";
|
||||
import { opensOtherShare } from "@/platform/paths";
|
||||
|
||||
/** `text` as a Markdown quote for the composer, followed by an empty line to type in. */
|
||||
@@ -65,48 +64,6 @@ export function pathLink(text: string, cwd: string): PathLink | null {
|
||||
return out;
|
||||
}
|
||||
|
||||
/** A symbol an inline code span names: `name`, inside `container` or `file` when the text says so. */
|
||||
export interface SymbolRef {
|
||||
name: string;
|
||||
container?: string;
|
||||
/** The tail of the defining file's path (`lib.rs`, `src/a.ts`). */
|
||||
file?: string;
|
||||
kinds: readonly SymbolKind[];
|
||||
}
|
||||
|
||||
const IDENT = "[A-Za-z_$][\\w$]*";
|
||||
const CALL = "(\\([^()]*\\))?";
|
||||
const SYMBOL = new RegExp(`^(?:(${IDENT})(?:\\.|#|::))?(${IDENT})${CALL}$`);
|
||||
const FILE_SYMBOL = new RegExp(`^((?:[\\w.@-]+\\/)*[\\w@-]+\\.[A-Za-z]\\w*)(?:#|::)(${IDENT})${CALL}$`);
|
||||
const TYPE_KINDS: readonly SymbolKind[] = ["class", "interface", "struct", "enum", "trait", "typeAlias", "function"];
|
||||
const CALLABLE_KINDS: readonly SymbolKind[] = ["function", "method", "constructor"];
|
||||
const MEMBER_KINDS: readonly SymbolKind[] = [...CALLABLE_KINDS, "field", "property", "constant", "enumMember"];
|
||||
const ANY_KINDS: readonly SymbolKind[] = [...new Set<SymbolKind>([...TYPE_KINDS, ...MEMBER_KINDS, "variable"])];
|
||||
/** Capitalized keywords and literals that read like a type name. */
|
||||
const LITERALS = new Set(["None", "True", "False", "Self", "Some", "Ok", "Err", "Null", "Nil", "NaN", "Infinity"]);
|
||||
|
||||
/**
|
||||
* The symbol inline code names (`FooView`, `load()`, `has_header`, `Config.load`,
|
||||
* `lib.rs::has_header`, `a.ts#load`); null for words, keywords, literals and anything
|
||||
* with spaces or shell syntax (`cargo test`, `true`, `None`, `x = 1`).
|
||||
*/
|
||||
export function symbolRef(text: string): SymbolRef | null {
|
||||
const trimmed = text.trim();
|
||||
const inFile = FILE_SYMBOL.exec(trimmed);
|
||||
if (inFile) return { name: inFile[2]!, file: inFile[1]!, kinds: ANY_KINDS };
|
||||
const match = SYMBOL.exec(trimmed);
|
||||
if (!match) return null;
|
||||
const [, container, name, call] = match;
|
||||
if (LITERALS.has(container ?? name!)) return null;
|
||||
if (container) return { name: name!, container, kinds: MEMBER_KINDS };
|
||||
if (call) return { name: name!, kinds: CALLABLE_KINDS };
|
||||
if (/^[A-Z]\w*[a-z]/.test(name!)) return { name: name!, kinds: TYPE_KINDS };
|
||||
if (/^[a-z]\w*[a-z\d][A-Z]/.test(name!) || /^[a-z][a-z\d]*(?:_[a-z\d]+)+$/.test(name!)) {
|
||||
return { name: name!, kinds: CALLABLE_KINDS };
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** `850ms`, `12s`, `1m 05s`, `2h 03m`. */
|
||||
export function formatDuration(ms: number): string {
|
||||
if (ms < 1000) return `${Math.max(0, Math.round(ms))}ms`;
|
||||
|
||||
@@ -1,380 +0,0 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { act, cleanup, render } from "@testing-library/react";
|
||||
import { EditorState } from "@codemirror/state";
|
||||
import { EditorView } from "@codemirror/view";
|
||||
import type { AgentEntry, AgentTask } from "@/bindings";
|
||||
import { _addEditor, _removeEditor, type EditorDocContext } from "@/editor/api";
|
||||
import { fontZoom as cmFontZoom, resetAllEditorsFontZoom } from "@/editor/core/cm/prefs";
|
||||
import type { EditorSlot } from "@/editor/core/model/slot";
|
||||
import { executeAction } from "@/platform/actions";
|
||||
import { useContextKeys } from "@/platform/context";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { EditorShownProvider, EditorTabIdProvider } from "@/workbench/contributions";
|
||||
import { HomeEditor } from "./HomeEditor";
|
||||
import { SessionEditor } from "./SessionEditor";
|
||||
import {
|
||||
clearAgentTabFontZoom,
|
||||
clearAgentTaskFontZoom,
|
||||
resetAllAgentFontZoom,
|
||||
stepAgentSurfaceFontZoom,
|
||||
useAgentFontZoom,
|
||||
} from "./fontZoom";
|
||||
import { SESSION_KIND, sessionKey } from "./model";
|
||||
import { disconnect, useAgents } from "./store";
|
||||
import styles from "./Session.module.css";
|
||||
|
||||
let activeSlot: Partial<EditorSlot> | null = null;
|
||||
const imageReads = new Map<string, string>();
|
||||
|
||||
vi.mock("@/editor/core/controller", async (importOriginal) => ({
|
||||
...(await importOriginal<object>()),
|
||||
editorController: () => ({
|
||||
get activeSlot() {
|
||||
return activeSlot;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
vi.mock("@tauri-apps/api/webview", () => ({
|
||||
getCurrentWebview: () => ({
|
||||
onDragDropEvent: () => Promise.resolve(() => {}),
|
||||
}),
|
||||
}));
|
||||
|
||||
vi.mock("@/platform/ipc", async (original) => ({
|
||||
...(await original<typeof import("@/platform/ipc")>()),
|
||||
commands: {
|
||||
fsProbe: async () => ({
|
||||
status: "ok",
|
||||
data: { size: 1, binary: false, tooLarge: false },
|
||||
}),
|
||||
fsReadImage: async (path: string) => {
|
||||
const url = imageReads.get(path);
|
||||
if (url) return { status: "ok", data: url };
|
||||
return { status: "error", error: { kind: "notFound", message: path } };
|
||||
},
|
||||
agentEntries: async () => ({ status: "ok", data: [] as AgentEntry[] }),
|
||||
agentChanges: async () => ({ status: "ok", data: [] }),
|
||||
agentGroupedChanges: async () => ({ status: "ok", data: { uncommitted: [], commits: [] } }),
|
||||
agentProviders: async () => ({ status: "ok", data: [] }),
|
||||
vcsBranchInfo: async () => ({ status: "ok", data: { head: "main" } }),
|
||||
vcsBranches: async () => ({ status: "ok", data: [] }),
|
||||
},
|
||||
}));
|
||||
|
||||
const { registerEditorActions } = await import("@/editor/core/actions");
|
||||
const { useTabs } = await import("@/editor/core/controller");
|
||||
|
||||
const makeTask = (id: string): AgentTask => ({
|
||||
id,
|
||||
title: id,
|
||||
provider: "copilot",
|
||||
status: "ready",
|
||||
isolation: "local",
|
||||
model: null,
|
||||
cwd: "/project",
|
||||
branch: null,
|
||||
base: null,
|
||||
baseCommit: null,
|
||||
error: null,
|
||||
createdMs: 0,
|
||||
updatedMs: 0,
|
||||
config: [],
|
||||
commands: [],
|
||||
usage: null,
|
||||
queue: [],
|
||||
});
|
||||
|
||||
describe("Agent chat font size zoom", () => {
|
||||
const disposers: Array<() => void> = [];
|
||||
const views: EditorView[] = [];
|
||||
|
||||
beforeEach(() => {
|
||||
resetAllEditorsFontZoom();
|
||||
resetAllAgentFontZoom();
|
||||
imageReads.clear();
|
||||
disposers.push(registerEditorActions());
|
||||
useContextKeys.setState({ projectOpen: true, textEditorActive: false, editorFocus: true, popupOpen: false });
|
||||
useProject.setState({
|
||||
project: { name: "openidea", root: "/project", isGit: true, workspace: null } as never,
|
||||
settings: null,
|
||||
});
|
||||
const t1 = makeTask("t1");
|
||||
const t2 = makeTask("t2");
|
||||
useAgents.setState({
|
||||
loaded: true,
|
||||
tasks: new Map([
|
||||
[t1.id, t1],
|
||||
[t2.id, t2],
|
||||
]),
|
||||
entries: new Map([
|
||||
[t1.id, [{ type: "agent", text: "Hello `world`" }]],
|
||||
[t2.id, [{ type: "agent", text: "Second task" }]],
|
||||
]),
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
cleanup();
|
||||
for (const view of views.splice(0)) view.destroy();
|
||||
for (const dispose of disposers.splice(0).reverse()) dispose();
|
||||
activeSlot = null;
|
||||
disconnect();
|
||||
resetAllAgentFontZoom();
|
||||
useProject.setState({ project: null, settings: null });
|
||||
useContextKeys.setState({}, true);
|
||||
});
|
||||
|
||||
it("scales only the focused Agent chat tab with ⌘=/⌘-/⌘0, clamped to -6..36, leaving other chat tabs untouched", async () => {
|
||||
const { container } = render(
|
||||
<div>
|
||||
<div data-pane-id="left">
|
||||
<div data-editor-focus="" tabIndex={-1}>
|
||||
<EditorTabIdProvider value="tab-1">
|
||||
<EditorShownProvider value={true}>
|
||||
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
|
||||
</EditorShownProvider>
|
||||
</EditorTabIdProvider>
|
||||
</div>
|
||||
<EditorTabIdProvider value="tab-kept">
|
||||
<EditorShownProvider value={false}>
|
||||
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t2"), data: { task: "t2" } }} />
|
||||
</EditorShownProvider>
|
||||
</EditorTabIdProvider>
|
||||
</div>
|
||||
<div data-pane-id="right">
|
||||
<div data-editor-focus="" tabIndex={-1}>
|
||||
<EditorTabIdProvider value="tab-2">
|
||||
<EditorShownProvider value={true}>
|
||||
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
|
||||
</EditorShownProvider>
|
||||
</EditorTabIdProvider>
|
||||
</div>
|
||||
</div>
|
||||
<HomeEditor docked />
|
||||
</div>,
|
||||
);
|
||||
act(() => useTabs.setState((s) => ({ ...s, activePane: "left" })));
|
||||
|
||||
const sessions = container.querySelectorAll<HTMLElement>(`.${styles.session}`);
|
||||
const leftSession = sessions[0]!;
|
||||
const keptSession = sessions[1]!;
|
||||
const rightSession = sessions[2]!;
|
||||
const home = container.querySelector<HTMLElement>('[class*="home"]')!;
|
||||
|
||||
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
expect(home.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
|
||||
// Works when the composer's CodeMirror input in tab-1 has focus — only tab-1 changes.
|
||||
leftSession.querySelector<HTMLElement>(".cm-content")!.focus();
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
|
||||
expect(leftSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("1.1538");
|
||||
expect(keptSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
expect(home.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
|
||||
// Focusing right split tab-2 (even showing the same task t1) zooms only tab-2.
|
||||
rightSession.querySelector<HTMLElement>(".cm-content")!.focus();
|
||||
await act(() => executeAction("editor.decreaseFontSize"));
|
||||
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("-1px");
|
||||
expect(rightSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("0.9231");
|
||||
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
|
||||
|
||||
// ⌘0 while focused in tab-2 resets only tab-2, keeping tab-1 at +2px.
|
||||
await act(() => executeAction("editor.resetFontSize"));
|
||||
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
|
||||
|
||||
// Works when the active pane's KindEditor [data-editor-focus] wrapper or body has focus.
|
||||
const leftWrapper = container.querySelector<HTMLElement>('[data-pane-id="left"] [data-editor-focus]')!;
|
||||
leftWrapper.focus();
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("3px");
|
||||
|
||||
document.body.focus();
|
||||
await act(() => executeAction("editor.decreaseFontSize"));
|
||||
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
|
||||
|
||||
// Clamped to -6..36.
|
||||
act(() => stepAgentSurfaceFontZoom("tab:tab-1", 100));
|
||||
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(36);
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(36);
|
||||
|
||||
act(() => stepAgentSurfaceFontZoom("tab:tab-1", -100));
|
||||
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(-6);
|
||||
await act(() => executeAction("editor.decreaseFontSize"));
|
||||
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(-6);
|
||||
|
||||
// ⌘0 on the active pane resets tab-1.
|
||||
await act(() => executeAction("editor.resetFontSize"));
|
||||
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
|
||||
expect(leftSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("1");
|
||||
});
|
||||
|
||||
it("isolates docked Agent chat and code editor resets from each other", async () => {
|
||||
const ctx: EditorDocContext = {
|
||||
doc: 1,
|
||||
path: "/project/a.ts",
|
||||
language: "typescript",
|
||||
uiMode: null,
|
||||
readOnly: false,
|
||||
};
|
||||
const view = new EditorView({ state: EditorState.create({ doc: "const x = 1;", extensions: [cmFontZoom] }) });
|
||||
document.body.appendChild(view.dom);
|
||||
const handle = { view, ctx };
|
||||
_addEditor(handle);
|
||||
disposers.push(() => {
|
||||
_removeEditor(handle);
|
||||
view.dom.remove();
|
||||
});
|
||||
views.push(view);
|
||||
activeSlot = { view, disposed: false };
|
||||
|
||||
const { container } = render(
|
||||
<SessionEditor docked input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />,
|
||||
);
|
||||
const stream = container.querySelector<HTMLElement>(`.${styles.stream}`)!;
|
||||
|
||||
// Zoom code editor first (+2), then zoom docked chat (+1).
|
||||
view.contentDOM.focus();
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
expect(view.state.field(cmFontZoom)).toBe(2);
|
||||
|
||||
stream.focus();
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBe(1);
|
||||
expect(view.state.field(cmFontZoom)).toBe(2);
|
||||
|
||||
// Resetting in code editor leaves docked chat at +1.
|
||||
view.contentDOM.focus();
|
||||
await act(() => executeAction("editor.resetFontSize"));
|
||||
expect(view.state.field(cmFontZoom)).toBe(0);
|
||||
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBe(1);
|
||||
|
||||
// Zoom code editor again (+1); resetting in docked chat leaves code editor at +1.
|
||||
await act(() => executeAction("editor.increaseFontSize"));
|
||||
expect(view.state.field(cmFontZoom)).toBe(1);
|
||||
|
||||
stream.focus();
|
||||
await act(() => executeAction("editor.resetFontSize"));
|
||||
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBeUndefined();
|
||||
expect(view.state.field(cmFontZoom)).toBe(1);
|
||||
});
|
||||
|
||||
it("zooms with ⌘/Ctrl+wheel only on the hovered chat tab when editor.general.wheelZoom is enabled", () => {
|
||||
const { container } = render(
|
||||
<div>
|
||||
<EditorTabIdProvider value="tab-1">
|
||||
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
|
||||
</EditorTabIdProvider>
|
||||
<EditorTabIdProvider value="tab-2">
|
||||
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t2"), data: { task: "t2" } }} />
|
||||
</EditorTabIdProvider>
|
||||
</div>,
|
||||
);
|
||||
const streams = container.querySelectorAll<HTMLElement>(`.${styles.stream}`);
|
||||
const stream1 = streams[0]!;
|
||||
|
||||
const offEvent = new WheelEvent("wheel", { bubbles: true, cancelable: true, metaKey: true, deltaY: -100 });
|
||||
act(() => {
|
||||
stream1.dispatchEvent(offEvent);
|
||||
});
|
||||
expect(offEvent.defaultPrevented).toBe(false);
|
||||
expect(useAgentFontZoom.getState().bySurface).toEqual({});
|
||||
|
||||
act(() =>
|
||||
useProject.setState((s) => ({
|
||||
...s,
|
||||
settings: { editor: { general: { wheelZoom: true } } } as never,
|
||||
})),
|
||||
);
|
||||
|
||||
const up = new WheelEvent("wheel", { bubbles: true, cancelable: true, metaKey: true, deltaY: -100 });
|
||||
act(() => {
|
||||
stream1.dispatchEvent(up);
|
||||
});
|
||||
expect(up.defaultPrevented).toBe(true);
|
||||
expect(useAgentFontZoom.getState().bySurface).toEqual({ "tab:tab-1": 1 });
|
||||
|
||||
const down = new WheelEvent("wheel", { bubbles: true, cancelable: true, ctrlKey: true, deltaY: 100 });
|
||||
act(() => {
|
||||
stream1.dispatchEvent(down);
|
||||
});
|
||||
expect(down.defaultPrevented).toBe(true);
|
||||
expect(useAgentFontZoom.getState().bySurface).toEqual({});
|
||||
|
||||
const plain = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: -100 });
|
||||
act(() => {
|
||||
stream1.dispatchEvent(plain);
|
||||
});
|
||||
expect(plain.defaultPrevented).toBe(false);
|
||||
});
|
||||
|
||||
it("sizes SVG and raster images in replies so they scale with --markdown-zoom-scale", async () => {
|
||||
const svgUrl = `data:image/svg+xml;base64,${btoa('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 120"></svg>')}`;
|
||||
const pngUrl = "data:image/png;base64,iVBORw0KGgo=";
|
||||
imageReads.set("/project/diagram.svg", svgUrl);
|
||||
imageReads.set("/project/shot.png", pngUrl);
|
||||
|
||||
act(() =>
|
||||
useAgents.setState((s) => ({
|
||||
...s,
|
||||
entries: new Map([["t1", [{ type: "agent", text: "\n\n" }]]]),
|
||||
})),
|
||||
);
|
||||
|
||||
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,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,95 +0,0 @@
|
||||
import { useEffect, type CSSProperties, type RefObject } from "react";
|
||||
import { create } from "zustand";
|
||||
import { editorPrefs } from "@/platform/editorSettings";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { registerFontZoomSurface, useEditorShown, useEditorTabId, useToolWindowShown } from "@/workbench/contributions";
|
||||
|
||||
const MIN_FONT_ZOOM = -6;
|
||||
const MAX_FONT_ZOOM = 36;
|
||||
const DEFAULT_UI_FONT_SIZE = 13;
|
||||
|
||||
export const useAgentFontZoom = create<{ bySurface: Record<string, number> }>(() => ({ bySurface: {} }));
|
||||
|
||||
export function agentSurfaceZoomKey(fallbackKey: string, docked: boolean, tabId: string | null): string {
|
||||
if (docked) return `docked:${fallbackKey}`;
|
||||
return tabId ? `tab:${tabId}` : fallbackKey;
|
||||
}
|
||||
|
||||
/** Steps one Agent chat surface's font zoom by `delta` px (-6..36), or resets it when `delta === 0`. */
|
||||
export function stepAgentSurfaceFontZoom(surfaceKey: string, delta: number): void {
|
||||
useAgentFontZoom.setState((s) => {
|
||||
const current = s.bySurface[surfaceKey] ?? 0;
|
||||
const next = delta === 0 ? 0 : Math.max(MIN_FONT_ZOOM, Math.min(MAX_FONT_ZOOM, current + delta));
|
||||
if (next === current) return s;
|
||||
if (next === 0) {
|
||||
const { [surfaceKey]: _, ...rest } = s.bySurface;
|
||||
return { bySurface: rest };
|
||||
}
|
||||
return { bySurface: { ...s.bySurface, [surfaceKey]: next } };
|
||||
});
|
||||
}
|
||||
|
||||
export function clearAgentTabFontZoom(tabId: string): void {
|
||||
stepAgentSurfaceFontZoom(`tab:${tabId}`, 0);
|
||||
}
|
||||
|
||||
export function clearAgentTaskFontZoom(taskKey: string): void {
|
||||
useAgentFontZoom.setState((s) => {
|
||||
const dockedKey = `docked:${taskKey}`;
|
||||
if (!(taskKey in s.bySurface) && !(dockedKey in s.bySurface)) return s;
|
||||
const { [taskKey]: _a, [dockedKey]: _b, ...rest } = s.bySurface;
|
||||
return { bySurface: rest };
|
||||
});
|
||||
}
|
||||
|
||||
export function resetAllAgentFontZoom(): void {
|
||||
useAgentFontZoom.setState({ bySurface: {} });
|
||||
}
|
||||
|
||||
function uiFontSizeOf(settings: unknown): number {
|
||||
if (!settings || typeof settings !== "object") return DEFAULT_UI_FONT_SIZE;
|
||||
const a = (settings as { appearance?: { useCustomFont?: unknown; uiFontSize?: unknown } }).appearance;
|
||||
return a?.useCustomFont && typeof a.uiFontSize === "number" && a.uiFontSize > 0 ? a.uiFontSize : DEFAULT_UI_FONT_SIZE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wires per-tab keyboard font zoom (`editor.increaseFontSize` / `decreaseFontSize` / `resetFontSize`)
|
||||
* and `⌘/Ctrl+wheel` (when `editor.general.wheelZoom` is on) to an Agent chat surface.
|
||||
*/
|
||||
export function useAgentFontZoomSurface(
|
||||
ref: RefObject<HTMLElement | null>,
|
||||
fallbackKey: string,
|
||||
docked: boolean,
|
||||
enabled = true,
|
||||
): { fontZoom: number; zoomStyle: CSSProperties } {
|
||||
const editorShown = useEditorShown();
|
||||
const toolWindowShown = useToolWindowShown();
|
||||
const tabId = useEditorTabId();
|
||||
const surfaceKey = agentSurfaceZoomKey(fallbackKey, docked, tabId);
|
||||
const active = enabled && (docked ? toolWindowShown : editorShown);
|
||||
const fontZoom = useAgentFontZoom((s) => s.bySurface[surfaceKey] ?? 0);
|
||||
const baseSize = useProject((s) => uiFontSizeOf(s.settings));
|
||||
useEffect(() => {
|
||||
const el = ref.current;
|
||||
if (!active || !el) return;
|
||||
const step = (delta: number) => stepAgentSurfaceFontZoom(surfaceKey, delta);
|
||||
const onWheel = (e: WheelEvent) => {
|
||||
if ((!e.ctrlKey && !e.metaKey) || e.deltaY === 0 || !editorPrefs().general.wheelZoom) return;
|
||||
e.preventDefault();
|
||||
e.stopPropagation();
|
||||
step(e.deltaY < 0 ? 1 : -1);
|
||||
};
|
||||
el.addEventListener("wheel", onWheel, { capture: true, passive: false });
|
||||
const release = registerFontZoomSurface(el, step, { isolated: true });
|
||||
return () => {
|
||||
el.removeEventListener("wheel", onWheel, { capture: true });
|
||||
release();
|
||||
};
|
||||
}, [ref, active, surfaceKey]);
|
||||
const zoomScale = Number((Math.max(4, baseSize + fontZoom) / baseSize).toFixed(4));
|
||||
const zoomStyle = {
|
||||
"--agent-font-zoom": `${fontZoom}px`,
|
||||
"--markdown-zoom-scale": String(zoomScale),
|
||||
} as CSSProperties;
|
||||
return { fontZoom, zoomStyle };
|
||||
}
|
||||
@@ -38,7 +38,6 @@ import {
|
||||
import { sendPaths, sendSelection, trackEditorCopies } from "./references";
|
||||
import { focusedSession } from "./sessionFocus";
|
||||
import { cycleFocusedEffort } from "./effortFocus";
|
||||
import { clearAgentTabFontZoom } from "./fontZoom";
|
||||
import {
|
||||
closeActiveTask,
|
||||
closeAndNewTask,
|
||||
@@ -189,7 +188,6 @@ export function activate(): () => void {
|
||||
const s = useAgents.getState();
|
||||
if (s.ephemeral.has(task) && s.docked !== task) void discardEphemeral(task);
|
||||
},
|
||||
onTabClose: (tabId) => clearAgentTabFontZoom(tabId),
|
||||
// Rebuilding a long conversation on every switch back is slow.
|
||||
keepAlive: true,
|
||||
}),
|
||||
@@ -201,7 +199,6 @@ export function activate(): () => void {
|
||||
const task = useAgents.getState().tasks.get((input.data as { task: string }).task);
|
||||
return task ? providerIcon(task.provider) : "toolwindow-agents";
|
||||
},
|
||||
onTabClose: (tabId) => clearAgentTabFontZoom(tabId),
|
||||
restorable: true,
|
||||
}),
|
||||
// An explicit editor drop sets the placement for subsequent sessions too.
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import { call, commands } from "@/platform/ipc";
|
||||
import { ipcPath } from "@/platform/paths";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { applyImageZoomWidth, svgDataUrlSize } from "@/ui/svgSize";
|
||||
import styles from "./Session.module.css";
|
||||
|
||||
const hasControl = (text: string) => [...text].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127);
|
||||
@@ -40,41 +39,16 @@ export function imageTarget(source: string, cwd: string): ImageTarget | null {
|
||||
}
|
||||
|
||||
/** What one message has loaded: streaming reuses it, later replies read a new QR at the same path and ask again. */
|
||||
export type MessageImages = {
|
||||
reads: Map<string, Promise<string>>;
|
||||
asked: Set<string>;
|
||||
onLoaded?: () => void;
|
||||
};
|
||||
export type MessageImages = { reads: Map<string, Promise<string>>; asked: Set<string> };
|
||||
|
||||
export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageImages): () => void {
|
||||
const { reads, asked } = imagesState;
|
||||
export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: MessageImages): () => void {
|
||||
let alive = true;
|
||||
const held: HTMLButtonElement[] = [];
|
||||
const images = [...root.querySelectorAll<HTMLImageElement>("img")];
|
||||
const bindUrl = (img: HTMLImageElement, url: string, asyncLoad: boolean) => {
|
||||
const svgSize = svgDataUrlSize(url);
|
||||
if (svgSize && applyImageZoomWidth(img, svgSize) && asyncLoad) imagesState.onLoaded?.();
|
||||
img.onload = () => {
|
||||
if (!alive) return;
|
||||
if (!img.hasAttribute("data-natural-width") && img.naturalWidth > 0 && img.naturalHeight > 0) {
|
||||
if (applyImageZoomWidth(img, { w: img.naturalWidth, h: img.naturalHeight }) && asyncLoad) {
|
||||
imagesState.onLoaded?.();
|
||||
}
|
||||
} else if (asyncLoad) {
|
||||
imagesState.onLoaded?.();
|
||||
}
|
||||
};
|
||||
img.src = url;
|
||||
if (!img.hasAttribute("data-natural-width") && img.complete && img.naturalWidth > 0 && img.naturalHeight > 0) {
|
||||
applyImageZoomWidth(img, { w: img.naturalWidth, h: img.naturalHeight });
|
||||
}
|
||||
};
|
||||
for (const img of images) {
|
||||
applyImageZoomWidth(img);
|
||||
const source = img.dataset.imageSrc ?? "";
|
||||
const fail = () => {
|
||||
if (!alive) return;
|
||||
img.onload = null;
|
||||
img.onerror = null;
|
||||
img.removeAttribute("src");
|
||||
img.alt = tx`Unable to load image: ${source}`;
|
||||
@@ -88,7 +62,7 @@ export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageI
|
||||
const { url } = target;
|
||||
if (/^data:/i.test(url) || asked.has(url)) {
|
||||
img.hidden = false;
|
||||
bindUrl(img, url, false);
|
||||
img.src = url;
|
||||
} else {
|
||||
// A reply can be steered into naming an address that carries data out: the user decides.
|
||||
// That holds for this machine too, where a server may pass the request on.
|
||||
@@ -101,7 +75,7 @@ export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageI
|
||||
asked.add(url);
|
||||
load.remove();
|
||||
img.hidden = false;
|
||||
bindUrl(img, url, true);
|
||||
img.src = url;
|
||||
};
|
||||
img.hidden = true;
|
||||
img.before(load);
|
||||
@@ -115,16 +89,13 @@ export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageI
|
||||
void pending.catch(() => reads.delete(target.path));
|
||||
}
|
||||
void pending.then((url) => {
|
||||
if (alive) bindUrl(img, url, true);
|
||||
if (alive) img.src = url;
|
||||
}, fail);
|
||||
}
|
||||
}
|
||||
return () => {
|
||||
alive = false;
|
||||
for (const img of images) {
|
||||
img.onload = null;
|
||||
img.onerror = null;
|
||||
}
|
||||
for (const img of images) img.onerror = null;
|
||||
for (const load of held) load.remove();
|
||||
};
|
||||
}
|
||||
@@ -20,7 +20,6 @@ import type {
|
||||
Isolation,
|
||||
} from "@/bindings";
|
||||
import { useChangesOptions } from "./changesOptions";
|
||||
import { clearAgentTaskFontZoom, resetAllAgentFontZoom } from "./fontZoom";
|
||||
import { basename, useProject } from "@/platform/project";
|
||||
import { defaultTaskProject } from "./project";
|
||||
import { call, commands, isTauri } from "@/platform/ipc";
|
||||
@@ -519,7 +518,6 @@ export function disconnect() {
|
||||
arrivedWhileLoading.clear();
|
||||
streamingReply.clear();
|
||||
modelFlights.clear();
|
||||
resetAllAgentFontZoom();
|
||||
useAgents.setState({
|
||||
loaded: false,
|
||||
error: null,
|
||||
@@ -578,7 +576,6 @@ function onEvent(e: AgentEvent) {
|
||||
organize,
|
||||
...(s.docked === e.id ? { docked: null } : {}),
|
||||
});
|
||||
clearAgentTaskFontZoom(sessionKey(e.id));
|
||||
void editorService().closeInput?.(sessionKey(e.id));
|
||||
break;
|
||||
}
|
||||
@@ -1277,7 +1274,6 @@ export async function discardEphemeral(task: string): Promise<void> {
|
||||
lastComposer: state.lastComposer === task ? HOME : state.lastComposer,
|
||||
};
|
||||
});
|
||||
clearAgentTaskFontZoom(sessionKey(task));
|
||||
void editorService().closeInput?.(sessionKey(task));
|
||||
}
|
||||
|
||||
|
||||
@@ -1,81 +0,0 @@
|
||||
import { afterEach, describe, expect, it } from "vitest";
|
||||
import { clearMocks, mockIPC } from "@tauri-apps/api/mocks";
|
||||
import type { SymbolKind, SymbolMatch } from "@/platform/ipc";
|
||||
import { symbolRef } from "./conversation";
|
||||
import { inTaskFolder, lookupSymbols, symbolTargets } from "./symbolLinks";
|
||||
|
||||
const symbol = (
|
||||
name: string,
|
||||
path: string,
|
||||
kind: SymbolKind = "class",
|
||||
container: string | null = null,
|
||||
): SymbolMatch => ({
|
||||
name,
|
||||
kind,
|
||||
container,
|
||||
path,
|
||||
relPath: path.replace(/^\/repo\//, ""),
|
||||
range: { start: { line: 3, col: 6 }, end: { line: 3, col: 6 + name.length } },
|
||||
score: 0,
|
||||
indices: [],
|
||||
});
|
||||
|
||||
afterEach(clearMocks);
|
||||
|
||||
describe("symbolTargets", () => {
|
||||
const views = [symbol("FooView", "/repo/web/view.ts"), symbol("FooView", "/repo/app/view.ts")];
|
||||
|
||||
it("keeps only exact matches of the named kind, container and file", () => {
|
||||
const found = [
|
||||
symbol("load", "/repo/a.ts", "method", "Config"),
|
||||
symbol("load", "/repo/b.ts", "method", "Loader"),
|
||||
symbol("load", "/repo/c.ts", "variable"),
|
||||
];
|
||||
expect(symbolTargets(symbolRef("Config.load")!, found, [], "/repo").map((found) => found.path)).toEqual([
|
||||
"/repo/a.ts",
|
||||
]);
|
||||
expect(symbolTargets(symbolRef("b.ts#load")!, found, [], "/repo").map((found) => found.path)).toEqual([
|
||||
"/repo/b.ts",
|
||||
]);
|
||||
expect(symbolTargets(symbolRef("load()")!, found, [], "/repo").map((found) => found.path)).toEqual([
|
||||
"/repo/a.ts",
|
||||
"/repo/b.ts",
|
||||
]);
|
||||
expect(symbolTargets(symbolRef("FooView")!, [symbol("FooView", "/repo/x.ts", "variable")], [], "/repo")).toEqual(
|
||||
[],
|
||||
);
|
||||
});
|
||||
|
||||
it("prefers a file the reply names, then the task's folder", () => {
|
||||
const ref = symbolRef("FooView")!;
|
||||
expect(symbolTargets(ref, views, ["/app/view.ts"], "/repo/web").map((found) => found.path)).toEqual([
|
||||
"/repo/app/view.ts",
|
||||
]);
|
||||
expect(symbolTargets(ref, views, [], "/repo/web").map((found) => found.path)).toEqual(["/repo/web/view.ts"]);
|
||||
expect(symbolTargets(ref, views, ["/other.ts"], "/repo")).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("puts a worktree task's targets under its own folder", () => {
|
||||
const [view] = views;
|
||||
expect(inTaskFolder(view!, "/repo", "/repo/web").path).toBe("/repo/web/view.ts");
|
||||
expect(inTaskFolder(view!, "/repo", "/worktrees/fix").path).toBe("/worktrees/fix/web/view.ts");
|
||||
});
|
||||
});
|
||||
|
||||
describe("lookupSymbols", () => {
|
||||
it("asks the index once per name and folder, in one request", async () => {
|
||||
const asked: string[][] = [];
|
||||
mockIPC((cmd, args) => {
|
||||
if (cmd !== "find_symbols_named") return null;
|
||||
const { names } = args as { names: string[] };
|
||||
asked.push(names);
|
||||
return names.map((name) => symbol(name, `/repo/${name}.ts`));
|
||||
});
|
||||
const first = lookupSymbols("/batch", ["FooView", "load", "FooView"]);
|
||||
expect((await first.get("load"))!.map((found) => found.path)).toEqual(["/repo/load.ts"]);
|
||||
const second = lookupSymbols("/batch", ["load", "BarView"]);
|
||||
expect((await second.get("BarView"))!.map((found) => found.name)).toEqual(["BarView"]);
|
||||
await lookupSymbols("/elsewhere", ["load"]).get("load");
|
||||
expect(asked).toEqual([["FooView", "load"], ["BarView"], ["load"]]);
|
||||
});
|
||||
});
|
||||
@@ -1,73 +0,0 @@
|
||||
/**
|
||||
* Symbol links in agent replies: the names a reply shows are looked up in the symbol index
|
||||
* in one batch, and each name only once per task folder.
|
||||
*/
|
||||
import { call, commands, type SymbolMatch } from "@/platform/ipc";
|
||||
import type { SymbolRef } from "./conversation";
|
||||
|
||||
/** Index answers by the folder they were asked in, then by name. */
|
||||
const answers = new Map<string, Map<string, Promise<SymbolMatch[]>>>();
|
||||
const NAMES_PER_FOLDER = 2000;
|
||||
|
||||
/** The index's symbols named exactly each of `names` inside `within`; one request for the names not asked before. */
|
||||
export function lookupSymbols(within: string, names: Iterable<string>): Map<string, Promise<SymbolMatch[]>> {
|
||||
const known = answers.get(within) ?? new Map<string, Promise<SymbolMatch[]>>();
|
||||
answers.set(within, known);
|
||||
const wanted = new Set(names);
|
||||
const missing = [...wanted].filter((name) => !known.has(name));
|
||||
if (missing.length) {
|
||||
const found = call(commands.findSymbolsNamed(missing, within)).catch(() => []);
|
||||
for (const name of missing) {
|
||||
if (known.size >= NAMES_PER_FOLDER) known.delete(known.keys().next().value!);
|
||||
known.set(
|
||||
name,
|
||||
found.then((symbols) => symbols.filter((symbol) => symbol.name === name)),
|
||||
);
|
||||
}
|
||||
}
|
||||
return new Map([...wanted].map((name) => [name, known.get(name)!]));
|
||||
}
|
||||
|
||||
/** Narrows `symbols` by each preference in turn, skipping one that would leave nothing. */
|
||||
function preferred(symbols: SymbolMatch[], ...preferences: Array<(symbol: SymbolMatch) => boolean>): SymbolMatch[] {
|
||||
return preferences.reduce((pool, prefers) => {
|
||||
const narrowed = pool.filter(prefers);
|
||||
return narrowed.length ? narrowed : pool;
|
||||
}, symbols);
|
||||
}
|
||||
|
||||
const trimSlash = (path: string) => path.replace(/\/$/, "");
|
||||
const under = (folder: string, path: string) => path.startsWith(`${trimSlash(folder)}/`);
|
||||
|
||||
/**
|
||||
* The definitions `ref` names among `symbols` (same name, kind, container and file), the
|
||||
* ones in a file the reply names first, then the ones in the task's folder `cwd`.
|
||||
*/
|
||||
export function symbolTargets(
|
||||
ref: SymbolRef,
|
||||
symbols: readonly SymbolMatch[],
|
||||
mentioned: readonly string[],
|
||||
cwd: string,
|
||||
): SymbolMatch[] {
|
||||
const exact = symbols.filter(
|
||||
(symbol) =>
|
||||
symbol.name === ref.name &&
|
||||
ref.kinds.includes(symbol.kind) &&
|
||||
(!ref.container || symbol.container?.split(/\.|::/).pop() === ref.container) &&
|
||||
(!ref.file || symbol.path.endsWith(`/${ref.file}`)),
|
||||
);
|
||||
return preferred(
|
||||
exact,
|
||||
(symbol) => mentioned.some((path) => symbol.path.endsWith(`/${path.replace(/^\.?\//, "")}`)),
|
||||
(symbol) => under(cwd, symbol.path),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* `symbol` as the task sees it: a task in a worktree outside the indexed project root has
|
||||
* the same file under its own folder.
|
||||
*/
|
||||
export function inTaskFolder(symbol: SymbolMatch, projectRoot: string, cwd: string): SymbolMatch {
|
||||
if (trimSlash(cwd) === trimSlash(projectRoot) || under(projectRoot, cwd)) return symbol;
|
||||
return { ...symbol, path: `${trimSlash(cwd)}/${symbol.relPath}` };
|
||||
}
|
||||
@@ -9,7 +9,6 @@ import {
|
||||
Spinner,
|
||||
SymbolBadge,
|
||||
Tabs,
|
||||
showContextMenu,
|
||||
Tree,
|
||||
badgeKind,
|
||||
type TreeHandle,
|
||||
@@ -18,11 +17,8 @@ import {
|
||||
} from "@/ui";
|
||||
import { openLocation } from "./ipc";
|
||||
import {
|
||||
closeHierarchyTab,
|
||||
pinHierarchyTab,
|
||||
closeHierarchy,
|
||||
ROOT_ID,
|
||||
selectHierarchyTab,
|
||||
tabHierarchy,
|
||||
directionLabel,
|
||||
hierarchyTitle,
|
||||
hierarchyTarget,
|
||||
@@ -58,44 +54,22 @@ useHierarchyOptions.subscribe((s) => {
|
||||
}
|
||||
});
|
||||
|
||||
/** Tool window header: the `Callers of foo` content tabs. */
|
||||
/** Tool window header: `Callers of foo` content tab. */
|
||||
export function HierarchyTabs() {
|
||||
const state = useHierarchy();
|
||||
const tabs = state.tabs.flatMap((tab) => {
|
||||
const h = tabHierarchy(state, tab);
|
||||
return h.root ? [{ tab, label: hierarchyTitle(h.mode, h.direction, h.root.name) }] : [];
|
||||
});
|
||||
if (!tabs.length || state.active === null) return null;
|
||||
const mode = useHierarchy((s) => s.mode);
|
||||
const direction = useHierarchy((s) => s.direction);
|
||||
const root = useHierarchy((s) => s.root);
|
||||
if (!root) return null;
|
||||
const label = hierarchyTitle(mode, direction, root.name);
|
||||
return (
|
||||
<Tabs
|
||||
variant="compact"
|
||||
className={styles.tabs}
|
||||
aria-label="Hierarchies"
|
||||
items={tabs.map(({ tab, label }) => ({ id: String(tab.id), label, closable: true, pinned: tab.pinned }))}
|
||||
activeId={String(state.active)}
|
||||
onSelect={(id) => selectHierarchyTab(Number(id))}
|
||||
onClose={(id) => closeHierarchyTab(Number(id))}
|
||||
onTogglePin={(id) => {
|
||||
const tab = tabs.find((t) => t.tab.id === Number(id))?.tab;
|
||||
if (tab) pinHierarchyTab(tab.id, !tab.pinned);
|
||||
}}
|
||||
onContextMenu={(id, e) => {
|
||||
const tab = tabs.find((t) => t.tab.id === Number(id))?.tab;
|
||||
if (!tab) return;
|
||||
// IDEA's content tab menu.
|
||||
showContextMenu(e, [
|
||||
{ id: "close", label: "Close Tab", run: () => closeHierarchyTab(tab.id) },
|
||||
{ id: "closeAll", label: "Close All Tabs", run: () => tabs.forEach((t) => closeHierarchyTab(t.tab.id)) },
|
||||
{
|
||||
id: "closeOthers",
|
||||
label: "Close Other Tabs",
|
||||
disabled: tabs.length < 2,
|
||||
run: () => tabs.forEach((t) => t.tab.id !== tab.id && closeHierarchyTab(t.tab.id)),
|
||||
},
|
||||
{ kind: "separator" },
|
||||
{ id: "pin", label: tab.pinned ? "Unpin Tab" : "Pin Tab", run: () => pinHierarchyTab(tab.id, !tab.pinned) },
|
||||
]);
|
||||
}}
|
||||
items={[{ id: "current", label, closable: true }]}
|
||||
activeId="current"
|
||||
onSelect={() => undefined}
|
||||
onClose={closeHierarchy}
|
||||
/>
|
||||
);
|
||||
}
|
||||
@@ -140,7 +114,7 @@ function HierarchyToolbar() {
|
||||
}
|
||||
|
||||
export function HierarchyView() {
|
||||
const { mode, direction, root, children, failed, notes, loading, expanded, generation } = useHierarchy();
|
||||
const { mode, direction, root, children, failed, notes, loading, generation } = useHierarchy();
|
||||
const projectRoot = useProject((s) => s.project?.root ?? "");
|
||||
const roots = useMemo<Node[]>(() => (root ? [{ kind: "root", id: ROOT_ID }] : []), [root]);
|
||||
|
||||
@@ -250,12 +224,11 @@ export function HierarchyView() {
|
||||
getChildren={getChildren}
|
||||
isExpandable={isExpandable}
|
||||
loadChildren={(n) => (n.kind === "item" ? loadChildren(n.node) : undefined)}
|
||||
onExpandedChange={(opened, n, open) => {
|
||||
useHierarchy.setState({ expanded: [...opened] });
|
||||
onExpandedChange={(_expanded, n, open) => {
|
||||
const shown = open ? children.get(n.id) : undefined;
|
||||
if (shown) prefetchLevels(shown);
|
||||
}}
|
||||
defaultExpanded={expanded}
|
||||
defaultExpanded={[ROOT_ID]}
|
||||
handleRef={tree}
|
||||
isOccurrence={() => true}
|
||||
onSelectionChange={(_sel, n) => {
|
||||
|
||||
@@ -306,45 +306,3 @@ describe("closing the hierarchy tab", () => {
|
||||
expect(hide).toHaveBeenCalledWith("hierarchy", { removeFromStripe: true });
|
||||
});
|
||||
});
|
||||
|
||||
describe("hierarchy tabs", () => {
|
||||
it("replace the selected tab unless it is pinned, and keep each tab's tree", async () => {
|
||||
const { closeHierarchyTab, pinHierarchyTab, selectHierarchyTab, tabHierarchy } = await import("./hierarchy");
|
||||
const names = () => {
|
||||
const s = useHierarchy.getState();
|
||||
return s.tabs.map((t) => `${tabHierarchy(s, t).mode}:${t.pinned ? "pinned" : ""}`);
|
||||
};
|
||||
resetHierarchy();
|
||||
await showHierarchy("call");
|
||||
await showHierarchy("type");
|
||||
expect(names()).toEqual(["type:"]);
|
||||
const first = useHierarchy.getState().active!;
|
||||
pinHierarchyTab(first, true);
|
||||
await showHierarchy("call");
|
||||
expect(names()).toEqual(["type:pinned", "call:"]);
|
||||
const second = useHierarchy.getState().active!;
|
||||
expect(
|
||||
useHierarchy
|
||||
.getState()
|
||||
.children.get(ROOT_ID)
|
||||
?.map((n) => n.item.name),
|
||||
).toEqual(["main"]);
|
||||
|
||||
selectHierarchyTab(first);
|
||||
expect(useHierarchy.getState().mode).toBe("type");
|
||||
selectHierarchyTab(second);
|
||||
expect(useHierarchy.getState().mode).toBe("call");
|
||||
expect(
|
||||
useHierarchy
|
||||
.getState()
|
||||
.children.get(ROOT_ID)
|
||||
?.map((n) => n.item.name),
|
||||
).toEqual(["main"]);
|
||||
|
||||
closeHierarchyTab(second);
|
||||
expect(useHierarchy.getState()).toMatchObject({ active: first, mode: "type" });
|
||||
expect(names()).toEqual(["type:pinned"]);
|
||||
closeHierarchyTab(first);
|
||||
expect(useHierarchy.getState()).toMatchObject({ root: null, tabs: [], active: null });
|
||||
});
|
||||
});
|
||||
@@ -54,27 +54,8 @@ interface HierarchyState {
|
||||
/** Parent id → why its children may be missing callers. */
|
||||
notes: ReadonlyMap<string, string>;
|
||||
loading: boolean;
|
||||
/** Ids of the expanded nodes, so a tab shown again keeps its tree open. */
|
||||
expanded: readonly string[];
|
||||
/** Bumped per (re)query so stale responses are dropped and the tree resets. */
|
||||
generation: number;
|
||||
/** Content tabs; the selected one's hierarchy is the state above. */
|
||||
tabs: readonly HierarchyTab[];
|
||||
active: number | null;
|
||||
}
|
||||
|
||||
/** The hierarchy of a tab that isn't selected. */
|
||||
export type SavedHierarchy = Pick<
|
||||
HierarchyState,
|
||||
"mode" | "direction" | "root" | "children" | "failed" | "notes" | "loading" | "expanded"
|
||||
>;
|
||||
|
||||
export interface HierarchyTab {
|
||||
id: number;
|
||||
/** Pinned: a new hierarchy opens beside it instead of taking its place. */
|
||||
pinned: boolean;
|
||||
/** Null for the selected tab. */
|
||||
saved: SavedHierarchy | null;
|
||||
}
|
||||
|
||||
export const ROOT_ID = "root";
|
||||
@@ -87,89 +68,9 @@ export const useHierarchy = create<HierarchyState>(() => ({
|
||||
failed: new Set(),
|
||||
notes: new Map(),
|
||||
loading: false,
|
||||
expanded: [ROOT_ID],
|
||||
generation: 0,
|
||||
tabs: [],
|
||||
active: null,
|
||||
}));
|
||||
|
||||
let tabSeq = 0;
|
||||
|
||||
function saved(s: HierarchyState): SavedHierarchy {
|
||||
const { mode, direction, root, children, failed, notes, loading, expanded } = s;
|
||||
return { mode, direction, root, children, failed, notes, loading, expanded };
|
||||
}
|
||||
|
||||
/** A tab's mode, direction and root: the live state's for the selected one. */
|
||||
export function tabHierarchy(s: HierarchyState, tab: HierarchyTab): SavedHierarchy {
|
||||
return tab.saved ?? saved(s);
|
||||
}
|
||||
|
||||
/**
|
||||
* As IDEA: a new hierarchy takes the place of the selected tab unless it is pinned,
|
||||
* then it opens in a tab of its own.
|
||||
*/
|
||||
function openTab() {
|
||||
const s = useHierarchy.getState();
|
||||
const current = s.tabs.find((t) => t.id === s.active);
|
||||
if (current && !current.pinned) return;
|
||||
cancelInflight();
|
||||
const id = ++tabSeq;
|
||||
useHierarchy.setState({
|
||||
tabs: [
|
||||
...s.tabs.map((t) => (t.id === s.active ? { ...t, saved: saved(s) } : t)),
|
||||
{ id, pinned: false, saved: null },
|
||||
],
|
||||
active: id,
|
||||
root: null,
|
||||
children: new Map(),
|
||||
failed: new Set(),
|
||||
notes: new Map(),
|
||||
loading: false,
|
||||
expanded: [ROOT_ID],
|
||||
generation: s.generation + 1,
|
||||
});
|
||||
}
|
||||
|
||||
export function selectHierarchyTab(id: number) {
|
||||
const s = useHierarchy.getState();
|
||||
const target = s.tabs.find((t) => t.id === id);
|
||||
if (id === s.active || !target?.saved) return;
|
||||
cancelInflight();
|
||||
const next = target.saved;
|
||||
useHierarchy.setState({
|
||||
...next,
|
||||
loading: false,
|
||||
generation: s.generation + 1,
|
||||
active: id,
|
||||
tabs: s.tabs.map((t) => (t.id === s.active ? { ...t, saved: saved(s) } : t.id === id ? { ...t, saved: null } : t)),
|
||||
});
|
||||
// Its requests were dropped when it was left: load it again.
|
||||
if (next.loading) void loadRoot();
|
||||
}
|
||||
|
||||
/** Closes a tab; the tool window goes with the last one. */
|
||||
export function closeHierarchyTab(id: number) {
|
||||
const s = useHierarchy.getState();
|
||||
const at = s.tabs.findIndex((t) => t.id === id);
|
||||
if (at < 0) return;
|
||||
const rest = s.tabs.filter((t) => t.id !== id);
|
||||
if (!rest.length) {
|
||||
closeHierarchy();
|
||||
return;
|
||||
}
|
||||
if (id !== s.active) {
|
||||
useHierarchy.setState({ tabs: rest });
|
||||
return;
|
||||
}
|
||||
useHierarchy.setState({ tabs: rest, active: null });
|
||||
selectHierarchyTab((s.tabs[at + 1] ?? s.tabs[at - 1])!.id);
|
||||
}
|
||||
|
||||
export function pinHierarchyTab(id: number, pinned: boolean) {
|
||||
useHierarchy.setState((s) => ({ tabs: s.tabs.map((t) => (t.id === id ? { ...t, pinned } : t)) }));
|
||||
}
|
||||
|
||||
/** Call hierarchy requests the current tree still waits for. */
|
||||
const inflight = new Set<RequestId>();
|
||||
|
||||
@@ -187,10 +88,7 @@ export function resetHierarchy() {
|
||||
failed: new Set(),
|
||||
notes: new Map(),
|
||||
loading: false,
|
||||
expanded: [ROOT_ID],
|
||||
generation: s.generation + 1,
|
||||
tabs: [],
|
||||
active: null,
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -350,14 +248,7 @@ async function loadRoot(quiet = false): Promise<RootResult> {
|
||||
if (!root) return "stale";
|
||||
const generation = s.generation + 1;
|
||||
cancelInflight();
|
||||
useHierarchy.setState({
|
||||
generation,
|
||||
children: new Map(),
|
||||
failed: new Set(),
|
||||
notes: new Map(),
|
||||
loading: true,
|
||||
expanded: [ROOT_ID],
|
||||
});
|
||||
useHierarchy.setState({ generation, children: new Map(), failed: new Set(), notes: new Map(), loading: true });
|
||||
try {
|
||||
const { items, incomplete } = await withDocument(root.path, (doc) =>
|
||||
request(s.mode, doc, root.path, root.line, root.col, s.direction),
|
||||
@@ -474,7 +365,6 @@ export async function showHierarchy(mode: HierarchyMode) {
|
||||
hint("Open a file to show the hierarchy");
|
||||
return;
|
||||
}
|
||||
openTab();
|
||||
const s = useHierarchy.getState();
|
||||
const direction = s.mode === mode ? s.direction : mode === "call" ? "incoming" : "outgoing";
|
||||
useHierarchy.setState({
|
||||
|
||||
@@ -191,7 +191,6 @@ function providePluginEndpoints(pluginId: string): () => void {
|
||||
export function defineBuiltinUiPoints(): () => void {
|
||||
const disposers = [
|
||||
defineUiPoint("mcpTools", {}),
|
||||
defineUiPoint("serverCommands", {}),
|
||||
defineUiPoint("endpoints", { project: ({ pluginId }) => providePluginEndpoints(pluginId) }),
|
||||
defineUiPoint<CommandDecl>("commands", {
|
||||
title: "Commands",
|
||||
|
||||
@@ -69,14 +69,3 @@ it("keeps an agent's commands out of other tabs", async () => {
|
||||
await startRun(agent, undefined, undefined, { prepared: true });
|
||||
expect(useRun.getState().sessions).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("gives runs started together their own tabs", async () => {
|
||||
useRun.setState({ sessions: [finished("a"), finished("b")], activeSession: "a" });
|
||||
await Promise.all([
|
||||
startRun(config("x"), "a", undefined, { prepared: true }),
|
||||
startRun(config("y"), undefined, undefined, { prepared: true }),
|
||||
startRun(config("z"), undefined, undefined, { prepared: true }),
|
||||
]);
|
||||
expect(tabs()).toEqual(["a:x", "b:y", expect.stringMatching(/^run\d+:z$/)]);
|
||||
expect(ipc.runStart).toHaveBeenCalledTimes(3);
|
||||
});
|
||||
@@ -760,58 +760,38 @@ export function sessionsOf(config: RunConfig, sessions = useRun.getState().sessi
|
||||
* Agents' commands keep to their own tabs.
|
||||
*/
|
||||
function reusableTab(sessions: readonly RunSession[], active: string | null, config: RunConfig) {
|
||||
const free = sessions.filter((s) => !isLive(s) && !s.pinned && !claimedTabs.has(s.id));
|
||||
const free = sessions.filter((s) => !isLive(s) && !s.pinned);
|
||||
const same = free.find((s) => s.config.id === config.id);
|
||||
if (same || agentName(config) !== null) return same;
|
||||
const others = free.filter((s) => agentName(s.config) === null);
|
||||
return others.find((s) => s.id === active) ?? others[0];
|
||||
}
|
||||
|
||||
/** Tabs a starting run is about to take: runs started together (compounds, reruns of several packages) must not take the same one. */
|
||||
const claimedTabs = new Set<string>();
|
||||
|
||||
/** Pins or unpins a session's tab. */
|
||||
export function pinSession(id: string, pinned: boolean) {
|
||||
patchSession(id, { pinned });
|
||||
}
|
||||
|
||||
interface StartRunOptions {
|
||||
show?: boolean;
|
||||
/** Launch this instead of `config` (e.g. with a debug agent); the tab still shows `config`. Skips before launch tasks. */
|
||||
launch?: RunConfig;
|
||||
/** Every output line of this run. */
|
||||
onLine?: (text: string) => void;
|
||||
/** The process exited. */
|
||||
onExit?: (exitCode: number | null, stopped: boolean) => void;
|
||||
/** Before launch tasks already ran (or must not run). */
|
||||
prepared?: boolean;
|
||||
/** Configurations whose launch led to this one (before launch tasks, compounds): breaks cycles. */
|
||||
chain?: readonly string[];
|
||||
/** Runs before the stop signal when the user stops this run (run executors). */
|
||||
beforeStop?: (runId: RunId) => Promise<void>;
|
||||
}
|
||||
|
||||
/** Starts `config`, reusing the tab of a finished (or the given) session (see `reusableTab`). */
|
||||
export async function startRun(
|
||||
config: RunConfig,
|
||||
reuse?: string,
|
||||
baseConfig?: RunConfig,
|
||||
options: StartRunOptions = {},
|
||||
): Promise<RunSession | null> {
|
||||
if (!reuse || claimedTabs.has(reuse)) return startRunIn(config, reuse, baseConfig, options);
|
||||
claimedTabs.add(reuse);
|
||||
try {
|
||||
return await startRunIn(config, reuse, baseConfig, options);
|
||||
} finally {
|
||||
claimedTabs.delete(reuse);
|
||||
}
|
||||
}
|
||||
|
||||
async function startRunIn(
|
||||
config: RunConfig,
|
||||
reuse: string | undefined,
|
||||
baseConfig: RunConfig | undefined,
|
||||
options: StartRunOptions,
|
||||
options: {
|
||||
show?: boolean;
|
||||
/** Launch this instead of `config` (e.g. with a debug agent); the tab still shows `config`. Skips before launch tasks. */
|
||||
launch?: RunConfig;
|
||||
/** Every output line of this run. */
|
||||
onLine?: (text: string) => void;
|
||||
/** The process exited. */
|
||||
onExit?: (exitCode: number | null, stopped: boolean) => void;
|
||||
/** Before launch tasks already ran (or must not run). */
|
||||
prepared?: boolean;
|
||||
/** Configurations whose launch led to this one (before launch tasks, compounds): breaks cycles. */
|
||||
chain?: readonly string[];
|
||||
/** Runs before the stop signal when the user stops this run (run executors). */
|
||||
beforeStop?: (runId: RunId) => Promise<void>;
|
||||
} = {},
|
||||
): Promise<RunSession | null> {
|
||||
config = withRunTarget(config);
|
||||
if (!options.launch && isCMakeBuild(config)) {
|
||||
@@ -861,16 +841,12 @@ async function startRunIn(
|
||||
// IDEA there is no time limit: a first Stop waits for the shutdown, a second one kills it.
|
||||
await waitForExit(stopping, null);
|
||||
const now = useRun.getState();
|
||||
const picked = session ? undefined : reusableTab(now.sessions, now.activeSession, config);
|
||||
session ??= picked;
|
||||
session ??= reusableTab(now.sessions, now.activeSession, config);
|
||||
|
||||
if (picked) claimedTabs.add(picked.id);
|
||||
try {
|
||||
await maybeEditorService()?.saveAll();
|
||||
} catch {
|
||||
/* saving is best effort */
|
||||
} finally {
|
||||
if (picked) claimedTabs.delete(picked.id);
|
||||
}
|
||||
|
||||
const startedAt = Date.now();
|
||||
|
||||
@@ -115,19 +115,7 @@ const GENERAL = editorPage({
|
||||
{
|
||||
title: "Mouse Control",
|
||||
items: [
|
||||
{
|
||||
t: "check",
|
||||
key: `${P}.general.wheelZoom`,
|
||||
label: "Change font size with Ctrl/Command+Mouse Wheel",
|
||||
inline: {
|
||||
kind: "select",
|
||||
key: `${P}.general.wheelZoomScope`,
|
||||
options: [
|
||||
{ value: "active", label: "Active editor" },
|
||||
{ value: "all", label: "All editors" },
|
||||
],
|
||||
},
|
||||
},
|
||||
{ t: "check", key: `${P}.general.wheelZoom`, label: "Change font size with Ctrl/Command+Mouse Wheel" },
|
||||
{ t: "check", key: `${P}.general.dragAndDrop`, label: "Enable drag-and-drop functionality in editor" },
|
||||
],
|
||||
},
|
||||
|
||||
@@ -504,12 +504,6 @@ export const VCS_PAGES: PageSpec[] = [
|
||||
{
|
||||
title: "Commit",
|
||||
options: [
|
||||
{
|
||||
kind: "toggle",
|
||||
key: "vcs.git.stagingArea",
|
||||
label: "Enable staging area",
|
||||
hint: "Commit works on the Git index: stage and unstage changes instead of checking them. Change lists are not used. Only for the non-modal commit interface.",
|
||||
},
|
||||
{ kind: "toggle", key: "vcs.git.warnCrlf", label: "Warn if CRLF line separators are about to be committed" },
|
||||
{
|
||||
kind: "toggle",
|
||||
|
||||
@@ -1,83 +0,0 @@
|
||||
.root {
|
||||
flex: 1;
|
||||
height: 100%;
|
||||
min-height: 0;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
background: var(--bg-app);
|
||||
}
|
||||
.toolbar {
|
||||
flex: none;
|
||||
height: var(--h-header);
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--space-0-5);
|
||||
padding: 0 6px;
|
||||
border-bottom: 1px solid var(--border);
|
||||
}
|
||||
.toolbar > * {
|
||||
flex-shrink: 0;
|
||||
}
|
||||
.sep {
|
||||
width: 1px;
|
||||
height: 14px;
|
||||
margin: 0 4px;
|
||||
background: var(--border-strong);
|
||||
}
|
||||
.count {
|
||||
padding: 0 6px;
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--fs-small);
|
||||
white-space: nowrap;
|
||||
}
|
||||
.grow {
|
||||
flex: 1;
|
||||
}
|
||||
.scroll {
|
||||
flex: 1;
|
||||
min-height: 0;
|
||||
overflow-y: auto;
|
||||
}
|
||||
.block {
|
||||
border-bottom: 1px solid var(--border);
|
||||
}
|
||||
/* The file's header stays at the top while its diff scrolls by. */
|
||||
.header {
|
||||
position: sticky;
|
||||
top: 0;
|
||||
z-index: 3;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--space-1);
|
||||
height: var(--h-header);
|
||||
padding: 0 6px;
|
||||
background: var(--bg-elev);
|
||||
border-bottom: 1px solid var(--border);
|
||||
}
|
||||
.name {
|
||||
flex: none;
|
||||
font-weight: 500;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.dir {
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
color: var(--fg-subtle);
|
||||
font-size: var(--fs-small);
|
||||
}
|
||||
.body {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
}
|
||||
/* Space a block takes before its diff loads, so the scrollbar is roughly right. */
|
||||
.placeholder {
|
||||
height: 160px;
|
||||
}
|
||||
.empty {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
color: var(--fg-subtle);
|
||||
}
|
||||
@@ -1,219 +0,0 @@
|
||||
/**
|
||||
* The all-in-one diff tab (`combined-diff`): one block per file of a change, each a diff
|
||||
* as tall as its content under a sticky header, in one scrolling view. Blocks load as they
|
||||
* come near the viewport; a header collapses its block or opens the file's own diff tab.
|
||||
*/
|
||||
import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
|
||||
import clsx from "clsx";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { relativeDir, useProject } from "@/platform/project";
|
||||
import { Icon, IconButton, T, fileIconName } from "@/ui";
|
||||
import { editorService, type EditorInput } from "@/workbench/contributions";
|
||||
import { setAllInOneDiff, type CombinedDiffData } from "./allInOneDiff";
|
||||
import { DiffEditor } from "./DiffEditor";
|
||||
import { diffInput, openDiff, withChain, type DiffData } from "./diffInput";
|
||||
import { loadDiffOptions, saveDiffOptions } from "./diffOptions";
|
||||
import { KIND_COLOR, KIND_LABEL, baseName, fileCount } from "./model";
|
||||
import styles from "./CombinedDiff.module.css";
|
||||
|
||||
type Kind = "added" | "deleted" | "modified";
|
||||
|
||||
/** What happened to the file: one side absent means added or deleted. */
|
||||
export function blockKind(item: DiffData): Kind {
|
||||
const absent = (s: DiffData["left"]) => s.type === "text" && !!s.absent;
|
||||
return absent(item.left) ? "added" : absent(item.right) ? "deleted" : "modified";
|
||||
}
|
||||
|
||||
/** How far below the viewport a block starts loading (above it, only once scrolled to). */
|
||||
const PRELOAD = "0px 0px 800px 0px";
|
||||
|
||||
function Block({
|
||||
item,
|
||||
index,
|
||||
items,
|
||||
collapsed,
|
||||
onToggle,
|
||||
mode,
|
||||
}: {
|
||||
item: DiffData;
|
||||
index: number;
|
||||
items: readonly DiffData[];
|
||||
collapsed: boolean;
|
||||
onToggle: () => void;
|
||||
mode: "split" | "unified";
|
||||
}) {
|
||||
const ref = useRef<HTMLElement>(null);
|
||||
// Without IntersectionObserver (tests), every block loads at once.
|
||||
const [near, setNear] = useState(() => typeof IntersectionObserver === "undefined");
|
||||
useEffect(() => {
|
||||
const el = ref.current;
|
||||
if (!el || near) return;
|
||||
const io = new IntersectionObserver(
|
||||
(entries) => {
|
||||
if (entries.some((e) => e.isIntersecting)) setNear(true);
|
||||
},
|
||||
{ root: el.closest("[data-combined-scroll]"), rootMargin: PRELOAD },
|
||||
);
|
||||
io.observe(el);
|
||||
return () => io.disconnect();
|
||||
}, [near]);
|
||||
const input: EditorInput = useMemo(() => diffInput({ ...item, mode }), [item, mode]);
|
||||
const kind = blockKind(item);
|
||||
const name = baseName(item.path);
|
||||
const root = useProject((s) => s.project?.root ?? "");
|
||||
const dir = relativeDir(root, item.path);
|
||||
return (
|
||||
<section ref={ref} className={styles.block} data-combined-block={item.path} aria-label={name}>
|
||||
<div className={styles.header}>
|
||||
<IconButton
|
||||
icon={collapsed ? "chevron-right" : "chevron-down"}
|
||||
title={collapsed ? "Expand File" : "Collapse File"}
|
||||
size="small"
|
||||
aria-expanded={!collapsed}
|
||||
onClick={onToggle}
|
||||
/>
|
||||
<Icon name={fileIconName(name)} size={16} />
|
||||
<span className={styles.name} style={{ color: KIND_COLOR[kind] }} title={tx(KIND_LABEL[kind])}>
|
||||
{name}
|
||||
</span>
|
||||
{dir && (
|
||||
<span className={styles.dir} title={item.path}>
|
||||
{dir}
|
||||
</span>
|
||||
)}
|
||||
<span className={styles.grow} />
|
||||
<IconButton
|
||||
icon="diff"
|
||||
title="Open in Separate Tab"
|
||||
size="small"
|
||||
// The file's own diff, still knowing its siblings for Compare Next File.
|
||||
onClick={() => void editorService().openInput(diffInput(withChain(items, index)), { focus: true })}
|
||||
/>
|
||||
{item.right.type === "worktree" && (
|
||||
<IconButton
|
||||
icon="edit"
|
||||
title="Jump to Source"
|
||||
size="small"
|
||||
onClick={() => void editorService().openFile(item.path, { focus: true })}
|
||||
/>
|
||||
)}
|
||||
</div>
|
||||
{!collapsed &&
|
||||
(near ? (
|
||||
<div className={styles.body}>
|
||||
<DiffEditor input={input} fit />
|
||||
</div>
|
||||
) : (
|
||||
<div className={styles.placeholder} />
|
||||
))}
|
||||
</section>
|
||||
);
|
||||
}
|
||||
|
||||
export function CombinedDiffTab({ input }: { input: EditorInput }) {
|
||||
const data = input.data as CombinedDiffData;
|
||||
const items = data.items;
|
||||
const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(() => new Set());
|
||||
const [mode, setMode] = useState(() => loadDiffOptions().mode);
|
||||
const scrollRef = useRef<HTMLDivElement>(null);
|
||||
|
||||
const blocks = () => [...(scrollRef.current?.querySelectorAll<HTMLElement>("[data-combined-block]") ?? [])];
|
||||
/** The block at the top of the view. */
|
||||
const current = () => {
|
||||
const top = scrollRef.current?.getBoundingClientRect().top ?? 0;
|
||||
const all = blocks();
|
||||
const at = all.findIndex((b) => b.getBoundingClientRect().bottom > top + 1);
|
||||
return at < 0 ? all.length - 1 : at;
|
||||
};
|
||||
const scrollTo = (path: string) => {
|
||||
const el = blocks().find((b) => b.dataset.combinedBlock === path);
|
||||
const scroller = scrollRef.current;
|
||||
if (el && scroller) scroller.scrollTop += el.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
|
||||
};
|
||||
const step = (dir: 1 | -1) => {
|
||||
const next = items[current() + dir];
|
||||
if (next) scrollTo(next.path);
|
||||
};
|
||||
|
||||
// Open at the file the diff was asked for.
|
||||
useLayoutEffect(() => {
|
||||
if (data.reveal) scrollTo(data.reveal);
|
||||
// Once per tab: later revisits keep their scroll position.
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, []);
|
||||
|
||||
const setViewer = (next: "split" | "unified") => {
|
||||
setMode(next);
|
||||
saveDiffOptions({ ...loadDiffOptions(), mode: next });
|
||||
};
|
||||
const toggle = (path: string) =>
|
||||
setCollapsed((c) => {
|
||||
const s = new Set(c);
|
||||
if (s.has(path)) s.delete(path);
|
||||
else s.add(path);
|
||||
return s;
|
||||
});
|
||||
const allCollapsed = items.length > 0 && items.every((i) => collapsed.has(i.path));
|
||||
|
||||
return (
|
||||
<div className={styles.root}>
|
||||
<div className={styles.toolbar} role="toolbar" aria-label={tx("Combined Changes Diff")}>
|
||||
<IconButton icon="arrow-up" title="Previous File" size="small" onClick={() => step(-1)} />
|
||||
<IconButton icon="arrow-down" title="Next File" size="small" onClick={() => step(1)} />
|
||||
<IconButton
|
||||
icon={allCollapsed ? "expand-all" : "collapse-all"}
|
||||
title={allCollapsed ? "Expand All Files" : "Collapse All Files"}
|
||||
size="small"
|
||||
onClick={() => setCollapsed(allCollapsed ? new Set() : new Set(items.map((i) => i.path)))}
|
||||
/>
|
||||
<span className={styles.sep} />
|
||||
<IconButton
|
||||
icon="diff-side-by-side"
|
||||
title="Side-by-side Viewer"
|
||||
size="small"
|
||||
pressed={mode === "split"}
|
||||
onClick={() => setViewer("split")}
|
||||
/>
|
||||
<IconButton
|
||||
icon="diff-unified"
|
||||
title="Unified Viewer"
|
||||
size="small"
|
||||
pressed={mode === "unified"}
|
||||
onClick={() => setViewer("unified")}
|
||||
/>
|
||||
<span className={styles.count}>{fileCount(items.length)}</span>
|
||||
<span className={styles.grow} />
|
||||
<IconButton
|
||||
icon="editor-only"
|
||||
title="Show Files in Separate Diff Tabs"
|
||||
size="small"
|
||||
onClick={() => {
|
||||
// Back to one diff per file, at the file in view.
|
||||
setAllInOneDiff(false);
|
||||
const at = Math.max(0, current());
|
||||
void openDiff(withChain(items, at)).then(() => editorService().closeInput?.(input.key));
|
||||
}}
|
||||
/>
|
||||
</div>
|
||||
<div ref={scrollRef} className={styles.scroll} data-combined-scroll>
|
||||
{items.length ? (
|
||||
items.map((item, index) => (
|
||||
<Block
|
||||
key={`${item.path}:${mode}`}
|
||||
item={item}
|
||||
index={index}
|
||||
items={items}
|
||||
collapsed={collapsed.has(item.path)}
|
||||
onToggle={() => toggle(item.path)}
|
||||
mode={mode}
|
||||
/>
|
||||
))
|
||||
) : (
|
||||
<div className={clsx(styles.placeholder, styles.empty)}>
|
||||
<T>No changes</T>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -344,13 +344,3 @@
|
||||
.checkProblemLink:hover {
|
||||
text-decoration: underline;
|
||||
}
|
||||
/* Staging area: Stage / Unstage on the hovered or selected row, as a hover icon at the row's end. */
|
||||
.stageButton {
|
||||
flex: none;
|
||||
margin-left: auto;
|
||||
visibility: hidden;
|
||||
}
|
||||
[role="treeitem"]:hover .stageButton,
|
||||
[role="treeitem"][aria-selected="true"] .stageButton {
|
||||
visibility: visible;
|
||||
}
|
||||
@@ -61,7 +61,6 @@ import {
|
||||
import { applyStash, commitChanges, deleteFiles, dropStash, showUnstashDialog, stashChanges } from "./changeOps";
|
||||
import { CommitOptionsPopup } from "./CommitOptions";
|
||||
import { DEFAULT_LIST_NAME, useChangelists, withListDefaults } from "./changelists";
|
||||
import { inclusionChecks, isCommitAll, useStagingArea } from "./staging";
|
||||
import { addToChangelist, commitFiles } from "./changelistsUi";
|
||||
import { acceptSide } from "./conflictsUi";
|
||||
import { copyChangesAsPatch } from "./patches";
|
||||
@@ -398,14 +397,13 @@ export function nodeMenu(
|
||||
{
|
||||
label: "Stage",
|
||||
icon: "plus",
|
||||
// Under Staged Changes, a partially staged file only offers Unstage.
|
||||
disabled: !files.some((f) => f.unstaged) || nodes.every((n) => n.group === "staged"),
|
||||
disabled: !files.some((f) => f.unstaged),
|
||||
run: () => void runOp(tx`Stage ${paths.length} files`, () => call(commands.vcsStage(paths))),
|
||||
},
|
||||
{
|
||||
label: "Unstage",
|
||||
icon: "minus",
|
||||
disabled: !files.some((f) => f.staged) || nodes.every((n) => n.group === "unstaged" || n.group === "unversioned"),
|
||||
disabled: !files.some((f) => f.staged),
|
||||
run: () => void runOp(tx`Unstage ${paths.length} files`, () => call(commands.vcsUnstage(paths))),
|
||||
},
|
||||
{ kind: "separator" },
|
||||
@@ -432,41 +430,6 @@ export function nodeMenu(
|
||||
return items;
|
||||
}
|
||||
|
||||
/**
|
||||
* The staging operation of a node of the staging area's tree: Unstage under Staged, Stage
|
||||
* under Unstaged and Unversioned Files, applied to every file below the node.
|
||||
*/
|
||||
export function stageOperation(n: ChangeNode): { label: string; icon: "plus" | "minus"; paths: string[] } | null {
|
||||
const paths = n.files.map((f) => stripSlash(f.path));
|
||||
if (!paths.length) return null;
|
||||
if (n.group === "staged") return { label: "Unstage", icon: "minus", paths };
|
||||
if (n.group === "unstaged" || n.group === "unversioned") return { label: "Stage", icon: "plus", paths };
|
||||
return null;
|
||||
}
|
||||
|
||||
function StageButton({ node }: { node: ChangeNode }) {
|
||||
const op = stageOperation(node);
|
||||
if (!op) return null;
|
||||
const { label, icon, paths } = op;
|
||||
const count = paths.length;
|
||||
return (
|
||||
<IconButton
|
||||
icon={icon}
|
||||
title={label}
|
||||
size="small"
|
||||
className={styles.stageButton}
|
||||
onMouseDown={(e) => e.stopPropagation()}
|
||||
onDoubleClick={(e) => e.stopPropagation()}
|
||||
onClick={(e) => {
|
||||
e.stopPropagation();
|
||||
void runOp(icon === "plus" ? tx`Stage ${count} files` : tx`Unstage ${count} files`, () =>
|
||||
call(icon === "plus" ? commands.vcsStage(paths) : commands.vcsUnstage(paths)),
|
||||
).then(() => refreshNow());
|
||||
}}
|
||||
/>
|
||||
);
|
||||
}
|
||||
|
||||
function CheckMark({
|
||||
checked,
|
||||
indeterminate,
|
||||
@@ -503,11 +466,7 @@ function useCommitChecks() {
|
||||
const root = useVcs((s) => s.root) ?? "";
|
||||
const userChecks = useCommit((s) => s.checks);
|
||||
const lists = useChangelists((s) => s.state);
|
||||
const staging = useStagingArea();
|
||||
return useMemo(
|
||||
() => inclusionChecks(status, root, lists, userChecks, staging),
|
||||
[status, root, lists, userChecks, staging],
|
||||
);
|
||||
return useMemo(() => withListDefaults(status, root, lists, userChecks), [status, root, lists, userChecks]);
|
||||
}
|
||||
|
||||
/** Number of changes the commit would include. */
|
||||
@@ -608,17 +567,14 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
|
||||
const status = useVcs((s) => s.status);
|
||||
const root = useVcs((s) => s.root) ?? "";
|
||||
const groupByDir = useCommit((s) => s.groupByDir);
|
||||
// With the staging area the Commit tool window shows the index: Staged / Unstaged, no lists or checkboxes.
|
||||
const staging = useStagingArea() && mode === "commit";
|
||||
const groupByStaging = useCommit((s) => s.groupByStaging) || staging;
|
||||
const groupByStaging = useCommit((s) => s.groupByStaging);
|
||||
const groupByRepo = useCommit((s) => s.groupByRepo);
|
||||
const diffPreview = useCommit((s) => s.diffPreview);
|
||||
const commitDiffPreview = useCommit((s) => s.commitDiffPreview);
|
||||
const doubleClickOpensDiff = useWorkflowSettings((s) => s.vcs.commit.doubleClickOpensDiff);
|
||||
const changelists = useChangelists((s) => s.state);
|
||||
const lists = staging ? undefined : changelists;
|
||||
const lists = useChangelists((s) => s.state);
|
||||
const checks = useCommitChecks();
|
||||
const checkboxes = mode !== "local" && !staging;
|
||||
const checkboxes = mode !== "local";
|
||||
const [dropTarget, setDropTarget] = useState<string | null>(null);
|
||||
// IDEA starts with Unversioned Files collapsed.
|
||||
const [collapsed, setCollapsed] = useState<Set<string>>(() => new Set(["group:unversioned"]));
|
||||
@@ -753,9 +709,7 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
|
||||
...(repos.length > 1
|
||||
? [{ label: "Repository", checked: groupByRepo, run: () => setGroupByRepo(!groupByRepo) }]
|
||||
: []),
|
||||
...(staging
|
||||
? []
|
||||
: [{ label: "Staging State", checked: groupByStaging, run: () => setGroupByStaging(!groupByStaging) }]),
|
||||
{ label: "Staging State", checked: groupByStaging, run: () => setGroupByStaging(!groupByStaging) },
|
||||
...(mode === "local"
|
||||
? [
|
||||
{ kind: "separator" } as const,
|
||||
@@ -944,14 +898,13 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
|
||||
)}
|
||||
{label}
|
||||
{n.type === "group" && <span className={styles.detail}>{fileCount(n.files.length)}</span>}
|
||||
{!staging && n.type === "file" && n.files[0] && isPartiallyStaged(n.files[0]) && (
|
||||
{n.type === "file" && n.files[0] && isPartiallyStaged(n.files[0]) && (
|
||||
<span className={styles.partial} title={tx("Partially staged: only staged hunks are committed")}>
|
||||
<T>partial</T>
|
||||
</span>
|
||||
)}
|
||||
{n.detail && n.detailIcon && <Icon name={n.detailIcon} size={14} className={styles.detailIcon} />}
|
||||
{n.detail && <span className={styles.detail}>{n.detail}</span>}
|
||||
{staging && <StageButton node={n} />}
|
||||
</span>
|
||||
);
|
||||
}}
|
||||
@@ -1204,8 +1157,8 @@ function CommitMessageActions() {
|
||||
}
|
||||
|
||||
/** Label of the Commit button. */
|
||||
export function commitLabel(amend: boolean, problems: boolean, all = false): string {
|
||||
return problems ? "Commit Anyway" : amend ? "Amend Commit" : all ? "Commit All" : "Commit";
|
||||
export function commitLabel(amend: boolean, problems: boolean): string {
|
||||
return problems ? "Commit Anyway" : amend ? "Amend Commit" : "Commit";
|
||||
}
|
||||
|
||||
/** Label of the Commit and Push button. */
|
||||
@@ -1222,15 +1175,13 @@ function CommitPanel({ included }: { included: number }) {
|
||||
const { canCommit } = runner;
|
||||
// After Fixup… / Squash Into…, the second button commits and autosquashes the target.
|
||||
const fixup = useCommit((s) => pendingFixup(s.message, s.fixupTarget));
|
||||
const staging = useStagingArea();
|
||||
const commitAll = useVcs((s) => staging && isCommitAll(s.status));
|
||||
|
||||
return (
|
||||
<div className={styles.commit}>
|
||||
<CommitMessageField included={included} runner={runner} />
|
||||
<div className={styles.commitActions}>
|
||||
<Button variant="primary" disabled={!canCommit} onClick={() => void runner.run(false)} title="⌘↩">
|
||||
<T>{commitLabel(amend, checkProblems.length > 0, commitAll)}</T>
|
||||
<T>{commitLabel(amend, checkProblems.length > 0)}</T>
|
||||
</Button>
|
||||
{fixup ? (
|
||||
<Button
|
||||
|
||||
@@ -8,9 +8,6 @@
|
||||
flex-direction: column;
|
||||
background: var(--bg-app);
|
||||
}
|
||||
.toolbar[hidden] {
|
||||
display: none;
|
||||
}
|
||||
.toolbar {
|
||||
flex: none;
|
||||
height: var(--h-header);
|
||||
@@ -396,22 +393,3 @@
|
||||
animation: none;
|
||||
}
|
||||
}
|
||||
|
||||
/* A block of the all-in-one diff: as tall as its content, the tab scrolls. */
|
||||
.fit {
|
||||
flex: none;
|
||||
height: auto;
|
||||
}
|
||||
.fit .host {
|
||||
flex: none;
|
||||
}
|
||||
.fit .host > :global(.cm-editor) {
|
||||
flex: none;
|
||||
}
|
||||
.fit .host :global(.cm-mergeView) {
|
||||
flex: none;
|
||||
overflow-y: visible;
|
||||
}
|
||||
.fit .host :global(.cm-mergeViewEditors) {
|
||||
min-height: 0;
|
||||
}
|
||||
@@ -77,7 +77,6 @@ import {
|
||||
type DiffSide,
|
||||
} from "./diffInput";
|
||||
import { diffAnnotations } from "./diffAnnotations";
|
||||
import { setAllInOneDiff } from "./allInOneDiff";
|
||||
import { annotationsShown, blameSlot, toggleAnnotations } from "./blame";
|
||||
import { diffBlameTarget } from "./diffBlame";
|
||||
import { changedChainNeighbour } from "./diffNavigation";
|
||||
@@ -255,7 +254,6 @@ export function DiffEditor({
|
||||
onNeighbour,
|
||||
onJumpToSource,
|
||||
onClose,
|
||||
fit = false,
|
||||
}: {
|
||||
input: EditorInput;
|
||||
toolbarActions?: ReactNode;
|
||||
@@ -269,11 +267,6 @@ export function DiffEditor({
|
||||
onJumpToSource?: () => void;
|
||||
/** Closes the diff's editor tab (Esc, IDEA's Close Diff Editor); hosts that aren't tabs leave it out. */
|
||||
onClose?: () => void;
|
||||
/**
|
||||
* A block of the all-in-one diff: as tall as its content (the host scrolls), without the
|
||||
* toolbar, side-by-side panes always aligned, and not taking the editor tab's focus.
|
||||
*/
|
||||
fit?: boolean;
|
||||
}) {
|
||||
const input_ = input.data as DiffData;
|
||||
// Swap Sides shows the request's sides the other way round; another request starts unswapped.
|
||||
@@ -303,8 +296,6 @@ export function DiffEditor({
|
||||
// the unified layout of an empty side is exactly that. The saved mode stays as it is.
|
||||
const single = oneSided(data);
|
||||
const viewMode: DiffMode = single ? "unified" : opts.mode;
|
||||
/** Side-by-side panes padded to line up; a fitted block always is (its host scrolls, not the panes). */
|
||||
const aligned = fit || opts.alignChanges;
|
||||
const [lang, setLang] = useState<Extension | null>(null);
|
||||
const [chunkInfo, setChunkInfo] = useState({ count: 0, current: -1, moves: 0, whitespaceOnly: false });
|
||||
const [busy, setBusy] = useState(false);
|
||||
@@ -536,7 +527,7 @@ export function DiffEditor({
|
||||
let views: Views;
|
||||
if (viewMode === "split") {
|
||||
let merge: MergeView | null = null;
|
||||
const panes = aligned
|
||||
const panes = opts.alignChanges
|
||||
? null
|
||||
: new UnalignedPanes({
|
||||
sync: syncScroll.current,
|
||||
@@ -694,7 +685,7 @@ export function DiffEditor({
|
||||
lang,
|
||||
viewMode,
|
||||
single,
|
||||
aligned,
|
||||
opts.alignChanges,
|
||||
opts.collapse,
|
||||
opts.ignore,
|
||||
opts.highlight,
|
||||
@@ -714,8 +705,7 @@ export function DiffEditor({
|
||||
const views = viewsRef.current;
|
||||
if (!views) return;
|
||||
// Aligned panes scroll in MergeView's outer element, which scrollSnapshot does not cover.
|
||||
// A fitted block has no scroller of its own: anchoring would scroll the all-in-one diff.
|
||||
const outer = !fit && views.merge && !views.panes ? views.merge.dom : null;
|
||||
const outer = views.merge && !views.panes ? views.merge.dom : null;
|
||||
const top = outer?.getBoundingClientRect().top;
|
||||
const block = top == null ? null : views.b.lineBlockAtHeight(Math.max(0, top - views.b.documentTop));
|
||||
const anchor =
|
||||
@@ -740,15 +730,14 @@ export function DiffEditor({
|
||||
});
|
||||
return () => cancelAnimationFrame(frame);
|
||||
}
|
||||
}, [softWrap, wrapSlot, fit]);
|
||||
}, [softWrap, wrapSlot]);
|
||||
|
||||
useEffect(() => viewsRef.current?.panes?.setSync(opts.syncScroll), [opts.syncScroll]);
|
||||
|
||||
// The editor area focuses the tab's host (`[data-editor-focus]`), e.g. after F7 opened the next
|
||||
// file: hand that focus on to the diff, so its keymap and Jump to Source apply right away.
|
||||
useEffect(() => {
|
||||
// The blocks of an all-in-one diff share one tab: none takes its focus.
|
||||
const host = fit ? null : rootRef.current?.closest<HTMLElement>("[data-editor-focus]");
|
||||
const host = rootRef.current?.closest<HTMLElement>("[data-editor-focus]");
|
||||
const views = viewsRef.current;
|
||||
if (!host || !views) return;
|
||||
const forward = () => (focusedSide.current === "a" && views.a ? views.a : views.b).focus();
|
||||
@@ -758,7 +747,7 @@ export function DiffEditor({
|
||||
host.addEventListener("focus", onFocus);
|
||||
if (document.activeElement === host) forward();
|
||||
return () => host.removeEventListener("focus", onFocus);
|
||||
}, [viewsGen, fit]);
|
||||
}, [viewsGen]);
|
||||
|
||||
useEffect(
|
||||
() => () => {
|
||||
@@ -1189,25 +1178,10 @@ export function DiffEditor({
|
||||
{
|
||||
id: "align",
|
||||
label: "Align Changes",
|
||||
checked: aligned,
|
||||
disabled: viewMode !== "split" || fit,
|
||||
checked: opts.alignChanges,
|
||||
disabled: viewMode !== "split",
|
||||
run: () => setOpts({ alignChanges: !opts.alignChanges }),
|
||||
},
|
||||
// A tab of one file of a change: show every file of it in one scrollable tab instead.
|
||||
...(input_.chain && input_.chain.length > 1 && !input_.embedded && onClose
|
||||
? [
|
||||
{ kind: "separator" } as const,
|
||||
{
|
||||
id: "allInOne",
|
||||
label: "Show All Files in One Diff View",
|
||||
checked: false,
|
||||
run: () => {
|
||||
setAllInOneDiff(true);
|
||||
void openDiff(input_).then(() => onClose());
|
||||
},
|
||||
},
|
||||
]
|
||||
: []),
|
||||
...contribs.flatMap((c) => {
|
||||
const items = c.settingsItems?.() ?? [];
|
||||
return items.length ? [{ kind: "separator" } as const, ...items] : [];
|
||||
@@ -1332,7 +1306,7 @@ export function DiffEditor({
|
||||
return (
|
||||
<div
|
||||
ref={rootRef}
|
||||
className={clsx(styles.root, fit && styles.fit)}
|
||||
className={styles.root}
|
||||
onKeyDown={onKeyDown}
|
||||
onFocusCapture={() => {
|
||||
setFocusedDiffNavigator(nav.current);
|
||||
@@ -1345,7 +1319,7 @@ export function DiffEditor({
|
||||
}
|
||||
}}
|
||||
>
|
||||
<div ref={toolbarRef} className={styles.toolbar} role="toolbar" aria-label={tx("Diff")} hidden={fit}>
|
||||
<div ref={toolbarRef} className={styles.toolbar} role="toolbar" aria-label={tx("Diff")}>
|
||||
<IconButton
|
||||
icon="arrow-up"
|
||||
title="Previous Difference"
|
||||
@@ -1585,7 +1559,7 @@ export function DiffEditor({
|
||||
className={clsx(
|
||||
styles.host,
|
||||
opts.highlight === "none" && styles.noHighlight,
|
||||
viewMode === "split" && !aligned && styles.unaligned,
|
||||
viewMode === "split" && !opts.alignChanges && styles.unaligned,
|
||||
)}
|
||||
hidden={!!binary || !!error || !ready}
|
||||
aria-label={diffTitle(data)}
|
||||
|
||||
@@ -1,126 +0,0 @@
|
||||
import { act, fireEvent, render, screen } from "@testing-library/react";
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("../DiffEditor", () => ({
|
||||
DiffEditor: ({ input, fit }: { input: { data: { path: string; mode?: string } }; fit?: boolean }) => (
|
||||
<div data-testid="block-diff" data-path={input.data.path} data-mode={input.data.mode} data-fit={String(!!fit)} />
|
||||
),
|
||||
}));
|
||||
|
||||
import { provideEditorService, type EditorInput } from "@/workbench/contributions";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { allInOneDiff, combinedOf, setAllInOneDiff } from "../allInOneDiff";
|
||||
import { CombinedDiffTab, blockKind } from "../CombinedDiff";
|
||||
import { COMBINED_DIFF_KIND } from "../allInOneDiff";
|
||||
import { combinedDiffInput, openDiff, withChain, type DiffData } from "../diffInput";
|
||||
|
||||
const diff = (path: string, extra: Partial<DiffData> = {}): DiffData => ({
|
||||
path,
|
||||
left: { type: "rev", rev: "HEAD" },
|
||||
right: { type: "worktree" },
|
||||
...extra,
|
||||
});
|
||||
const items = [diff("/r/src/a.ts"), diff("/r/src/b.ts"), diff("/r/c.md")];
|
||||
|
||||
const openInput = vi.fn(async (_input: EditorInput, _opts?: unknown) => undefined);
|
||||
const closeInput = vi.fn();
|
||||
const openFile = vi.fn(async () => undefined);
|
||||
provideEditorService({ openInput, openFile, closeInput } as never);
|
||||
|
||||
beforeEach(() => {
|
||||
localStorage.clear();
|
||||
useProject.setState({ project: { name: "r", root: "/r", trusted: true, isGit: true, settings: {} } as never });
|
||||
openInput.mockClear();
|
||||
closeInput.mockClear();
|
||||
});
|
||||
|
||||
describe("all-in-one diff", () => {
|
||||
it("is off by default; on, a diff of a change with several files opens all of them", () => {
|
||||
expect(allInOneDiff()).toBe(false);
|
||||
expect(combinedOf(withChain(items, 1))).toBeNull();
|
||||
setAllInOneDiff(true);
|
||||
expect(combinedOf(withChain(items, 1))).toMatchObject({ reveal: "/r/src/b.ts" });
|
||||
expect(combinedOf(withChain(items, 1))!.items).toHaveLength(3);
|
||||
// One file, or a diff shown inside another view, stays as it is.
|
||||
expect(combinedOf(diff("/r/a"))).toBeNull();
|
||||
expect(combinedOf({ ...withChain(items, 0), embedded: true })).toBeNull();
|
||||
});
|
||||
|
||||
it("opens one tab per change, whichever of its files asked", async () => {
|
||||
setAllInOneDiff(true);
|
||||
await openDiff(withChain(items, 0));
|
||||
await openDiff({ ...withChain(items, 2), line: 4 });
|
||||
const [first, second] = openInput.mock.calls.map((c) => c[0]);
|
||||
expect(first!.kind).toBe(COMBINED_DIFF_KIND);
|
||||
expect(second!.key).toBe(first!.key);
|
||||
expect(second!.path).toBe("/r/c.md");
|
||||
// The blocks don't carry the chain or the reveal of the file that opened them.
|
||||
const blocks = (first!.data as { items: DiffData[] }).items;
|
||||
expect(blocks.every((b) => !b.chain && b.line === undefined)).toBe(true);
|
||||
});
|
||||
|
||||
it("keeps one diff per file while off", async () => {
|
||||
await openDiff(withChain(items, 0));
|
||||
expect(openInput.mock.calls[0]![0].kind).toBe("diff");
|
||||
});
|
||||
|
||||
it("tells added and deleted files from the absent side", () => {
|
||||
expect(blockKind(diff("/r/a", { left: { type: "text", text: "", label: "", absent: true } }))).toBe("added");
|
||||
expect(blockKind(diff("/r/a", { right: { type: "text", text: "", label: "", absent: true } }))).toBe("deleted");
|
||||
expect(blockKind(diff("/r/a"))).toBe("modified");
|
||||
});
|
||||
});
|
||||
|
||||
describe("the all-in-one diff tab", () => {
|
||||
const input = combinedDiffInput({ items });
|
||||
|
||||
it("shows a block per file, each diff fitted to its content", () => {
|
||||
render(<CombinedDiffTab input={input} />);
|
||||
expect(screen.getByText("3 files")).toBeTruthy();
|
||||
const blocks = screen.getAllByTestId("block-diff");
|
||||
expect(blocks.map((b) => b.dataset.path)).toEqual(["/r/src/a.ts", "/r/src/b.ts", "/r/c.md"]);
|
||||
expect(blocks.every((b) => b.dataset.fit === "true")).toBe(true);
|
||||
expect(screen.getAllByText("src")).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("collapses a file and all files", () => {
|
||||
render(<CombinedDiffTab input={input} />);
|
||||
act(() => {
|
||||
fireEvent.click(screen.getAllByRole("button", { name: "Collapse File" })[0]!);
|
||||
});
|
||||
expect(screen.getAllByTestId("block-diff")).toHaveLength(2);
|
||||
act(() => {
|
||||
fireEvent.click(screen.getByRole("button", { name: "Collapse All Files" }));
|
||||
});
|
||||
expect(screen.queryAllByTestId("block-diff")).toHaveLength(0);
|
||||
act(() => {
|
||||
fireEvent.click(screen.getByRole("button", { name: "Expand All Files" }));
|
||||
});
|
||||
expect(screen.getAllByTestId("block-diff")).toHaveLength(3);
|
||||
});
|
||||
|
||||
it("switches every block between side-by-side and unified", () => {
|
||||
render(<CombinedDiffTab input={input} />);
|
||||
act(() => {
|
||||
fireEvent.click(screen.getByRole("button", { name: "Unified Viewer" }));
|
||||
});
|
||||
expect(screen.getAllByTestId("block-diff").every((b) => b.dataset.mode === "unified")).toBe(true);
|
||||
});
|
||||
|
||||
it("opens a file's own diff, and goes back to one tab per file", async () => {
|
||||
setAllInOneDiff(true);
|
||||
render(<CombinedDiffTab input={input} />);
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getAllByRole("button", { name: "Open in Separate Tab" })[1]!);
|
||||
});
|
||||
const own = openInput.mock.calls[0]![0];
|
||||
expect(own).toMatchObject({ kind: "diff", path: "/r/src/b.ts" });
|
||||
expect((own.data as DiffData).chain).toHaveLength(3);
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByRole("button", { name: "Show Files in Separate Diff Tabs" }));
|
||||
});
|
||||
expect(allInOneDiff()).toBe(false);
|
||||
expect(openInput.mock.calls[1]![0].kind).toBe("diff");
|
||||
expect(closeInput).toHaveBeenCalledWith(input.key);
|
||||
});
|
||||
});
|
||||
@@ -1,174 +0,0 @@
|
||||
import { act, fireEvent, render, screen } from "@testing-library/react";
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import type { FileStatus } from "@/bindings";
|
||||
|
||||
vi.mock("@/platform/ipc", async (importOriginal) => {
|
||||
const real = await importOriginal<typeof import("@/platform/ipc")>();
|
||||
return { ...real, call: vi.fn(async () => null) };
|
||||
});
|
||||
|
||||
vi.mock("../DiffEditor", () => ({ DiffEditor: () => <div /> }));
|
||||
|
||||
import { call, commands } from "@/platform/ipc";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { useContextMenuStore, type MenuItem } from "@/ui/Menu";
|
||||
import { ChangesTree, nodeMenu, stageOperation } from "../CommitView";
|
||||
import { buildChangeTree, planCommit } from "../changes";
|
||||
import { useChangelists } from "../changelists";
|
||||
import { useCommit } from "../commitStore";
|
||||
import { inclusionChecks, isCommitAll, stagingChecks } from "../staging";
|
||||
import { useVcs } from "../store";
|
||||
|
||||
const file = (rel: string, staged: FileStatus["staged"], unstaged: FileStatus["unstaged"]): FileStatus => ({
|
||||
path: `/p/${rel}`,
|
||||
relPath: rel,
|
||||
staged,
|
||||
unstaged,
|
||||
renamedFrom: null,
|
||||
});
|
||||
|
||||
const stagedOnly = file("src/Staged.kt", "modified", null);
|
||||
const partial = file("src/Partial.kt", "modified", "modified");
|
||||
const unstagedOnly = file("src/Unstaged.kt", null, "modified");
|
||||
const untracked = file("src/New.kt", null, "untracked");
|
||||
|
||||
function useSettings(stagingArea: boolean, nonModal = true) {
|
||||
useProject.setState({
|
||||
project: { name: "p", root: "/p", trusted: true, isGit: true, settings: {} } as never,
|
||||
settings: { vcs: { git: { stagingArea }, commit: { nonModal } } } as never,
|
||||
});
|
||||
}
|
||||
|
||||
describe("staging area inclusion", () => {
|
||||
it("commits what is staged, the staged part of a partially staged file, and nothing else", () => {
|
||||
const status = [stagedOnly, partial, unstagedOnly, untracked];
|
||||
expect(isCommitAll(status)).toBe(false);
|
||||
const plan = planCommit(status, stagingChecks(status));
|
||||
expect(plan.included.map((f) => f.relPath)).toEqual(["src/Staged.kt", "src/Partial.kt"]);
|
||||
// Nothing is added to the index, and nothing staged is left out.
|
||||
expect(plan.stage).toEqual([]);
|
||||
expect(plan.exclude).toEqual([]);
|
||||
expect(plan.partial).toEqual([]);
|
||||
});
|
||||
|
||||
it("with nothing staged, Commit All takes every tracked change but not unversioned files", () => {
|
||||
const status = [unstagedOnly, file("src/Gone.kt", null, "deleted"), untracked];
|
||||
expect(isCommitAll(status)).toBe(true);
|
||||
const plan = planCommit(status, stagingChecks(status));
|
||||
expect(plan.included.map((f) => f.relPath)).toEqual(["src/Unstaged.kt", "src/Gone.kt"]);
|
||||
expect(plan.stage).toEqual(["/p/src/Unstaged.kt", "/p/src/Gone.kt"]);
|
||||
});
|
||||
|
||||
it("is not Commit All when only unversioned files changed", () => {
|
||||
expect(isCommitAll([untracked])).toBe(false);
|
||||
});
|
||||
|
||||
it("ignores the checkboxes and change lists", () => {
|
||||
const status = [stagedOnly, unstagedOnly];
|
||||
const lists = {
|
||||
active: "a",
|
||||
lists: [
|
||||
{ id: "a", name: "A" },
|
||||
{ id: "b", name: "B" },
|
||||
],
|
||||
files: { "src/Staged.kt": "b" },
|
||||
};
|
||||
const checks = new Map([[unstagedOnly.path, "all" as const]]);
|
||||
const staging = planCommit(status, inclusionChecks(status, "/p", lists as never, checks, true));
|
||||
expect(staging.included.map((f) => f.relPath)).toEqual(["src/Staged.kt"]);
|
||||
const lists_ = planCommit(status, inclusionChecks(status, "/p", lists as never, checks, false));
|
||||
expect(lists_.included.map((f) => f.relPath)).toEqual(["src/Unstaged.kt"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("staging operations of the tree's nodes", () => {
|
||||
const roots = buildChangeTree([stagedOnly, partial, unstagedOnly, untracked], "/p", false, undefined, [], true);
|
||||
const group = (id: string) => roots.find((n) => n.group === id)!;
|
||||
|
||||
it("unstages under Staged and stages under Unstaged and Unversioned Files", () => {
|
||||
const op = (id: string) => {
|
||||
const o = stageOperation(group(id))!;
|
||||
return [o.label, [...o.paths].sort()];
|
||||
};
|
||||
expect(op("staged")).toEqual(["Unstage", ["/p/src/Partial.kt", "/p/src/Staged.kt"]]);
|
||||
expect(op("unstaged")).toEqual(["Stage", ["/p/src/Partial.kt", "/p/src/Unstaged.kt"]]);
|
||||
expect(op("unversioned")).toEqual(["Stage", ["/p/src/New.kt"]]);
|
||||
});
|
||||
|
||||
it("offers only Unstage for a partially staged file under Staged, only Stage under Unstaged", () => {
|
||||
const enabled = (items: MenuItem[], label: string) =>
|
||||
!(items.find((i) => "label" in i && i.label === label) as { disabled?: boolean }).disabled;
|
||||
const underStaged = group("staged").children!.find((n) => n.label === "Partial.kt")!;
|
||||
const underUnstaged = group("unstaged").children!.find((n) => n.label === "Partial.kt")!;
|
||||
expect([enabled(nodeMenu([underStaged], []), "Stage"), enabled(nodeMenu([underStaged], []), "Unstage")]).toEqual([
|
||||
false,
|
||||
true,
|
||||
]);
|
||||
expect([
|
||||
enabled(nodeMenu([underUnstaged], []), "Stage"),
|
||||
enabled(nodeMenu([underUnstaged], []), "Unstage"),
|
||||
]).toEqual([true, false]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("the Commit tool window with the staging area", () => {
|
||||
beforeEach(() => {
|
||||
localStorage.clear();
|
||||
vi.mocked(call).mockClear();
|
||||
useCommit.setState({
|
||||
groupByDir: false,
|
||||
groupByStaging: false,
|
||||
groupByRepo: true,
|
||||
checks: new Map(),
|
||||
selection: [],
|
||||
});
|
||||
useChangelists.setState({
|
||||
state: {
|
||||
active: "a",
|
||||
lists: [
|
||||
{ id: "a", name: "Changes" },
|
||||
{ id: "b", name: "Feature" },
|
||||
],
|
||||
files: {},
|
||||
} as never,
|
||||
});
|
||||
useVcs.setState({ root: "/p", repo: "/p", roots: ["/p"], status: [stagedOnly, unstagedOnly], heads: {} });
|
||||
});
|
||||
|
||||
it("groups by staging state without change lists or checkboxes", () => {
|
||||
useSettings(true);
|
||||
render(<ChangesTree mode="commit" />);
|
||||
expect(screen.getByText("Staged Changes")).toBeTruthy();
|
||||
expect(screen.getByText("Unstaged Changes")).toBeTruthy();
|
||||
expect(screen.queryByText("Feature")).toBeNull();
|
||||
expect(screen.queryAllByRole("checkbox")).toHaveLength(0);
|
||||
act(() => {
|
||||
fireEvent.click(screen.getByRole("button", { name: "View Options" }));
|
||||
});
|
||||
const labels = useContextMenuStore.getState().menu!.items.map((i) => ("label" in i ? i.label : null));
|
||||
act(() => useContextMenuStore.setState({ menu: null }));
|
||||
expect(labels).not.toContain("Staging State");
|
||||
});
|
||||
|
||||
it("stages a file from its row's button", async () => {
|
||||
useSettings(true);
|
||||
const stageCommand = vi.spyOn(commands, "vcsStage").mockResolvedValue({ status: "ok", data: null });
|
||||
render(<ChangesTree mode="commit" />);
|
||||
const stage = screen.getAllByRole("button", { name: "Stage" });
|
||||
await act(async () => {
|
||||
fireEvent.click(stage[stage.length - 1]!);
|
||||
});
|
||||
expect(stageCommand).toHaveBeenCalledWith(["/p/src/Unstaged.kt"]);
|
||||
});
|
||||
|
||||
it("keeps change lists and checkboxes when off, or under the modal commit interface", () => {
|
||||
useSettings(true, false);
|
||||
const { unmount } = render(<ChangesTree mode="commit" />);
|
||||
expect(screen.getByText("Feature")).toBeTruthy();
|
||||
expect(screen.queryAllByRole("checkbox").length).toBeGreaterThan(0);
|
||||
unmount();
|
||||
useSettings(false);
|
||||
render(<ChangesTree mode="commit" />);
|
||||
expect(screen.queryByText("Staged Changes")).toBeNull();
|
||||
});
|
||||
});
|
||||
Loaded 100 of 126 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача