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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 55a19bbbe1 feat(build): read Eclipse projects without a build tool
An Eclipse project's .classpath now gives its roots: source folders
(tests by their test attribute) and the output folder, excluded. Maven
and Gradle builds keep owning the model when present.

Builds of such a project use the .classpath libraries, and the web content
folder (the wb-resource deployed at / in
.settings/org.eclipse.wst.common.component, or a WebContent / WebRoot /
web / src/main/webapp folder holding WEB-INF/web.xml) acts as the Web facet
when none is configured. A web project with no artifacts gets
<name>:war exploded, which Build Artifacts lays out and Tomcat deploys.

Part of #3571
2026-11-16 10:02:02 +08:00
l0ng-ai efa4fb3b43 feat(build): Build Artifacts and Tomcat deployment for projects without a build tool (#3629)
Build Artifacts on a Java project without Maven or Gradle compiles the production classes with javac and lays out each Project Structure artifact: exploded WAR (web root, WEB-INF/classes, WEB-INF/lib), WAR packed from it, or JAR with a manifest (Main-Class, Class-Path) and its libraries next to it. Layouts are rebuilt from scratch and refuse an output folder holding their inputs. The WAR artifacts are offered to Tomcat run configurations; Build before launch packs the WAR in the IDE and records it for deployment.

Part of #3571, closes #2875
2026-11-16 09:54:52 +08:00
l0ng-ai 6df0087038 feat(build): build Java projects without a build tool from their Project Structure (#3627)
Build Project / Rebuild Project on a Java project without Maven or Gradle now compiles with javac from the Project Structure: source roots to <compiler output>/production/<module> (out by default) against the project libraries, module library dependencies and the Web facet's WEB-INF/lib; resources copied next to the classes; tests to the test output with the production classes. JDK: module or project SDK, else an installed JDK for the language level (--release from JDK 9, -source/-target before). Rebuild cleans first. BuildStep can carry in-IDE actions (clean, copy resources); BuildSystem gains javac.

Part of #3571
2026-11-16 09:47:30 +08:00
l0ng-ai bedd9d2fc9 feat(appearance): scopes and file colors for the project view and editor tabs (#3624)
Settings › Appearance & Behavior gets Scopes (named file sets as file:pattern expressions with ||, && and !, optionally limited to a module) and File Colors (a background colour per scope, first match wins, in the project view and on editor tabs; on by default with Tests green and Non-Project Files yellow). The project view's context menu gets File Color for a file or folder, kept as a scope of that path first in the project's File Colors, with Clear File Color.

Closes #3183
2026-11-16 09:36:14 +08:00
Vadim LazukтаInf1mum 696abb08d8 feat(whats-new): show the release notes in the UI language when the update manifest has them (#3567)
The update manifest can carry translated notes as notes.<lang> (for example notes.zh-CN). app_release_notes returns every language it finds, keyed by base language code. What's New shows the UI language's notes and falls back to English. Notes recorded at install stay English and are replaced by the manifest's translation when one exists.

Refs #3525

Co-authored-by: Inf1mum <[email protected]>
2026-11-16 09:34:42 +08:00
l0ng-ai f99ae11c01 feat(release): Chinese update notes from a 中文 section of the release (#3622)
The update manifest's notes come from the release body. A "## 中文" section added at the end of the draft before publishing is now published as notes.zh-CN, and the English notes leave it out. HTML comments, such as the generated-notes marker, are dropped from both.

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

Refs #3390

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

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

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

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

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

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

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

Closes #3585

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

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

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

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

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

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

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

Part of #3542.

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

No files matched your search

+7 -3
Переглянути файл
@@ -208,11 +208,15 @@ jobs:
- run: pnpm build
e2e:
name: E2E
name: E2E (${{ matrix.shard }}/2)
needs: changes
if: needs.changes.outputs.frontend == 'true'
timeout-minutes: 30
runs-on: ubuntu-24.04
strategy:
fail-fast: false
matrix:
shard: [1, 2]
# Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
container: mcr.microsoft.com/playwright:v1.64.1-noble
steps:
@@ -222,12 +226,12 @@ jobs:
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm e2e
- run: pnpm e2e --shard=${{ matrix.shard }}/2
env:
HOME: /root
- uses: actions/upload-artifact@v6
if: failure()
with:
name: playwright-report
name: playwright-report-${{ matrix.shard }}
path: playwright-report/
retention-days: 7
+29 -9
Переглянути файл
@@ -262,26 +262,46 @@ jobs:
}
// The update's notes: the release body without its Download section. That
// section only matters on the release page, and What's new follows it.
// A translated section, "## 中文" added at the end of the draft before it is
// published (it runs to the next heading of its level, or the end), becomes
// `notes.zh-CN`: What's new shows it in that UI language and falls back to
// `notes`, the English rest of the body. HTML comments are dropped.
const { data: release } = await github.rest.repos.getRelease({ owner, repo, release_id });
const withoutDownloadSection = (body) => {
const kept = [];
const languages = { "中文": "zh-CN" };
const notesByLanguage = (body) => {
const parts = { "": [] };
let lang = "";
let langLevel = 0;
let skip = 0;
for (const line of body.split(/\r?\n/)) {
for (const line of body.replace(/<!--[\s\S]*?-->/g, "").split(/\r?\n/)) {
const heading = /^(#{1,6})\s+(.*)$/.exec(line);
if (heading) {
const level = heading[1].length;
if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
const title = heading[2].trim();
if (skip && level <= skip) skip = 0;
if (lang && level <= langLevel) lang = "";
if (!skip && level <= 3 && /^download$/i.test(title)) {
skip = level;
continue;
}
if (skip && level <= skip) skip = 0;
if (!skip && !lang && level <= 2 && languages[title]) {
lang = languages[title];
langLevel = level;
parts[lang] ??= [];
continue;
}
}
if (!skip) kept.push(line);
if (!skip) parts[lang].push(line);
}
return kept.join("\n").trim();
return Object.fromEntries(Object.entries(parts).map(([key, lines]) => [key, lines.join("\n").trim()]));
};
const { "": notes, ...translated } = notesByLanguage(String(release.body ?? ""));
const translations = Object.fromEntries(
Object.entries(translated).filter(([, text]) => text).map(([lang, text]) => [`notes.${lang}`, text]),
);
const manifest = {
version: tag.replace(/^v/, ""), notes, ...translations, pub_date: new Date().toISOString(), platforms,
};
const notes = withoutDownloadSection(String(release.body ?? ""));
const manifest = { version: tag.replace(/^v/, ""), notes, pub_date: new Date().toISOString(), platforms };
const old = assets.find((a) => a.name === "latest.json");
if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
await github.rest.repos.uploadReleaseAsset({
+7 -2
Переглянути файл
@@ -1204,7 +1204,10 @@ impl AgentManager {
}
/// What `provider` reports about itself, from `initialize` alone: no session is opened,
/// so no MCP server, hook or sign-in runs. Remembered until `refresh`.
/// so no MCP server, hook or sign-in runs. A successful answer is remembered until
/// `refresh`; a failed one is not, so a transient startup failure (a CLI updating itself,
/// a busy machine) is retried on the next call instead of being shown for the rest of
/// the session.
pub async fn probe(&self, provider: &str, refresh: bool) -> IdeResult<AgentProbe> {
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
return Ok(p.clone());
@@ -1266,7 +1269,9 @@ impl AgentManager {
}
Err(e) => probe.error = Some(e),
}
self.shared.probes.lock().insert(spec.id, probe.clone());
if probe.error.is_none() {
self.shared.probes.lock().insert(spec.id, probe.clone());
}
Ok(probe)
}
+34
Переглянути файл
@@ -2474,6 +2474,40 @@ async fn reload_providers_updates_registry_install_clears_stale_probes_and_notif
assert!(probe.error.is_none());
}
/// A probe that fails is not remembered, so the next new-task page tries the agent again
/// instead of showing the same startup failure until the IDE restarts.
#[tokio::test(flavor = "multi_thread")]
async fn a_failed_probe_is_retried_instead_of_remembered() {
let tmp = tempfile::tempdir().unwrap();
let calls = Arc::new(Mutex::new(0usize));
let connector: Connector = {
let calls = calls.clone();
Arc::new(move |_spec, _cwd, _client, _stderr| {
*calls.lock() += 1;
Err(std::io::Error::from(std::io::ErrorKind::NotFound))
})
};
let mgr = AgentManager::with_connector(
AgentPaths {
project_root: tmp.path().to_path_buf(),
store_dir: tmp.path().join("store"),
worktrees_dir: tmp.path().join("worktrees"),
models_file: tmp.path().join("models.json"),
custom_agents_dir: None,
home_dir: None,
env_secrets: None,
catalogs: Arc::default(),
},
tokio::runtime::Handle::current(),
connector,
);
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
assert_eq!(*calls.lock(), 2, "the second call must start the agent again");
assert!(!mgr.shared.probes.lock().contains_key("claude"));
}
/// A session report that changes the cached provider config notifies subscribers,
/// so the composer re-lists models without waiting for the next task (#1490).
/// Reports that change nothing stay silent.
+54 -1
Переглянути файл
@@ -7,6 +7,7 @@ mod fingerprint;
mod launch_resources;
mod parse;
mod single;
mod structure;
mod up_to_date;
pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
@@ -15,6 +16,10 @@ pub use single::{
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
single_file_target,
};
pub use structure::{
StructureJdk, StructureRoots, artifact_file, artifact_output, language_release, structure_outputs, structure_plan,
structure_war_plan, structure_web_artifacts,
};
pub use up_to_date::{menu_up_to_date, record_menu_build};
use crate::process::{self, Stream};
@@ -55,6 +60,8 @@ pub enum BuildSystem {
CMake,
#[serde(rename = "dotnet")]
Dotnet,
/// A Java project without a build tool, compiled from its Project Structure.
Javac,
}
/// One command of a build.
@@ -65,6 +72,10 @@ pub struct BuildStep {
pub cwd: PathBuf,
pub env: BTreeMap<String, String>,
format: Format,
/// Folders created before the command runs (a compiler's output).
mkdirs: Vec<PathBuf>,
/// Work done in the IDE instead of a command, with its console title.
action: Option<(structure::Action, String)>,
}
impl BuildStep {
@@ -75,16 +86,26 @@ impl BuildStep {
cwd: cwd.to_path_buf(),
env: BTreeMap::new(),
format,
mkdirs: Vec::new(),
action: None,
}
}
fn action(action: structure::Action, root: &Path) -> Self {
let title = action.display(root);
BuildStep { action: Some((action, title)), ..Self::new("", &[], root, Format::Gradle) }
}
/// A CMake configure/build invocation, parsed as compiler output in the Build view.
pub fn cmake(program: &str, args: Vec<String>, cwd: PathBuf, env: BTreeMap<String, String>) -> Self {
Self { program: program.into(), args, cwd, env, format: Format::Gcc }
Self { program: program.into(), args, cwd, env, format: Format::Gcc, mkdirs: Vec::new(), action: None }
}
/// The command line as echoed in the console.
pub fn display(&self) -> String {
if let Some((_, title)) = &self.action {
return title.clone();
}
let program = Path::new(&self.program).file_name().map_or(self.program.clone(), |n| n.to_string_lossy().into());
std::iter::once(program)
.chain(self.args.iter().map(|a| if a.contains(' ') { format!("\"{a}\"") } else { a.clone() }))
@@ -249,6 +270,8 @@ pub fn plan(
BuildSystem::TypeScript => ts_steps(&dir, kind),
BuildSystem::CMake => cmake_steps(&dir, kind, cmake.and_then(<[_]>::first)),
BuildSystem::Dotnet => dotnet_steps(&dir, kind)?,
// Never detected from a folder: it comes from the Project Structure (`structure_plan`).
BuildSystem::Javac => return Err(IdeError::invalid("no build tool to run")),
};
Ok(BuildPlan { system, title, steps })
}
@@ -650,6 +673,36 @@ pub fn run(
let command = step.display();
on_event(BuildEvent::Step { command: command.clone(), cwd: step.cwd.clone().into() });
on_event(BuildEvent::Progress { message: command.clone(), fraction: None });
if let Some((action, _)) = &step.action {
match action.run(cancel) {
Ok(text) => {
if !text.is_empty() {
on_event(BuildEvent::Output { text: format!("{text}\n"), stderr: false });
}
continue;
}
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => return Err(e),
Err(e) => {
let m = BuildMessage {
severity: Severity::Error,
text: e.message.clone(),
path: None,
range: None,
code: None,
};
on_event(BuildEvent::Output { text: format!("{}\n", e.message), stderr: true });
on_event(BuildEvent::Message { message: m.clone() });
messages.push(m);
success = false;
break;
}
}
}
for dir in &step.mkdirs {
if let Err(e) = std::fs::create_dir_all(dir) {
tracing::debug!(dir = %dir.display(), %e, "cannot create the build output folder");
}
}
let mut parser = OutputParser::new(step.format);
let mut emit = |raws: Vec<RawMessage>, messages: &mut Vec<BuildMessage>| {
for raw in raws {
+817
Переглянути файл
@@ -0,0 +1,817 @@
//! A Java project without a build tool, built from its Project Structure: `javac` compiles
//! the source roots to the module's output folder against the project libraries and the
//! Web facet's `WEB-INF/lib`, and the resources are copied next to the classes; tests the
//! same way into the test output, which also sees the production classes.
use super::*;
use ide_core::settings::{
ArtifactConfig, ArtifactKind, DependencyScope, ModuleStructureSettings, ProjectStructureSettings,
};
use std::fs;
/// The roots of the project as the IDE resolved them (absolute folders).
#[derive(Clone, Debug, Default)]
pub struct StructureRoots {
pub sources: Vec<PathBuf>,
pub tests: Vec<PathBuf>,
pub resources: Vec<PathBuf>,
pub test_resources: Vec<PathBuf>,
pub excluded: Vec<PathBuf>,
}
/// The JDK compiling the project.
#[derive(Clone, Debug)]
pub struct StructureJdk {
pub home: PathBuf,
pub major: u32,
}
/// Where the project's classes go: `<compiler output>/production/<module>` and
/// `<compiler output>/test/<module>` (`out` by default), unless the module names its own.
pub fn structure_outputs(root: &Path, ps: &ProjectStructureSettings) -> (PathBuf, PathBuf) {
let module = root_module(root, ps);
let name = module_name(root);
let base = resolve_dir(root, &ps.compiler_output).unwrap_or_else(|| root.join("out"));
let main = module
.and_then(|m| resolve_dir(root, &m.compiler_output))
.unwrap_or_else(|| base.join("production").join(&name));
let test = module
.and_then(|m| resolve_dir(root, &m.test_compiler_output))
.unwrap_or_else(|| base.join("test").join(&name));
(main, test)
}
fn module_name(root: &Path) -> String {
root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned())
}
fn root_module<'a>(root: &Path, ps: &'a ProjectStructureSettings) -> Option<&'a ModuleStructureSettings> {
ps.modules.get(".").or_else(|| ps.module_settings(root, root))
}
fn resolve_dir(root: &Path, value: &str) -> Option<PathBuf> {
let value = value.trim();
(!value.is_empty()).then(|| root.join(value))
}
/// `.java` files below `dir`, not inside an excluded folder or another root of `skip`.
fn java_files(dir: &Path, excluded: &[PathBuf], out: &mut Vec<PathBuf>) {
let Ok(entries) = fs::read_dir(dir) else { return };
let mut entries: Vec<_> = entries.flatten().collect();
entries.sort_by_key(|e| e.file_name());
for e in entries {
let path = e.path();
match e.file_type() {
Ok(t) if t.is_dir() => {
if !excluded.iter().any(|x| path.starts_with(x)) {
java_files(&path, excluded, out);
}
}
Ok(t) if t.is_file() && path.extension().is_some_and(|x| x == "java") => out.push(path),
_ => {}
}
}
}
/// Folders and archives of the libraries a module compiles against, for `scope`.
fn library_entries(root: &Path, ps: &ProjectStructureSettings, test: bool) -> Vec<String> {
let wanted = |scope: DependencyScope| match scope {
DependencyScope::Compile | DependencyScope::Provided => true,
DependencyScope::Test => test,
DependencyScope::Runtime => false,
};
let mut out: Vec<String> = Vec::new();
let mut add = |entry: String| {
if !out.contains(&entry) {
out.push(entry);
}
};
let module_deps = root_module(root, ps).map(|m| m.dependencies.as_slice()).unwrap_or_default();
for lib in &ps.libraries {
// A library a module dependency names takes that dependency's scope.
let scope =
module_deps.iter().find(|d| d.kind == "library" && d.target == lib.name).map_or(lib.scope, |d| d.scope);
if wanted(scope) {
for class in &lib.classes {
add(class_entry(root, class));
}
}
}
for dep in module_deps.iter().filter(|d| d.kind == "library" && wanted(d.scope)) {
if !ps.libraries.iter().any(|l| l.name == dep.target) && !dep.target.trim().is_empty() {
add(class_entry(root, &dep.target));
}
}
for facet in ps.facets.iter().filter(|f| f.kind == "web") {
let lib = web_root(root, facet).join("WEB-INF").join("lib");
if lib.is_dir() {
add(format!("{}{}*", lib.to_string_lossy(), std::path::MAIN_SEPARATOR));
}
}
out
}
/// The web resource folder of a Web facet: its own, else the folder holding `WEB-INF/web.xml`.
fn web_root(root: &Path, facet: &ide_core::settings::FacetConfig) -> PathBuf {
let dir = facet.web_root.trim();
let dir = if dir.is_empty() {
facet.descriptor.trim().replace('\\', "/").strip_suffix("/WEB-INF/web.xml").unwrap_or("").to_owned()
} else {
dir.to_owned()
};
root.join(dir)
}
/// The class archives and folders of a library path (`lib/*.jar` lists the folder's jars).
fn library_files(root: &Path, value: &str) -> Vec<PathBuf> {
let entry = class_entry(root, value);
match entry.strip_suffix('*') {
Some(dir) => {
let mut jars: Vec<PathBuf> = fs::read_dir(dir)
.map(|d| d.flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "jar")).collect())
.unwrap_or_default();
jars.sort();
jars
}
None => vec![PathBuf::from(entry)],
}
}
/// A classpath entry for a library path: a folder of jars (`lib/*`) stays a wildcard javac expands.
fn class_entry(root: &Path, value: &str) -> String {
let path = root.join(value.trim());
let text = path.to_string_lossy().into_owned();
if text.ends_with("/*.jar") || text.ends_with("\\*.jar") {
return text[..text.len() - 4].to_owned();
}
text
}
fn classpath(entries: &[String]) -> String {
entries.join(if cfg!(windows) { ";" } else { ":" })
}
/// `--release N` from JDK 9 on; older compilers only know `-source` / `-target`.
fn release_args(level: Option<u32>, jdk: Option<&StructureJdk>) -> Vec<String> {
let Some(level) = level else { return Vec::new() };
if jdk.is_none_or(|j| j.major >= 9) {
vec!["--release".into(), level.to_string()]
} else {
vec!["-source".into(), format!("1.{level}"), "-target".into(), format!("1.{level}")]
}
}
/// `"17"`, `"1.8"`, `"JDK_17"` → the release number.
pub fn language_release(level: &str) -> Option<u32> {
let digits = level.trim().trim_start_matches("JDK_").trim_start_matches("jdk").replace('_', ".");
let digits = digits.strip_prefix("1.").unwrap_or(&digits);
digits.split(['.', ' ']).next()?.parse().ok().filter(|n| *n > 0)
}
/// The Build / Rebuild plan of a project without a build tool, or `None` when it has no
/// Java sources under its source roots. `language_level`: the project's, unless the module
/// overrides it. Writes the javac argument files below `cache`.
pub fn structure_plan(
root: &Path,
ps: &ProjectStructureSettings,
roots: &StructureRoots,
jdk: Option<&StructureJdk>,
language_level: &str,
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<BuildPlan>> {
let mut main_sources = Vec::new();
for dir in &roots.sources {
java_files(dir, &roots.excluded, &mut main_sources);
}
let mut test_sources = Vec::new();
for dir in &roots.tests {
java_files(dir, &roots.excluded, &mut test_sources);
}
if main_sources.is_empty() && test_sources.is_empty() {
return Ok(None);
}
let (main_out, test_out) = structure_outputs(root, ps);
let module = root_module(root, ps);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
.or(Some(language_level))
.and_then(language_release);
let env: BTreeMap<String, String> = jdk
.map(|j| BTreeMap::from([("JAVA_HOME".to_owned(), j.home.to_string_lossy().into_owned())]))
.unwrap_or_default();
let javac = find_javac(&env);
let args_dir = cache.join("javac");
fs::create_dir_all(&args_dir)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", args_dir.display())))?;
let mut steps = Vec::new();
if kind == BuildKind::Rebuild {
steps.push(BuildStep::action(Action::Clean(vec![main_out.clone(), test_out.clone()]), root));
}
let main_cp = library_entries(root, ps, false);
let compile = |name: &str, sources: &[PathBuf], out: &Path, cp: &[String]| -> IdeResult<BuildStep> {
let args_file = args_dir.join(format!("{name}.args"));
// One quoted path per line: the sources outgrow a command line quickly.
let text: String = sources
.iter()
.map(|p| format!("\"{}\"\n", p.to_string_lossy().replace('\\', "\\\\").replace('"', "\\\"")))
.collect();
fs::write(&args_file, text)
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", args_file.display())))?;
let mut step = BuildStep::new(&javac, &[], root, Format::Gradle);
step.args.extend(["-encoding".into(), "UTF-8".into(), "-g".into()]);
step.args.extend(["-d".into(), out.to_string_lossy().into_owned()]);
if !cp.is_empty() {
step.args.extend(["-cp".into(), classpath(cp)]);
}
step.args.extend(release_args(level, jdk));
step.args.push(format!("@{}", args_file.to_string_lossy()));
step.env = env.clone();
step.mkdirs = vec![out.to_path_buf()];
Ok(step)
};
if !main_sources.is_empty() {
steps.push(compile("production", &main_sources, &main_out, &main_cp)?);
}
steps.push(BuildStep::action(
Action::CopyResources {
from: roots.sources.iter().chain(&roots.resources).cloned().collect(),
to: main_out.clone(),
},
root,
));
// Artifacts hold production classes only.
if !test_sources.is_empty() && kind != BuildKind::Artifacts {
let mut test_cp = vec![main_out.to_string_lossy().into_owned()];
test_cp.extend(library_entries(root, ps, true));
steps.push(compile("test", &test_sources, &test_out, &test_cp)?);
steps.push(BuildStep::action(
Action::CopyResources {
from: roots.tests.iter().chain(&roots.test_resources).cloned().collect(),
to: test_out.clone(),
},
root,
));
}
if kind == BuildKind::Artifacts {
if ps.artifacts.is_empty() {
return Err(IdeError::invalid("No artifacts are configured: add one in Project Structure › Artifacts"));
}
for artifact in &ps.artifacts {
steps.extend(artifact_steps(root, ps, artifact, &main_out, None, cache));
}
}
Ok(Some(BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps }))
}
/// Where an artifact goes: its output folder, else `out/artifacts/<name>`.
pub fn artifact_output(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
resolve_dir(root, &artifact.output_directory)
.unwrap_or_else(|| root.join("out").join("artifacts").join(file_name(&artifact.name)))
}
/// An artifact name as a file name (`shop:war exploded` → `shop_war_exploded`).
fn file_name(name: &str) -> String {
name.chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '.' { c } else { '_' }).collect()
}
/// The archive a `jar` / `war` artifact writes (`<output>/<name>.war`), or its folder (exploded).
pub fn artifact_file(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
let out = artifact_output(root, artifact);
let base = artifact.name.split(':').next().filter(|n| !n.trim().is_empty()).unwrap_or(&artifact.name);
match artifact.kind {
ArtifactKind::Jar => out.join(format!("{}.jar", file_name(base))),
ArtifactKind::War => out.join(format!("{}.war", file_name(base))),
ArtifactKind::WarExploded => out,
}
}
/// The steps laying out one artifact from the module output `classes`; `war`: write a
/// WAR there instead of the artifact's own output (an application server's deployment).
fn artifact_steps(
root: &Path,
ps: &ProjectStructureSettings,
artifact: &ArtifactConfig,
classes: &Path,
war: Option<&Path>,
cache: &Path,
) -> Vec<BuildStep> {
let libraries: Vec<PathBuf> = ps
.libraries
.iter()
.filter(|l| artifact.include_libraries.contains(&l.name))
.flat_map(|l| l.classes.iter().flat_map(|c| library_files(root, c)))
.collect();
let facet = ps
.facets
.iter()
.filter(|f| f.kind == "web")
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
let staging = cache.join("artifacts").join(file_name(&artifact.name));
let mut steps = Vec::new();
match (artifact.kind, war) {
(ArtifactKind::Jar, None) => {
let out = artifact_output(root, artifact);
let mut manifest = String::from("Manifest-Version: 1.0\r\n");
if !artifact.main_class.trim().is_empty() {
manifest.push_str(&format!("Main-Class: {}\r\n", artifact.main_class.trim()));
}
let names: Vec<String> =
libraries.iter().filter_map(|l| l.file_name()).map(|n| n.to_string_lossy().into_owned()).collect();
if !names.is_empty() {
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
}
steps.push(BuildStep::action(
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
root,
));
// The jar's Class-Path names the libraries next to it.
steps.push(BuildStep::action(
Action::Layout {
into: out.clone(),
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
},
root,
));
steps.push(BuildStep::action(
Action::Archive { from: staging, to: artifact_file(root, artifact), manifest: Some(manifest) },
root,
));
}
(kind, war) => {
let exploded = match (kind, war) {
(ArtifactKind::WarExploded, None) => artifact_output(root, artifact),
_ => staging.clone(),
};
let mut entries = Vec::new();
if let Some(facet) = facet {
entries.push((web_root(root, facet), PathBuf::new()));
}
entries.push((classes.to_path_buf(), PathBuf::from("WEB-INF/classes")));
for lib in &libraries {
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
}
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
let archive = war
.map(Path::to_path_buf)
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
if let Some(to) = archive {
steps.push(BuildStep::action(Action::Archive { from: exploded, to, manifest: None }, root));
}
}
}
steps
}
fn file_of(path: &Path) -> PathBuf {
path.file_name().map(PathBuf::from).unwrap_or_default()
}
/// The WAR artifacts of a project without a build tool: an application server deploys them.
pub fn structure_web_artifacts(ps: &ProjectStructureSettings) -> Vec<&ArtifactConfig> {
ps.artifacts.iter().filter(|a| matches!(a.kind, ArtifactKind::War | ArtifactKind::WarExploded)).collect()
}
/// A build of `artifact` into the WAR `war` (Tomcat's deployment), compiling first.
#[allow(clippy::too_many_arguments)]
pub fn structure_war_plan(
root: &Path,
ps: &ProjectStructureSettings,
roots: &StructureRoots,
jdk: Option<&StructureJdk>,
language_level: &str,
artifact: &ArtifactConfig,
war: &Path,
cache: &Path,
) -> IdeResult<BuildPlan> {
let mut plan = structure_plan(root, ps, roots, jdk, language_level, BuildKind::Build, cache)?
.unwrap_or_else(|| BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps: Vec::new() });
let (main_out, _) = structure_outputs(root, ps);
// Tests are not part of a deployment.
plan.steps.retain(|s| !s.args.iter().any(|a| a.ends_with("test.args")));
plan.steps
.retain(|s| !matches!(&s.action, Some((Action::CopyResources { to, .. }, _)) if !to.starts_with(&main_out)));
plan.steps.extend(artifact_steps(root, ps, artifact, &main_out, Some(war), cache));
plan.title = artifact.name.clone();
Ok(plan)
}
/// Work a build does in the IDE itself rather than through a tool.
#[derive(Clone, Debug, PartialEq)]
pub(crate) enum Action {
/// Deletes these output folders (Rebuild).
Clean(Vec<PathBuf>),
/// Copies the files of these folders that are not Java sources into `to`, keeping their
/// relative paths; files that are already up to date are left alone.
CopyResources { from: Vec<PathBuf>, to: PathBuf },
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
/// place (`""` = the top). What is no longer laid out is removed.
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
/// Zips the folder `from` into the archive `to`, with this manifest first.
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
}
impl Action {
pub(crate) fn display(&self, root: &Path) -> String {
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().into_owned();
match self {
Action::Clean(dirs) => format!("Clean {}", dirs.iter().map(|d| rel(d)).collect::<Vec<_>>().join(", ")),
Action::CopyResources { to, .. } => format!("Copy resources to {}", rel(to)),
Action::Layout { into, .. } => format!("Lay out {}", rel(into)),
Action::Archive { to, .. } => format!("Pack {}", rel(to)),
}
}
/// Runs the action; the text is a summary for the console.
pub(crate) fn run(&self, cancel: &CancellationToken) -> IdeResult<String> {
match self {
Action::Clean(dirs) => {
for dir in dirs.iter().filter(|d| d.exists()) {
fs::remove_dir_all(dir)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", dir.display())))?;
}
Ok(String::new())
}
Action::CopyResources { from, to } => {
let mut copied = 0;
for dir in from {
copied += copy_resources(dir, dir, to, cancel)?;
}
Ok(format!("{copied} resource file(s) copied"))
}
Action::Layout { into, entries } => {
// A fresh layout: files dropped from the sources must not linger in the artifact.
if entries.iter().any(|(from, _)| from.starts_with(into)) {
return Err(IdeError::invalid(format!(
"The artifact output folder {} holds files the artifact is made of",
into.display()
)));
}
if into.exists() {
fs::remove_dir_all(into)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
}
let mut copied = 0;
for (from, to) in entries {
let target = into.join(to);
if from.is_dir() {
copied += copy_tree(from, &target, cancel)?;
} else if from.is_file() {
copy_file(from, &target)?;
copied += 1;
}
}
Ok(format!("{copied} file(s) laid out"))
}
Action::Archive { from, to, manifest } => {
archive(from, to, manifest.as_deref(), cancel)?;
Ok(format!("Wrote {}", to.display()))
}
}
}
}
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
if let Some(parent) = to.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::copy(from, to).map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", from.display())))?;
Ok(())
}
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
let mut copied = 0;
for e in entries.flatten() {
let Ok(t) = e.file_type() else { continue };
let target = to.join(e.file_name());
if t.is_dir() {
copied += copy_tree(&e.path(), &target, cancel)?;
} else if t.is_file() {
copy_file(&e.path(), &target)?;
copied += 1;
}
}
Ok(copied)
}
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
use std::io::Write;
let err = |e: &dyn std::fmt::Display| IdeError::internal(format!("cannot write {} ({e})", to.display()));
if let Some(parent) = to.parent() {
fs::create_dir_all(parent).map_err(|e| err(&e))?;
}
let mut zip = zip::ZipWriter::new(fs::File::create(to).map_err(|e| err(&e))?);
let options = zip::write::SimpleFileOptions::default();
if let Some(manifest) = manifest {
zip.add_directory("META-INF/", options).map_err(|e| err(&e))?;
zip.start_file("META-INF/MANIFEST.MF", options).map_err(|e| err(&e))?;
zip.write_all(manifest.as_bytes()).map_err(|e| err(&e))?;
}
let mut stack = vec![from.to_path_buf()];
while let Some(dir) = stack.pop() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(&dir) else { continue };
let mut entries: Vec<_> = entries.flatten().collect();
entries.sort_by_key(|e| e.file_name());
for e in entries {
let path = e.path();
let name = path.strip_prefix(from).unwrap_or(&path).to_string_lossy().replace('\\', "/");
if manifest.is_some() && name.eq_ignore_ascii_case("META-INF/MANIFEST.MF") {
continue;
}
match e.file_type() {
Ok(t) if t.is_dir() => {
if !(manifest.is_some() && name == "META-INF") {
zip.add_directory(format!("{name}/"), options).map_err(|e| err(&e))?;
}
stack.push(path);
}
Ok(t) if t.is_file() => {
zip.start_file(name, options).map_err(|e| err(&e))?;
let mut file = fs::File::open(&path).map_err(|e| err(&e))?;
std::io::copy(&mut file, &mut zip).map_err(|e| err(&e))?;
}
_ => {}
}
}
}
zip.finish().map_err(|e| err(&e))?;
Ok(())
}
fn copy_resources(base: &Path, dir: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(dir) else { return Ok(0) };
let mut copied = 0;
for e in entries.flatten() {
let path = e.path();
let Ok(t) = e.file_type() else { continue };
if t.is_dir() {
// The output folder can sit inside a source root (`src` holding `classes`).
if path != to && !path.starts_with(to) {
copied += copy_resources(base, &path, to, cancel)?;
}
continue;
}
if !t.is_file() || path.extension().is_some_and(|x| x == "java") {
continue;
}
let target = to.join(path.strip_prefix(base).unwrap_or(&path));
let newer =
match (fs::metadata(&path).and_then(|m| m.modified()), fs::metadata(&target).and_then(|m| m.modified())) {
(Ok(source), Ok(existing)) => source > existing,
_ => true,
};
if newer {
if let Some(parent) = target.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::copy(&path, &target)
.map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", path.display())))?;
copied += 1;
}
}
Ok(copied)
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::settings::{FacetConfig, ModuleDependency, ProjectLibrary};
fn write(path: &Path, text: &str) {
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, text).unwrap();
}
#[test]
fn reads_language_levels() {
assert_eq!(language_release("17"), Some(17));
assert_eq!(language_release("1.8"), Some(8));
assert_eq!(language_release("JDK_11"), Some(11));
assert_eq!(language_release(""), None);
}
#[test]
fn plans_javac_over_source_roots_with_libraries_and_web_lib() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("shop");
write(&root.join("src/com/a/A.java"), "package com.a; class A {}");
write(&root.join("src/com/a/app.properties"), "x=1");
write(&root.join("test/com/a/ATest.java"), "package com.a; class ATest {}");
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
write(&root.join("WebRoot/WEB-INF/lib/x.jar"), "");
let ps = ProjectStructureSettings {
libraries: vec![
ProjectLibrary { name: "tools".into(), classes: vec!["lib/*.jar".into()], ..Default::default() },
ProjectLibrary {
name: "junit".into(),
classes: vec!["junit.jar".into()],
scope: DependencyScope::Test,
..Default::default()
},
],
facets: vec![FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: "WebRoot/WEB-INF/web.xml".into(),
web_root: String::new(),
}],
..Default::default()
};
let roots =
StructureRoots { sources: vec![root.join("src")], tests: vec![root.join("test")], ..Default::default() };
let jdk = StructureJdk { home: PathBuf::from("/jdk"), major: 21 };
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "17", BuildKind::Rebuild, &tmp.path().join("cache"))
.unwrap()
.unwrap();
assert_eq!(plan.system, BuildSystem::Javac);
let shown: Vec<String> = plan.steps.iter().map(BuildStep::display).collect();
assert_eq!(shown[0], "Clean out/production/shop, out/test/shop");
let javac = &plan.steps[1];
let cp = |s: &BuildStep| s.args[s.args.iter().position(|a| a == "-cp").unwrap() + 1].clone();
let sep = if cfg!(windows) { ";" } else { ":" };
let main_cp = cp(javac);
let entries: Vec<&str> = main_cp.split(sep).collect();
assert_eq!(entries.len(), 2, "{main_cp}");
assert!(entries[0].ends_with("lib/*"));
assert!(entries[1].ends_with("WEB-INF/lib/*"));
assert!(javac.args.windows(2).any(|w| w == ["--release", "17"]));
let args = fs::read_to_string(tmp.path().join("cache/javac/production.args")).unwrap();
assert!(args.contains("A.java") && !args.contains("ATest.java"));
assert_eq!(shown[2], "Copy resources to out/production/shop");
let test = &plan.steps[3];
let test_cp = cp(test);
assert!(test_cp.starts_with(&root.join("out/production/shop").to_string_lossy().into_owned()));
assert!(test_cp.contains("junit.jar"));
}
#[test]
fn a_module_dependency_gives_its_library_a_scope_and_jdk_8_gets_source_and_target() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
write(&root.join("src/A.java"), "class A {}");
let mut ps = ProjectStructureSettings {
libraries: vec![ProjectLibrary {
name: "junit".into(),
classes: vec!["junit.jar".into()],
..Default::default()
}],
compiler_output: "build/classes".into(),
..Default::default()
};
ps.modules.insert(
".".into(),
ModuleStructureSettings {
language_level: "1.8".into(),
dependencies: vec![ModuleDependency {
kind: "library".into(),
target: "junit".into(),
scope: DependencyScope::Test,
exported: false,
}],
..Default::default()
},
);
let roots = StructureRoots { sources: vec![root.join("src")], ..Default::default() };
let jdk = StructureJdk { home: PathBuf::from("/jdk8"), major: 8 };
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "21", BuildKind::Build, &tmp.path().join("c"))
.unwrap()
.unwrap();
let javac = &plan.steps[0];
assert!(!javac.args.iter().any(|a| a == "-cp"), "{:?}", javac.args);
assert!(javac.args.windows(4).any(|w| w == ["-source", "1.8", "-target", "1.8"]));
assert!(javac.args.windows(2).any(|w| w[0] == "-d" && w[1].ends_with("build/classes/production/p")));
}
#[test]
fn no_plan_without_java_sources() {
let tmp = tempfile::tempdir().unwrap();
let roots = StructureRoots { sources: vec![tmp.path().join("src")], ..Default::default() };
let plan =
structure_plan(tmp.path(), &Default::default(), &roots, None, "", BuildKind::Build, &tmp.path().join("c"));
assert!(plan.unwrap().is_none());
}
#[test]
fn copies_resources_but_not_sources_and_skips_up_to_date_files() {
let tmp = tempfile::tempdir().unwrap();
let src = tmp.path().join("src");
write(&src.join("a/A.java"), "class A {}");
write(&src.join("a/x.xml"), "<x/>");
let out = tmp.path().join("out");
let action = Action::CopyResources { from: vec![src], to: out.clone() };
let cancel = CancellationToken::new();
assert_eq!(action.run(&cancel).unwrap(), "1 resource file(s) copied");
assert!(out.join("a/x.xml").is_file() && !out.join("a/A.java").exists());
assert_eq!(action.run(&cancel).unwrap(), "0 resource file(s) copied");
Action::Clean(vec![out.clone()]).run(&cancel).unwrap();
assert!(!out.exists());
}
fn entries(archive: &Path) -> Vec<String> {
let mut zip = zip::ZipArchive::new(fs::File::open(archive).unwrap()).unwrap();
(0..zip.len()).map(|i| zip.by_index(i).unwrap().name().unwrap().into_owned()).collect()
}
fn run_plan(plan: &BuildPlan) {
let cancel = CancellationToken::new();
for step in &plan.steps {
if let Some((action, _)) = &step.action {
action.run(&cancel).unwrap();
}
}
}
#[test]
fn lays_out_war_jar_and_exploded_artifacts() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("shop");
write(&root.join("WebRoot/index.jsp"), "hi");
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
write(&root.join("WebRoot/WEB-INF/lib/inside.jar"), "");
write(&root.join("lib/extra.jar"), "");
let classes = root.join("out/production/shop");
write(&classes.join("com/a/A.class"), "");
let artifact = |name: &str, kind| ArtifactConfig {
name: name.into(),
kind,
module: ".".into(),
include_libraries: vec!["extra".into()],
main_class: "com.a.A".into(),
..Default::default()
};
let ps = ProjectStructureSettings {
libraries: vec![ProjectLibrary {
name: "extra".into(),
classes: vec!["lib/*.jar".into()],
..Default::default()
}],
facets: vec![FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: "WebRoot/WEB-INF/web.xml".into(),
web_root: String::new(),
}],
artifacts: vec![
artifact("shop:war", ArtifactKind::War),
artifact("shop:war exploded", ArtifactKind::WarExploded),
artifact("shop:jar", ArtifactKind::Jar),
],
..Default::default()
};
let cache = tmp.path().join("cache");
for a in &ps.artifacts {
let plan = BuildPlan {
system: BuildSystem::Javac,
title: String::new(),
steps: artifact_steps(&root, &ps, a, &classes, None, &cache),
};
run_plan(&plan);
}
let war = entries(&root.join("out/artifacts/shop_war/shop.war"));
for name in [
"index.jsp",
"WEB-INF/web.xml",
"WEB-INF/lib/inside.jar",
"WEB-INF/lib/extra.jar",
"WEB-INF/classes/com/a/A.class",
] {
assert!(war.iter().any(|e| e == name), "{name} in {war:?}");
}
let exploded = root.join("out/artifacts/shop_war_exploded");
assert!(exploded.join("WEB-INF/classes/com/a/A.class").is_file());
assert!(exploded.join("WEB-INF/lib/extra.jar").is_file());
let jar_dir = root.join("out/artifacts/shop_jar");
let jar = entries(&jar_dir.join("shop.jar"));
assert_eq!(jar[..2], ["META-INF/".to_owned(), "META-INF/MANIFEST.MF".to_owned()]);
assert!(jar.iter().any(|e| e == "com/a/A.class"));
assert!(jar_dir.join("extra.jar").is_file());
let mut zip = zip::ZipArchive::new(fs::File::open(jar_dir.join("shop.jar")).unwrap()).unwrap();
let mut manifest = String::new();
std::io::Read::read_to_string(&mut zip.by_name("META-INF/MANIFEST.MF").unwrap(), &mut manifest).unwrap();
assert!(manifest.contains("Main-Class: com.a.A") && manifest.contains("Class-Path: extra.jar"));
}
#[test]
fn never_lays_out_over_its_own_sources() {
let tmp = tempfile::tempdir().unwrap();
let web = tmp.path().join("WebRoot");
write(&web.join("a.jsp"), "");
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
assert!(action.run(&CancellationToken::new()).is_err());
assert!(web.join("a.jsp").is_file());
}
}
+3
Переглянути файл
@@ -12,6 +12,8 @@ use std::collections::BTreeMap;
pub struct EditorGeneralSettings {
/// Change font size with ⌘ + mouse wheel.
pub wheel_zoom: bool,
/// Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors.
pub wheel_zoom_scope: String,
pub markdown_image_folder: String,
pub markdown_image_name_pattern: String,
/// Drag-and-drop of selected text inside the editor.
@@ -37,6 +39,7 @@ impl Default for EditorGeneralSettings {
fn default() -> Self {
Self {
wheel_zoom: false,
wheel_zoom_scope: "active".into(),
markdown_image_folder: "assets".into(),
markdown_image_name_pattern: "image-{timestamp}".into(),
drag_and_drop: true,
+47
Переглянути файл
@@ -67,6 +67,10 @@ pub struct Settings {
pub mcp_server: McpServerSettings,
/// Tools › Agents: Command Execution Policy.
pub agent_security: AgentSecuritySettings,
/// Appearance & Behavior › Scopes: named file sets other settings refer to.
pub scopes: Vec<NamedScope>,
/// Appearance & Behavior › File Colors.
pub file_colors: FileColorSettings,
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
@@ -502,6 +506,8 @@ impl Default for Settings {
agents: AgentSettings::default(),
mcp_server: McpServerSettings::default(),
agent_security: AgentSecuritySettings::default(),
scopes: Vec::new(),
file_colors: FileColorSettings::default(),
plugins: BTreeMap::new(),
}
}
@@ -512,6 +518,47 @@ fn default_keymap() -> &'static str {
if cfg!(target_os = "macos") { "intellij-macos" } else { "intellij-windows" }
}
/// A named set of files: `file:src//*.ts && !file:*.test.ts` (project-relative path patterns
/// joined with `||`, `&&`, `!` and parentheses).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct NamedScope {
pub name: String,
pub pattern: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileColorSettings {
pub enabled: bool,
pub editor_tabs: bool,
pub project_view: bool,
/// Scope → colour; the first scope that holds a file gives its colour.
pub colors: Vec<FileColor>,
}
impl Default for FileColorSettings {
fn default() -> Self {
let color = |scope: &str, color: &str| FileColor { scope: scope.into(), color: color.into() };
Self {
enabled: true,
editor_tabs: true,
project_view: true,
colors: vec![color("Non-Project Files", "yellow"), color("Tests", "green")],
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileColor {
/// A built-in scope (`Tests`, `Production`, `Project Files`, `Non-Project Files`) or a
/// `scopes` entry, by name.
pub scope: String,
/// A palette name (`blue`, `green`, `orange`, `rose`, `violet`, `yellow`, `gray`) or `#rrggbb`.
pub color: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct CustomKeymap {
+4
Переглянути файл
@@ -69,6 +69,9 @@ pub struct GitSettings {
pub push_dialog_only_protected: bool,
/// Stashes and shelves share one tab.
pub combine_stash_and_shelf: bool,
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
/// stage and unstage instead of inclusion checkboxes, and no change lists.
pub staging_area: bool,
}
impl Default for GitSettings {
@@ -90,6 +93,7 @@ impl Default for GitSettings {
show_push_dialog: true,
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
}
}
}
+252
Переглянути файл
@@ -0,0 +1,252 @@
//! HTTP Client tools: list and run requests from project `.http` / `.rest` files.
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::path::Path;
/// Response body characters returned at most (keeps agent context bounded).
const MAX_BODY_CHARS: usize = 8_192;
pub fn tools() -> Vec<Tool> {
vec![http_list_requests(), http_run_request()]
}
fn is_http_file(path: &Path) -> bool {
path.extension()
.and_then(|e| e.to_str())
.is_some_and(|e| e.eq_ignore_ascii_case("http") || e.eq_ignore_ascii_case("rest"))
}
async fn resolve_http_file(call: &Call, path: &str) -> IdeResult<std::path::PathBuf> {
let path = call.resolve_inside(path)?;
if !is_http_file(&path) {
return Err(IdeError::invalid("path must be a .http or .rest file"));
}
if !path.is_file() {
return Err(IdeError::not_found(format!("No such file: {}", call.display(&path))));
}
Ok(path)
}
fn http_list_requests() -> Tool {
Tool::new(
"http_list_requests",
"Lists the HTTP requests in a project `.http` or `.rest` file (IntelliJ-style HTTP Client).
Returns each request's 0-based `index`, optional `name`, `method`, URL as written (variables not substituted), and `line`.
Use `http_run_request` with the same `path` and an `index` to send one.",
|call| async move {
let path = resolve_http_file(&call, &call.str("path")?).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
let requests: Vec<_> = ide_http::parse::requests(&text)
.into_iter()
.map(|b| {
json!({
"index": b.index,
"name": b.name,
"method": b.method,
"url": b.url,
"line": b.line,
})
})
.collect();
Output::json(json!({ "requests": requests }))
},
)
.param(Param::required(
"path",
ParamType::String,
"Project-relative path to a `.http` or `.rest` file",
))
.output(json!({
"type": "object",
"properties": {
"requests": {
"type": "array",
"items": {
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"line": { "type": "integer" },
},
"required": ["index", "method", "url", "line"],
},
},
},
"required": ["requests"],
}))
}
fn truncate_chars(text: &str, max: usize) -> (String, bool) {
let count = text.chars().count();
if count <= max {
return (text.to_owned(), false);
}
(text.chars().take(max).collect(), true)
}
/// Drop resolved URLs from transport errors so MCP JSON does not echo env-substituted targets.
fn redact_transport_error(error: Option<String>, resolved_url: &str) -> Option<String> {
let error = error?;
let mut out = error.replace(resolved_url, "<url>");
// reqwest often embeds `https://host/...` even when the primary URL string differs slightly.
out = redact_urls(&out);
Some(out)
}
fn redact_urls(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut rest = s;
loop {
// Prefer `https://` so we don't match the `http://` prefix inside it.
let start = match (rest.find("https://"), rest.find("http://")) {
(Some(a), Some(b)) => Some(a.min(b)),
(Some(a), None) => Some(a),
(None, Some(b)) => Some(b),
(None, None) => None,
};
let Some(start) = start else {
out.push_str(rest);
break;
};
out.push_str(&rest[..start]);
out.push_str("<url>");
let after = &rest[start..];
let end = after.find(|c: char| c.is_whitespace() || c == '\'' || c == '"' || c == ')').unwrap_or(after.len());
rest = &after[end..];
}
out
}
fn http_run_request() -> Tool {
Tool::new(
"http_run_request",
"Runs one request from a project `.http` or `.rest` file by 0-based `index`, using the IDE HTTP Client
(same as Run Request in the editor). Variables resolve from `http-client.env.json` / `http-client.private.env.json`
for the optional `env` name. Asks for confirmation with the resolved URL (and header names) first.
Returns status, timing and a truncated response body — not request headers or body (those may hold secrets).
The `url` field in the result is as written in the file (unsubstituted); transport errors redact URLs.",
|call| async move {
let rel = call.str("path")?;
let path = resolve_http_file(&call, &rel).await?;
let index =
call.opt_i64("index")?.ok_or_else(|| IdeError::invalid("missing or invalid argument `index`"))?;
if index < 0 {
return Err(IdeError::invalid("index must be >= 0"));
}
let index = index as u32;
let env = call.opt_str("env")?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
let blocks = ide_http::parse::requests(&text);
let block =
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
let input = ide_http::RunInput {
text: &text,
index,
file: Some(&path),
root: Some(call.root()),
env: env.as_deref(),
};
// Prepare before confirm so the dialog shows the real destination (after env substitution).
let prepared = ide_http::prepare(&input)?;
let subject = prepared.name.clone().unwrap_or_else(|| format!("{} {}", prepared.method, prepared.url));
let headers: Vec<_> = prepared.headers.iter().map(|(k, _)| k.as_str()).collect();
let mut detail = format!("{} {}\nFile: {rel}\nIndex: {index}", prepared.method, prepared.url);
if let Some(env) = &env {
detail.push_str(&format!("\nEnvironment: {env}"));
}
if !headers.is_empty() {
detail.push_str(&format!("\nHeaders: {}", headers.join(", ")));
}
if prepared.body.is_some() {
detail.push_str("\nBody: present");
}
call.confirm(&subject, Some(detail)).await?;
let exchange = ide_http::run(input, &call.cancel).await?;
let history = call.project().http_history.clone();
let saved = exchange.clone();
let _ = call.host().blocking(move || history.add(&saved)).await;
let (body, body_truncated) = match exchange.response.as_ref().and_then(|r| r.body.as_deref()) {
Some(b) => {
let (t, truncated) = truncate_chars(b, MAX_BODY_CHARS);
(Some(t), truncated)
}
None => (None, false),
};
let response = exchange.response.as_ref();
Output::json(json!({
"index": index,
"name": block.name,
"method": block.method,
"url": block.url,
"status": response.map(|r| r.status),
"statusText": response.map(|r| r.status_text.clone()),
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
"body": body,
"bodyTruncated": body_truncated,
}))
},
)
.write()
.param(Param::required("path", ParamType::String, "Project-relative path to a `.http` or `.rest` file"))
.param(Param::required("index", ParamType::Integer, "0-based request index from `http_list_requests`"))
.param(Param::optional(
"env",
ParamType::String,
"Environment name from `http-client.env.json` / `http-client.private.env.json`",
))
.output(json!({
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"status": { "type": ["integer", "null"] },
"statusText": { "type": ["string", "null"] },
"totalMs": { "type": ["number", "null"] },
"error": { "type": ["string", "null"] },
"body": { "type": ["string", "null"] },
"bodyTruncated": { "type": "boolean" },
},
"required": ["index", "method", "url", "bodyTruncated"],
}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_http_and_rest_extensions() {
assert!(is_http_file(Path::new("a.http")));
assert!(is_http_file(Path::new("a.REST")));
assert!(!is_http_file(Path::new("a.txt")));
}
#[test]
fn truncates_long_bodies() {
let long = "x".repeat(MAX_BODY_CHARS + 10);
let (t, truncated) = truncate_chars(&long, MAX_BODY_CHARS);
assert!(truncated);
assert_eq!(t.chars().count(), MAX_BODY_CHARS);
assert_eq!(truncate_chars("ok", MAX_BODY_CHARS), ("ok".into(), false));
}
#[test]
fn redacts_urls_in_transport_errors() {
let url = "https://secret.example/v1?token=abc";
assert_eq!(
redact_transport_error(Some(format!("error sending request for {url}")), url).as_deref(),
Some("error sending request for <url>")
);
assert_eq!(redact_urls("fail https://a.example/x and http://b/y"), "fail <url> and <url>");
}
}
+2
Переглянути файл
@@ -7,6 +7,7 @@ pub(crate) mod run;
mod vcs;
pub use requests::Requests;
mod files;
mod http;
mod page;
mod reports;
mod search;
@@ -39,6 +40,7 @@ fn tools() -> Vec<tool::Tool> {
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
tools.extend(http::tools());
tools
}
+86 -11
Переглянути файл
@@ -641,6 +641,82 @@ pub async fn maven_exclude_dependency(
.map_err(join_err)?
}
/// Build / Rebuild / Build Artifacts of a Java project without a build tool, from its
/// Project Structure; `None` when it has no Java sources under its source roots.
fn structure_plan(
root: &Path,
settings: &Settings,
detected: &[ide_workspace::roots::SourceFolder],
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<compile::BuildPlan>> {
let (ps, roots, jdk) = structure_inputs(root, settings, detected);
compile::structure_plan(root, &ps, &roots, jdk.as_ref(), &settings.languages.java.language_level, kind, cache)
}
/// The Project Structure, roots and JDK a build of a project without a build tool uses.
/// An Eclipse project's `.classpath` libraries and its web content folder count as if they
/// were configured, and a web project with no artifacts gets IDEA's `<name>:war exploded`.
pub(crate) fn structure_inputs(
root: &Path,
settings: &Settings,
detected: &[ide_workspace::roots::SourceFolder],
) -> (ide_core::settings::ProjectStructureSettings, compile::StructureRoots, Option<compile::StructureJdk>) {
use ide_core::settings::{ArtifactConfig, ArtifactKind, FacetConfig, ProjectLibrary};
use ide_workspace::roots::{ProjectRoots, RootKind, eclipse};
let mut ps = settings.project_structure.clone();
let mut included = Vec::new();
if let Some(cp) = eclipse::classpath(root).filter(|cp| !cp.libraries.is_empty()) {
let name = "Eclipse classpath".to_owned();
if !ps.libraries.iter().any(|l| l.name == name) {
ps.libraries.push(ProjectLibrary { name: name.clone(), classes: cp.libraries, ..Default::default() });
}
included.push(name);
}
if !ps.facets.iter().any(|f| f.kind == "web")
&& let Some(web) = eclipse::web_root(root)
{
ps.facets.push(FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: format!("{web}/WEB-INF/web.xml"),
web_root: web,
});
if ps.artifacts.is_empty() {
let name = root.file_name().map_or_else(|| "app".into(), |n| n.to_string_lossy().into_owned());
ps.artifacts.push(ArtifactConfig {
name: format!("{name}:war exploded"),
kind: ArtifactKind::WarExploded,
module: ".".into(),
include_libraries: included,
..Default::default()
});
}
}
let roots = ProjectRoots::compute(detected.to_vec(), &ps);
let of = |kind: RootKind| roots.roots.iter().filter(|r| r.kind == kind).map(|r| root.join(&r.path)).collect();
let module = ps.module_settings(root, root);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
.unwrap_or(&settings.languages.java.language_level);
// Without a configured SDK, an installed JDK that can compile the language level.
let jdk = ide_sdk::apply::module_jdk(root, root, settings)
.or_else(|| {
let installed = ide_sdk::java::installed_jdks();
ide_sdk::java::pick_jdk(&installed, compile::language_release(level)).cloned()
})
.map(|j| compile::StructureJdk { home: j.home, major: j.major });
let roots = compile::StructureRoots {
sources: of(RootKind::Source),
tests: of(RootKind::Test),
resources: of(RootKind::Resources),
test_resources: of(RootKind::TestResources),
excluded: of(RootKind::Excluded),
};
(ps, roots, jdk)
}
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
let commands = ide_run::cmake_build_configs(configs, id)?;
let title = commands.last().map(|c| c.name.clone()).unwrap_or_default();
@@ -675,6 +751,7 @@ pub async fn build_run(
let project = host.project(window)?;
let (root, cache, sink) = (project.root.clone(), project.build_cache_dir(), project.sink.clone());
let settings = project.settings.effective();
let detected = project.detected_roots.read().clone();
let config_dir = host.config_dir.clone();
let token = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
@@ -738,17 +815,15 @@ pub async fn build_run(
plan.title = workspace.name;
plan
} else {
prepare_plan(
compile::plan(
&root,
&with_profiles(load(&root, &cache, &settings), &cache),
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
)?,
&root,
&settings,
)
let model = with_profiles(load(&root, &cache, &settings), &cache);
match compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref()) {
Ok(plan) => prepare_plan(plan, &root, &settings),
// No build tool: a Java project builds from its Project Structure.
Err(e) if e.kind == ide_core::error::ErrorKind::NotFound => {
structure_plan(&root, &settings, &detected, kind, &cache)?.ok_or(e)?
}
Err(e) => return Err(e),
}
};
let result = compile::run(&root, &plan, &token, &|e| {
let _ = on_event.send(e);
+48
Переглянути файл
@@ -1057,6 +1057,11 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
blocking(move || apply_edit(&documents, &edit)).await?;
}
open_plugin_action_target(&action, window);
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, None, command).await
{
return result;
}
if let Some(command) = action.command
&& !(action.edit.is_some() && is_client_follow_up(&project, doc, None, &command).await)
{
@@ -1608,9 +1613,47 @@ pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command:
return blocking(move || plugins.run_language_command(&plugin, &command_id, argument.as_deref(), invocation))
.await;
}
if let Some(result) = run_plugin_server_command(host, window, doc, None, &command).await {
return result;
}
host.project(window)?.lsp.execute_command(doc, command).await
}
/// Runs `command` through the plugin that claims it (`[[contributes.serverCommands]]`)
/// when no server of the document executes it itself: a code lens, code action or inlay
/// hint may carry a command the server leaves to the client. `None` when no plugin does.
async fn run_plugin_server_command(
host: &Host,
window: &str,
doc: DocId,
server: Option<ServerId>,
command: &Command,
) -> Option<IdeResult<()>> {
let plugins = crate::plugins::editor_plugin_host()?;
let project = host.project(window).ok()?;
if project.lsp.provides_command(doc, server, &command.command).await {
return None;
}
let (plugin, run) = plugins.server_command(&project.lsp.server_names(doc, server), &command.command)?;
let snap = match project.documents.snapshot(doc) {
Ok(snap) => snap,
Err(e) => return Some(Err(e)),
};
let invocation = ide_plugin::Invocation {
client: Some(window.into()),
workspace_root: Some(project.root.clone()),
editor: Some(ide_plugin::EditorContext {
path: snap.path.0.clone(),
language: snap.language.0,
selections: vec![],
}),
selected_paths: vec![snap.path.0],
..Default::default()
};
let arguments = serde_json::Value::Array(command.arguments.clone()).to_string();
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
}
/// Resolves an interactive command without applying edits or executing it.
pub async fn lsp_resolve_command(
host: &Host,
@@ -1652,6 +1695,11 @@ pub async fn lsp_execute_code_action(
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
}
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, Some(action.server), command).await
{
return result.map(|()| Vec::new());
}
match action.command {
Some(command) if edited && is_client_follow_up(&project, doc, Some(action.server), &command).await => {
Ok(Vec::new())
+28 -9
Переглянути файл
@@ -54,8 +54,9 @@ pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<Extensi
Ok(host.project(window)?.index.file_extensions())
}
pub fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_files(&query, limit as usize))
pub async fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_files(&query, limit as usize))).await
}
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
@@ -63,18 +64,33 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
pub fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_dirs(&query, limit as usize))
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_dirs(&query, limit as usize))).await
}
pub fn find_symbols(
pub async fn find_symbols(
host: &Host,
window: &str,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
Ok(host.project(window)?.index.find_symbols(&query, filter, limit as usize))
let project = host.project(window)?;
blocking(move || Ok(project.index.find_symbols(&query, filter, limit as usize))).await
}
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder),
/// at most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
pub async fn find_symbols_named(
host: &Host,
window: &str,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
const SYMBOLS_PER_NAME: usize = 50;
let project = host.project(window)?;
blocking(move || Ok(project.index.symbols_named_any(&names, &PathBuf::from(within), SYMBOLS_PER_NAME))).await
}
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
@@ -318,11 +334,14 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
pub(crate) fn register(d: &mut Dispatcher) {
d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_files_named", |c| async move { find_files_named(&c.host, &c.window, c.arg("name")?).await });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_symbols", |c| async move {
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?).await
});
d.add("find_symbols_named", |c| async move {
find_symbols_named(&c.host, &c.window, c.arg("names")?, c.arg("within")?).await
});
d.add("mark_recent", |c| async move { mark_recent(&c.host, &c.window, c.arg("path")?) });
d.add("remove_recent", |c| async move { remove_recent(&c.host, &c.window, c.arg("path")?) });
+82 -2
Переглянути файл
@@ -202,12 +202,86 @@ pub async fn run_tomcat_installations(
.map_err(|e| IdeError::internal(e.to_string()))
}
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
const PROJECT_ARTIFACT: &str = "project:";
fn project_web_artifacts(ps: &ide_core::settings::ProjectStructureSettings) -> Vec<ide_build::web::WebArtifact> {
ide_build::compile::structure_web_artifacts(ps)
.into_iter()
.map(|a| ide_build::web::WebArtifact {
id: format!("{PROJECT_ARTIFACT}{}", a.name),
name: a.name.split(':').next().unwrap_or(&a.name).to_owned(),
module: if a.module == "." { String::new() } else { a.module.clone() },
tool: "project".into(),
})
.collect()
}
/// Compiles the project and packs the Project Structure artifact `name` as the WAR Tomcat
/// deploys, recorded in `base` like a build tool's archive.
fn build_project_war(
root: &std::path::Path,
settings: &ide_core::settings::Settings,
detected: &[ide_workspace::roots::SourceFolder],
name: &str,
base: &std::path::Path,
cache: &std::path::Path,
) -> IdeResult<()> {
use ide_build::compile;
let (ps, roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
let artifact = ps
.artifacts
.iter()
.find(|a| a.name == name)
.ok_or_else(|| IdeError::invalid(format!("No artifact named {name} in Project Structure › Artifacts")))?;
let war = base.join("artifact").join(format!(
"{}.war",
name.split(':').next().unwrap_or(name).replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
));
let plan = compile::structure_war_plan(
root,
&ps,
&roots,
jdk.as_ref(),
&settings.languages.java.language_level,
artifact,
&war,
cache,
)?;
let result = compile::run(root, &plan, &ide_core::CancellationToken::new(), &|_| {})?;
if !result.success {
let first = result.messages.iter().find(|m| m.severity == ide_core::Severity::Error);
let text = match first {
Some(m) => match (&m.path, m.range) {
(Some(path), Some(range)) => {
format!("{}:{}: {}", std::path::PathBuf::from(path.clone()).display(), range.start.line + 1, m.text)
}
_ => m.text.clone(),
},
None => "the build failed".into(),
};
return Err(IdeError::invalid(format!("Cannot build {name}: {text}")));
}
std::fs::create_dir_all(base)?;
std::fs::write(base.join("artifact-id.txt"), format!("{PROJECT_ARTIFACT}{name}"))?;
std::fs::write(base.join("artifact-path.txt"), war.to_string_lossy().as_bytes())?;
Ok(())
}
pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<ide_build::web::WebArtifact>> {
host.require_trust(window)?;
let project = host.project(window)?;
tokio::task::spawn_blocking(move || {
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &project.settings.effective());
ide_build::web::artifacts(&project.root, &model)
let settings = project.settings.effective();
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &settings);
let mut artifacts = ide_build::web::artifacts(&project.root, &model);
// Without a build tool, the Project Structure's WAR artifacts are built by the IDE.
if model.maven.is_none() && model.gradle.is_empty() {
let detected = project.detected_roots.read().clone();
let (ps, _, _) = crate::ops::build::structure_inputs(&project.root, &settings, &detected);
artifacts.extend(project_web_artifacts(&ps));
}
artifacts
})
.await
.map_err(|e| IdeError::internal(e.to_string()))
@@ -230,6 +304,12 @@ pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> I
.or_else(|| artifacts.first().map(|a| &a.id))
.ok_or_else(|| IdeError::invalid("Choose a WAR artifact"))?;
let base = ide_run::tomcat::effective_base_dir(&project.root, &project.cache_dir, &config)?;
if let Some(name) = id.strip_prefix(PROJECT_ARTIFACT) {
let settings = project.settings.effective();
let detected = project.detected_roots.read().clone();
build_project_war(&project.root, &settings, &detected, name, &base, &project.build_cache_dir())?;
return Ok(None);
}
// "Build before launch" is skipped when the built WAR is already newer than the
// sources of every module in the build, so a repeated run does not rebuild (IDEA's
// up-to-date check) but a change in a dependency module does.
+29
Переглянути файл
@@ -313,6 +313,35 @@ impl PluginHost {
}
}
impl PluginHost {
/// The plugin command that runs `command`, which one of the language servers
/// `servers` handed to the client (`[[contributes.serverCommands]]`): the plugin
/// and its command id. A plugin counts while it holds `lsp:<server>`; when several
/// claim the same server and command, the first one loaded keeps it.
pub(crate) fn server_command(&self, servers: &[String], command: &str) -> Option<(String, String)> {
let mut claims = self.ui.items(super::ui_points::SERVER_COMMANDS, None).into_iter().filter_map(|item| {
let decl: super::ui_points::ServerCommandDecl = serde_json::from_value(item.decl).ok()?;
let claimed = decl.command == command && servers.contains(&decl.server);
let grant = ide_extension::Capability::Lsp(decl.server.clone());
let granted = claimed
&& self.get(&item.plugin_id).is_ok_and(|p| p.meta.lock().granted.iter().any(|g| g.covers(&grant)));
granted.then_some((item.plugin_id, decl.server, decl.run))
});
let (plugin, server, run) = claims.next()?;
for (other, _, _) in claims.filter(|(other, s, _)| *other != plugin && *s == server) {
static LOGGED: parking_lot::Mutex<std::collections::BTreeSet<(String, String, String)>> =
parking_lot::Mutex::new(std::collections::BTreeSet::new());
if LOGGED.lock().insert((other.clone(), server.clone(), command.to_owned())) {
tracing::warn!(
"plugins {plugin} and {other} both claim command `{command}` of language server {server}; \
{plugin} was loaded first and keeps it"
);
}
}
Some((plugin, run))
}
}
pub(crate) fn signature_help(h: SignatureHelp) -> ide_lsp::types::SignatureHelp {
let signatures: Vec<_> = h
.signatures
+1
Переглянути файл
@@ -93,6 +93,7 @@ pub fn register_builtin_points(
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
registry.register(Arc::new(UiPoint::new(p::COMMIT_CHECKS, ui.clone(), p::commit_check)))?;
registry.register(Arc::new(UiPoint::new(p::SERVER_COMMANDS, ui.clone(), p::server_command)))?;
registry.register(Arc::new(UiPoint::new(ide_extension::LOCALES_POINT, ui.clone(), p::locales)))?;
Ok(())
}
+37
Переглянути файл
@@ -46,6 +46,11 @@
//! id = "conventional"
//! title = "Conventional Commits" # Commit Options › Before Commit; `commit-checker.check` runs it
//!
//! [[contributes.serverCommands]]
//! server = "phoxite" # the language server whose results carry the command
//! command = "laravel.modelView" # a command the server leaves to the client
//! run = "model-view" # this plugin's command; needs `lsp:phoxite`
//!
//! [[contributes.fileTemplates]]
//! id = "drawing"
//! name = "Excalidraw Drawing"
@@ -72,6 +77,7 @@ pub const FILE_ICONS: &str = "fileIcons";
pub const MARKER_ICONS: &str = "markerIcons";
pub const FILE_TEMPLATES: &str = "fileTemplates";
pub const COMMIT_CHECKS: &str = "commitChecks";
pub const SERVER_COMMANDS: &str = "serverCommands";
const VIEW_ITEM_MENU: &str = "viewItem.context";
/// The toolbar above the commit message (Commit tool window and dialog).
@@ -964,6 +970,37 @@ pub(super) fn commit_check(pkg: &Package, decl: toml::Value) -> Result<UiDecl, S
Ok(UiDecl::new(d.id.clone(), d.title.clone(), json(&d)?))
}
/// A command a language server's code lens, code action or inlay hint carries and
/// leaves to the client, and the plugin command that runs it.
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub(super) struct ServerCommandDecl {
/// The server's name in its language definition.
pub(super) server: String,
pub(super) command: String,
/// The plugin's command (`[[contributes.commands]]`); it gets the arguments as JSON.
pub(super) run: String,
}
/// `[[contributes.serverCommands]]` (API 1.9): routes a command no server executes
/// itself to the plugin's own command.
pub(super) fn server_command(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
let d: ServerCommandDecl = decode(SERVER_COMMANDS, decl)?;
pkg.manifest.needs_api(&format!("contributes.{SERVER_COMMANDS}"), 9)?;
if d.command.is_empty() || d.command.len() > 256 {
return Err(format!("contributes.{SERVER_COMMANDS}: command names are 1–256 bytes"));
}
declared_command(pkg, SERVER_COMMANDS, &d.run)?;
let grant: ide_extension::Capability =
format!("lsp:{}", d.server).parse().map_err(|e| format!("contributes.{SERVER_COMMANDS}: {e}"))?;
if !pkg.manifest.capabilities.all().any(|c| *c == grant) {
return Err(format!(
"contributes.{SERVER_COMMANDS}: needs the `{grant}` capability (the command comes from that server)"
));
}
Ok(UiDecl::new(format!("{}:{}", d.server, d.command), d.command.clone(), json(&d)?))
}
const MAX_CATALOG_ENTRIES: usize = 20_000;
pub fn locale_asset(tag: &str) -> String {
+1
Переглянути файл
@@ -500,6 +500,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "find_files_named"
| "find_dirs"
| "find_symbols"
| "find_symbols_named"
| "mark_recent"
| "remove_recent"
| "recent_files"
+73
Переглянути файл
@@ -697,3 +697,76 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
let interrupted = h.json("wait_for_run", json!({"name": "interrupt", "timeout": 10000})).await;
assert_eq!(interrupted["state"], "stoppedByAgent", "{interrupted}");
}
#[tokio::test(flavor = "multi_thread")]
async fn http_list_and_run_require_confirmation() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let h = Harness::new();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut buf = [0u8; 1024];
let _ = socket.read(&mut buf).await;
let body = b"{\"ok\":true}";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
body.len(),
std::str::from_utf8(body).unwrap()
);
let _ = socket.write_all(response.as_bytes()).await;
});
std::fs::write(
h.root.join("api.http"),
format!(
"### Health\nGET http://{addr}/health\nAccept: application/json\n\n### Echo\n# @name echo\nGET http://{addr}/echo\n"
),
)
.unwrap();
std::fs::write(h.root.join("http-client.env.json"), r#"{"dev":{"unused":"x"}}"#).unwrap();
let listed = h.json("http_list_requests", json!({"path": "api.http"})).await;
assert_eq!(listed["requests"].as_array().unwrap().len(), 2, "{listed}");
assert_eq!(listed["requests"][0]["index"], 0);
assert_eq!(listed["requests"][0]["name"], "Health");
assert_eq!(listed["requests"][0]["method"], "GET");
assert_eq!(listed["requests"][1]["name"], "echo");
assert!(listed["requests"][0]["url"].as_str().unwrap().contains("/health"));
// Write tool is hidden until the project is trusted.
assert!(Registry::new(h.host.clone()).tools(&h.root).unwrap().iter().all(|t| t.name != "http_run_request"));
h.trust().await;
assert!(
Registry::new(h.host.clone())
.tools(&h.root)
.unwrap()
.iter()
.any(|t| t.name == "http_run_request" && !t.read_only)
);
h.host.mcp_requests.set_ready("main", true);
let denied = h.error("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let deny = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, false, None).unwrap();
};
let (error, ()) = tokio::join!(denied, deny);
assert!(error.contains("denied by the user"), "{error}");
h.events.lock().unwrap().clear();
let run = h.json("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let allow = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, true, None).unwrap();
};
let (result, ()) = tokio::join!(run, allow);
assert_eq!(result["status"], 200, "{result}");
assert_eq!(result["method"], "GET");
assert!(result["body"].as_str().unwrap().contains("ok"), "{result}");
assert_eq!(result["bodyTruncated"], false);
// Secrets must not appear as request headers/body in the tool payload.
assert!(result.get("headers").is_none(), "{result}");
assert!(result.get("request").is_none(), "{result}");
}
+184
Переглянути файл
@@ -0,0 +1,184 @@
//! `[[contributes.serverCommands]]` (plugin API 1.9): a command a language server hands to the
//! client runs the plugin command that claims it. The fixture's command sends its argument
//! back to the server (`mock/ran`), through the real component runtime and `language-servers`.
use ide_host::plugins::{Consent, HostWorkspace, PluginHost, set_editor_providers};
use ide_host::{Host, HostConfig, ops};
use ide_jsonrpc::{Handler, Peer};
use ide_lsp::types::Command;
use ide_plugin::Limits;
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::{path::Path, sync::Arc, time::Duration};
const ID: &str = "test.lsp-requests";
const SECOND: &str = "test.lsp-second";
fn fixture() -> std::path::PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/lsp-requests")
}
/// The fixture under `dir` with `edit` applied to its manifest.
fn variant(dir: &Path, edit: impl Fn(&str) -> String) -> std::path::PathBuf {
fn copy(from: &Path, to: &Path) {
std::fs::create_dir_all(to).unwrap();
for entry in std::fs::read_dir(from).unwrap() {
let entry = entry.unwrap();
match entry.file_type().unwrap().is_dir() {
true if entry.file_name() != "target" => copy(&entry.path(), &to.join(entry.file_name())),
true => {}
false => drop(std::fs::copy(entry.path(), to.join(entry.file_name())).unwrap()),
}
}
}
copy(&fixture(), dir);
let manifest = dir.join("plugin.toml");
std::fs::write(&manifest, edit(&std::fs::read_to_string(&manifest).unwrap())).unwrap();
dir.to_path_buf()
}
/// A language server named `mock`: it executes `mock.own` itself and records what it gets.
#[derive(Default)]
struct Mock {
requests: Mutex<Vec<(String, Value)>>,
notifications: Mutex<Vec<(String, Value)>>,
}
impl Mock {
fn ran(&self) -> Vec<Value> {
self.notifications.lock().iter().filter(|(m, _)| m == "mock/ran").map(|(_, p)| p.clone()).collect()
}
fn executed(&self) -> Vec<Value> {
let requests = self.requests.lock();
requests.iter().filter(|(m, _)| m == "workspace/executeCommand").map(|(_, p)| p["command"].clone()).collect()
}
}
impl Handler for Mock {
fn on_notification(&self, method: &str, p: Value) {
self.notifications.lock().push((method.to_owned(), p));
}
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
self.requests.lock().push((method.to_owned(), p));
Ok(match method {
"initialize" => json!({ "capabilities": {
"textDocumentSync": { "openClose": true, "change": 1 },
"executeCommandProvider": { "commands": ["mock.own"] },
} }),
_ => Value::Null,
})
}
}
async fn eventually(what: &str, mut f: impl FnMut() -> bool) {
for _ in 0..500 {
if f() {
return;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
panic!("timed out waiting for {what}");
}
fn command(name: &str, arguments: Vec<Value>) -> Command {
Command { title: "Lens".into(), command: name.into(), arguments }
}
#[tokio::test(flavor = "multi_thread")]
async fn a_command_the_server_leaves_to_the_client_runs_the_plugin_that_claims_it() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
let host = Arc::new(Host::new(HostConfig {
config_dir: tmp.path().join("config"),
data_dir: tmp.path().join("data"),
local_data_dir: tmp.path().join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(ide_core::NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
}));
// Language servers start only in a trusted project.
host.set_project_trust(&root, true, false).await.unwrap();
host.open_project("main", &root).unwrap();
let plugins = Arc::new(
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
);
plugins.set_workspace(Some(Arc::new(HostWorkspace(Arc::downgrade(&host)))));
set_editor_providers(Some(&plugins));
// The manifest must hold the grant of the server whose commands it claims.
let ungranted = variant(&tmp.path().join("ungranted"), |m| m.replace("optional = [\"lsp:mock\"]", "optional = []"));
let err = plugins.install_from_dir(&ungranted, &Consent::all()).unwrap_err();
assert!(err.message.contains("needs the `lsp:mock` capability"), "{err:?}");
plugins.install_from_dir(&fixture(), &Consent::all()).unwrap();
// The server `mock` serves the project's text files.
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let port = listener.local_addr().unwrap().port();
let mock = Arc::new(Mock::default());
let peers = Arc::new(Mutex::new(Vec::<Peer>::new()));
let (accepted, state) = (peers.clone(), mock.clone());
let server = tokio::spawn(async move {
while let Ok((stream, _)) = listener.accept().await {
let (r, w) = stream.into_split();
accepted.lock().push(Peer::connect(r, w, state.clone()));
}
});
let cfg: ide_language::LanguageServerConfig =
toml::from_str(&format!("name='mock'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
let project = host.project("main").unwrap();
project.lsp.set_servers_hook(Box::new(move |_, _| vec![cfg.clone()]));
let path = root.join("a.txt");
std::fs::write(&path, "class Post {}\n").unwrap();
let doc = ops::doc::open(&host, "main", path.clone()).await.unwrap().id;
project.lsp.did_open(
doc,
&path,
&ide_core::LanguageId::plain_text(),
0,
"class Post {}
",
);
eventually("the server to be ready", || {
project.lsp.servers().iter().any(|s| s.name == "mock" && s.status == ide_core::event::ServerStatus::Ready)
})
.await;
// A lens command the server does not execute: the plugin's command gets the arguments as JSON.
let lens = command("mock.modelView", vec![json!("App\\Models\\Post"), json!({ "line": 3 })]);
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the plugin's command", || !mock.ran().is_empty()).await;
assert_eq!(mock.ran(), [json!(["App\\Models\\Post", { "line": 3 }])]);
assert!(mock.executed().is_empty(), "the server was not asked to execute it");
// A command in the server's `executeCommandProvider` still goes to the server.
ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.own", vec![])).await.unwrap();
assert_eq!(mock.executed(), [json!("mock.own")]);
assert_eq!(mock.ran().len(), 1);
// A command nobody claims fails as before.
let err = ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.unclaimed", vec![])).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
// Two plugins claim the same server and command: the first one loaded keeps it.
let second = variant(&tmp.path().join("second"), |m| m.replace(ID, SECOND));
plugins.install_from_dir(&second, &Consent::all()).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the first plugin's command again", || mock.ran().len() == 2).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 0, "the second plugin never ran");
// A claim counts only while the plugin holds the server's grant.
plugins.set_capability(ID, "lsp:mock", false).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the second plugin's command", || mock.ran().len() == 3).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 1);
plugins.set_capability(SECOND, "lsp:mock", false).unwrap();
let err = ops::lsp::lsp_execute_command(&host, "main", doc, lens).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
assert_eq!(mock.ran().len(), 3);
set_editor_providers(None);
server.abort();
}
+18 -14
Переглянути файл
@@ -70,10 +70,14 @@ async fn open(fixture: &str) -> Opened {
}
/// Polls `check` until it holds; fails with its last answer.
async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: impl FnMut() -> Result<(), T>) {
async fn until<T: std::fmt::Debug, F, Fut>(what: &str, timeout: Duration, mut check: F)
where
F: FnMut() -> Fut,
Fut: std::future::Future<Output = Result<(), T>>,
{
let deadline = Instant::now() + timeout;
loop {
match check() {
match check().await {
Ok(()) => return,
Err(last) if Instant::now() > deadline => panic!("{what}: timed out after {timeout:?}; last: {last:?}"),
Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,
@@ -82,25 +86,25 @@ async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: imp
}
impl Opened {
fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).unwrap();
async fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).await.unwrap();
found.into_iter().map(|f| f.rel_path).collect()
}
fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).unwrap();
async fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).await.unwrap();
found.into_iter().map(|s| (s.name, s.rel_path)).collect()
}
fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter);
async fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter).await;
if found.iter().any(|(n, f)| n == name && f == file) { Ok(()) } else { Err(found) }
}
}
async fn smoke(f: Fixture) {
let p = open(f.dir).await;
until("indexing", Duration::from_secs(30), || {
until("indexing", Duration::from_secs(30), || async {
let s = ops::nav::index_status(&p.host, WINDOW).unwrap();
if !s.indexing && s.files > 0 && s.symbols > 0 { Ok(()) } else { Err(s) }
})
@@ -115,12 +119,12 @@ async fn smoke(f: Fixture) {
);
}
let files = p.files(f.file.0);
let files = p.files(f.file.0).await;
assert!(files.iter().any(|r| r == f.file.1), "{}: files for {:?}: {files:?}", f.dir, f.file.0);
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types) {
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types).await {
panic!("{}: Go to Class {:?}: {found:?}", f.dir, f.class.0);
}
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All) {
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All).await {
panic!("{}: Go to Symbol {:?}: {found:?}", f.dir, f.symbol.0);
}
@@ -130,8 +134,8 @@ async fn smoke(f: Fixture) {
until("a new file's class", Duration::from_secs(20), || p.has_symbol("FreshWidget", added, SymbolFilter::Types))
.await;
std::fs::remove_file(p.root.join(added)).unwrap();
until("a deleted file's class", Duration::from_secs(20), || {
let found = p.symbols("FreshWidget", SymbolFilter::Types);
until("a deleted file's class", Duration::from_secs(20), || async {
let found = p.symbols("FreshWidget", SymbolFilter::Types).await;
if found.is_empty() { Ok(()) } else { Err(found) }
})
.await;
+10 -2
Переглянути файл
@@ -646,8 +646,16 @@ impl IndexData {
}
}
pub(crate) fn record_of(&self, path: &Path) -> Option<FileRecord> {
self.get(path).map(|e| self.record(e))
/// Refreshes on-disk metadata of an unchanged-content file in place and
/// returns its persisted record.
pub(crate) fn refresh_metadata(&mut self, path: &Path, mtime: u64, size: u64, ignored: bool) -> Option<FileRecord> {
let slot = *self.by_path.get(path)?;
let e = self.files[slot as usize].as_mut()?;
e.mtime = mtime;
e.size = size;
e.ignored = ignored;
let e = self.files[slot as usize].as_ref()?;
Some(self.record(e))
}
/// The symbols of one file, in declaration order.
+5
Переглянути файл
@@ -323,6 +323,11 @@ impl ProjectIndex {
matching::symbols_named_within(&self.shared.data.read(), name, kind, roots, limit)
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per name.
pub fn symbols_named_any(&self, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
matching::symbols_named_any(&self.shared.data.read(), names, root, limit)
}
/// Incrementally re-indexes changed paths (called from the vfs watcher).
/// Cheap: the work is queued for the indexing thread.
pub fn update(&self, changed: &[PathBuf], removed: &[PathBuf]) {
+35
Переглянути файл
@@ -632,6 +632,41 @@ pub(crate) fn symbols_named_within(
out
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per
/// name, by path then position: one walk over the index for every name an agent reply shows.
pub(crate) fn symbols_named_any(data: &IndexData, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
let wanted: Vec<(u64, &str)> = names.iter().map(|name| (char_mask(name), name.as_str())).collect();
let syms = &data.syms;
let mut out: Vec<SymbolMatch> = data
.files
.iter()
.flatten()
.filter(|entry| entry.path.starts_with(root))
.flat_map(|entry| {
(entry.sym_start..entry.sym_start + entry.sym_len)
.filter(|&at| wanted.iter().any(|&(mask, name)| syms.mask(at) == mask && syms.name(at) == name))
.map(move |at| SymbolMatch {
name: syms.name(at).to_string(),
kind: syms.kind(at),
container: syms.container(at).map(str::to_owned),
path: entry.path.clone().into(),
rel_path: entry.rel.to_string(),
range: syms.range(at),
score: 0,
indices: Vec::new(),
})
})
.collect();
out.sort_by(|left, right| left.rel_path.cmp(&right.rel_path).then_with(|| left.range.cmp(&right.range)));
let mut kept: HashMap<String, usize> = HashMap::new();
out.retain(|symbol| {
let count = kept.entry(symbol.name.clone()).or_default();
*count += 1;
*count <= limit
});
out
}
#[cfg(test)]
mod tests {
use super::*;
+100
Переглянути файл
@@ -549,6 +549,24 @@ fn symbols_named_within_keeps_out_of_root_matches_from_evicting_a_root() {
assert!(idx.symbols_named_within("Decoder", None, &[f.root.join("none")], 3).is_empty());
}
#[test]
fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
let fixture = Fixture::new(&[
("app/a.rs", "struct Config;\nfn load() {}\nfn load_all() {}\n"),
("app/b.rs", "fn load() {}\nfn load() {}\n"),
("other/c.rs", "struct Config;\n"),
]);
let idx = fixture.open();
let names = ["Config".to_string(), "load".to_string(), "missing".to_string()];
let found: Vec<(String, String)> = idx
.symbols_named_any(&names, &fixture.root.join("app"), 2)
.into_iter()
.map(|symbol| (symbol.name, symbol.rel_path))
.collect();
let expected = [("Config", "app/a.rs"), ("load", "app/a.rs"), ("load", "app/b.rs")];
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
}
#[test]
fn content_roots_and_excludes_change_without_reopening() {
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
@@ -967,3 +985,85 @@ fn warm_start_sees_edits_deletions_and_renames_made_while_closed() {
assert_eq!(idx.status().files, 3);
assert_eq!(symbols(&idx, "zzzz", SymbolFilter::All), ["zzzz"]);
}
#[test]
fn queries_during_streaming_scan_do_not_deadlock() {
// More than `2 * SCAN_BATCH` (4,096) files so a scan both flushes mid-pass
// (`publish` -> `data.write()`) and fills the bounded parse channel while
// concurrent queries hold `data.read()` and dispatch onto Rayon.
const FILES: usize = 4_600;
let f = Fixture::new(&[]);
for m in 0..32 {
std::fs::create_dir_all(f.root.join(format!("mod{m}"))).unwrap();
}
for i in 0..FILES {
std::fs::write(
f.root.join(format!("mod{}/File{i}.rs", i % 32)),
format!("pub struct Type{i};\npub fn sym{i}() {{}}\n"),
)
.unwrap();
}
let (done_tx, done_rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let languages = Arc::new(LanguageRegistry::load(None).unwrap());
let syntax = Arc::new(Syntax::new());
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let idx =
ProjectIndex::open(&f.root, &f.cache, Vec::new(), vec![], languages, syntax, Arc::new(NullSink)).unwrap();
let readers: Vec<_> = (0..4usize)
.map(|r| {
let idx = idx.clone();
let stop = stop.clone();
std::thread::spawn(move || {
let mut n = r;
while !stop.load(Ordering::Relaxed) {
match n % 3 {
0 => {
let _ = idx.find_files("File1", 20);
}
1 => {
let _ = idx.find_dirs("mod", 20);
}
_ => {
let _ = idx.find_symbols("sym1", SymbolFilter::All, 20);
}
}
n = n.wrapping_add(1);
}
})
})
.collect();
assert!(idx.wait_idle(WAIT), "initial streaming scan did not finish");
let parsed_before = idx.shared.parsed.load(Ordering::SeqCst);
assert_eq!(parsed_before, FILES);
// Touch every file without changing its contents so `parse_found` takes
// the `Extracted::Unchanged` path across multiple `SCAN_BATCH` flushes.
let bumped = std::fs::FileTimes::new().set_modified(std::time::SystemTime::now() + Duration::from_secs(10));
for i in 0..FILES {
let path = f.root.join(format!("mod{}/File{i}.rs", i % 32));
std::fs::File::options().write(true).open(path).unwrap().set_times(bumped).unwrap();
}
idx.shared.enqueue(Job::Rescan);
assert!(idx.wait_idle(WAIT), "rescan of unchanged-content files did not finish");
assert_eq!(idx.shared.parsed.load(Ordering::SeqCst), parsed_before, "unchanged content is not re-parsed");
assert_eq!(symbols(&idx, "sym4599", SymbolFilter::All), ["sym4599"]);
stop.store(true, Ordering::Relaxed);
for h in readers {
h.join().unwrap();
}
assert_eq!(idx.status().files, FILES as u32);
drop(idx);
let reopened = f.open();
assert_eq!(reopened.shared.parsed.load(Ordering::SeqCst), 0);
assert_eq!(symbols(&reopened, "sym4599", SymbolFilter::All), ["sym4599"]);
let _ = done_tx.send(());
});
done_rx.recv_timeout(Duration::from_secs(60)).expect("concurrent index queries deadlocked with streaming scan");
}
+146 -81
Переглянути файл
@@ -11,9 +11,21 @@ use rayon::prelude::*;
use std::collections::{HashMap, HashSet, VecDeque};
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::LazyLock;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant, SystemTime};
/// Dedicated pool for background indexing and snapshot hydration: queries hold
/// `IndexData::read` while scanning on the global Rayon pool, so indexing work
/// (which may block on channel backpressure while the index thread waits for
/// `IndexData::write`) must never compete for the same workers.
static INDEX_POOL: LazyLock<rayon::ThreadPool> = LazyLock::new(|| {
rayon::ThreadPoolBuilder::new()
.thread_name(|i| format!("openidea-index-{i}"))
.build()
.expect("cannot build index thread pool")
});
/// Files larger than this are listed but not parsed for symbols.
pub const MAX_SYMBOL_FILE: u64 = 2 * 1024 * 1024;
const CHUNK: usize = 512;
@@ -254,17 +266,19 @@ impl Shared {
}
}
let build_started = Instant::now();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = (0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect()
});
let built = build_started.elapsed();
if entries.iter().any(Option::is_none) {
return false;
@@ -333,17 +347,19 @@ impl Shared {
let started = Instant::now();
match store.load_snapshot() {
Some(snapshot) => {
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = (0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect();
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect()
});
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -363,16 +379,18 @@ impl Shared {
Ok(records) => {
// Fallback for an index that changed since the snapshot: redb
// records are decoded one file at a time and filtered by the walk.
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect();
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect()
});
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -446,10 +464,11 @@ impl Shared {
}
let classify_started = Instant::now();
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
let (todo, stale) = {
let d = self.data.read();
let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
let stale = d
let todo: Vec<(&Found, Option<ContentHash>)> =
found.iter().filter_map(|f| prev_hash_if_stale(&d, f).map(|h| (f, h))).collect();
let stale: Vec<PathBuf> = d
.paths()
.filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
.filter(|p| !seen.contains(p.as_path()))
@@ -470,7 +489,7 @@ impl Shared {
let total = todo.len();
let mut laps = ChunkLaps::default();
{
// One streaming parallel pass: parse on the rayon pool without
// One streaming parallel pass: parse on `INDEX_POOL` without
// per-chunk joins (a straggler file at a join's tail idles every
// other core), while parsed files flow to this thread to be
// inserted and persisted in batches. `filter` moves into the
@@ -485,12 +504,14 @@ impl Shared {
let pass_started = Instant::now();
std::thread::scope(|scope| -> () {
scope.spawn(move || {
todo.par_iter().for_each(|f| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, &filter, false) else { return };
let _ = tx.send(out);
INDEX_POOL.install(|| {
todo.par_iter().for_each(|&(f, prev_hash)| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, prev_hash, &filter) else { return };
let _ = tx.send(out);
});
});
// `tx` drops here: the consumer's loop ends with the channel.
});
@@ -570,13 +591,13 @@ impl Shared {
}
/// Extracts records in parallel, then publishes them to memory and disk.
/// `force` re-parses files whose content is unchanged (their language changed).
fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) -> ChunkLaps {
fn index_files(&self, files: &[(Found, Option<ContentHash>)]) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let files: Vec<&Found> = files.collect();
let filter = self.filter();
let started = Instant::now();
let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
let extracted: Vec<ParsedFile> = INDEX_POOL.install(|| {
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
});
laps.extract = started.elapsed();
if extracted.is_empty() {
return laps;
@@ -585,49 +606,69 @@ impl Shared {
laps
}
/// Reads and parses one file (parallel-safe), serializing its record for
/// the cache alongside the parse. `None` when the file is outside the
/// scope or the scan was cancelled.
fn parse_found(&self, f: &Found, filter: &std::sync::Arc<PathFilter>, force: bool) -> Option<ParsedFile> {
/// Reads and parses one file on `INDEX_POOL` without locking `self.data`,
/// serializing new records for the cache alongside the parse. `None` when
/// the file is outside the scope or the scan was cancelled.
fn parse_found(
&self,
f: &Found,
prev_hash: Option<ContentHash>,
filter: &std::sync::Arc<PathFilter>,
) -> Option<ParsedFile> {
if self.is_cancelled() {
return None;
}
let rel = filter.rel(&f.path)?;
let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
let rec = match self.extract(f, prev_hash) {
Extracted::Unchanged => {
// Same content, new mtime: keep the symbols, refresh metadata.
let mut rec = self.data.read().record_of(&f.path)?;
rec.mtime = f.mtime;
rec.size = f.size;
rec.ignored = f.ignored;
rec
}
Extracted::New(rec) => rec,
};
let key = filter.store_key(&f.path);
let bytes = postcard::to_allocvec(&rec).ok();
Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
let outcome = match self.extract(f, prev_hash) {
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
Extracted::New(rec) => {
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
ParsedOutcome::New { rec, bytes }
}
};
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
}
/// Inserts a parsed batch into the in-memory index and persists the records.
fn publish(&self, batch: impl Iterator<Item = ParsedFile>) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let started = Instant::now();
let mut entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut inserts: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut refreshes: Vec<MetadataRefresh> = Vec::new();
let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
for out in batch {
let ParsedFile { rel, rec, key, bytes, path } = out;
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
let ParsedFile { rel, key, outcome, path } = out;
match outcome {
ParsedOutcome::New { rec, bytes } => {
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
}
inserts.push(FileEntry::new(path, rel, rec));
}
ParsedOutcome::Unchanged { mtime, size, ignored } => {
refreshes.push(MetadataRefresh { path, key, mtime, size, ignored });
}
}
entries.push(FileEntry::new(path, rel, rec));
}
let mut refreshed_records: Vec<(String, FileRecord)> = Vec::new();
{
let mut d = self.data.write();
for (e, symbols) in entries {
for (e, symbols) in inserts {
d.insert(e, symbols);
}
for r in refreshes {
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
&& let Some(key) = r.key
{
refreshed_records.push((key, rec));
}
}
}
for (key, rec) in refreshed_records {
if let Ok(bytes) = postcard::to_allocvec(&rec) {
puts.push((key, bytes));
}
}
laps.insert = started.elapsed();
let started = Instant::now();
@@ -818,9 +859,9 @@ impl Shared {
for (dir, wanted) in by_dir {
files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));
}
let files: Vec<Found> = {
let files: Vec<(Found, Option<ContentHash>)> = {
let d = self.data.read();
files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
files.into_iter().filter_map(|f| prev_hash_if_stale(&d, &f).map(|h| (f, h))).collect()
};
if !files.is_empty() {
touched = true;
@@ -828,17 +869,17 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), false);
self.index_files(chunk);
}
}
for before in reparse {
let affected: Vec<Found> = {
let affected: Vec<(Found, Option<ContentHash>)> = {
let d = self.data.read();
d.paths()
.filter(|p| before.detect(p, None) != self.languages.detect(p, None))
.filter_map(|p| {
let e = d.get(p)?;
Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })
Some((Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, None))
})
.collect()
};
@@ -848,7 +889,7 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), true);
self.index_files(chunk);
}
}
}
@@ -866,6 +907,18 @@ impl Shared {
}
}
type ContentHash = [u8; 32];
/// `Some(prev_hash)` when `f` is missing or stale in `d` (`None` inner hash when
/// the file must be parsed fresh); `None` when `d` is already current for `f`.
fn prev_hash_if_stale(d: &IndexData, f: &Found) -> Option<Option<ContentHash>> {
match d.get(&f.path) {
None => Some(None),
Some(e) if e.stale_for(f) => Some((!e.ignored).then_some(e.hash)),
Some(_) => None,
}
}
/// The first line, capped at 256 bytes (for shebang / `<?xml` detection).
fn first_line(text: &str) -> &str {
let line = text.lines().next().unwrap_or_default();
@@ -898,14 +951,26 @@ impl ChunkLaps {
}
}
/// One file parsed off the index thread: its record ready to publish, already
/// serialized for the cache (in parallel with the parse).
struct MetadataRefresh {
path: PathBuf,
key: Option<String>,
mtime: u64,
size: u64,
ignored: bool,
}
enum ParsedOutcome {
Unchanged { mtime: u64, size: u64, ignored: bool },
New { rec: FileRecord, bytes: Option<Vec<u8>> },
}
/// One file parsed off the index thread: its outcome ready to publish, with new
/// records already serialized for the cache in parallel with the parse.
struct ParsedFile {
rel: String,
rec: FileRecord,
/// Cache key and postcard bytes; `None` when outside the persisted root.
/// Cache key; `None` when outside the persisted root.
key: Option<String>,
bytes: Option<Vec<u8>>,
outcome: ParsedOutcome,
path: PathBuf,
}
+3
Переглянути файл
@@ -194,6 +194,9 @@ pub mod codes {
pub const METHOD_NOT_FOUND: i64 = -32601;
pub const INVALID_PARAMS: i64 = -32602;
pub const INTERNAL_ERROR: i64 = -32603;
/// LSP `RequestFailed`: the request was understood and could not be carried out; the
/// message says why.
pub const REQUEST_FAILED: i64 = -32803;
/// LSP `ServerCancelled`.
pub const SERVER_CANCELLED: i64 = -32802;
/// LSP `ContentModified`.
+8 -1
Переглянути файл
@@ -1,5 +1,6 @@
//! Pull Members Up / Push Members Down through the app-owned JDT extension
//! (`java/java-usages`). The server checks the move and computes the edit; the UI
//! (`java/java-usages`), or through Phoxite's own requests when the document's
//! server advertises them (`crate::phoxite`). The server checks the move and computes the edit; the UI
//! shows its problems and applies the edit itself.
use super::COMMAND_TIMEOUT;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
@@ -75,6 +76,9 @@ impl LspManager {
kind: HierarchyRefactoring,
cancel: CancellationToken,
) -> IdeResult<HierarchyMembers> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_members(&phoxite, pos, kind, &cancel).await;
}
let (members, _, _) = self.hierarchy_command(doc, pos, kind, MEMBERS, &[], &cancel).await?;
Ok(members)
}
@@ -89,6 +93,9 @@ impl LspManager {
choices: Vec<HierarchyChoice>,
cancel: CancellationToken,
) -> IdeResult<HierarchyRefactored> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_refactor(&phoxite, pos, kind, target, &choices, &cancel).await;
}
let choices: Vec<Value> = choices.iter().map(|c| json!({ "id": c.id, "abstract": c.make_abstract })).collect();
let (refactored, _, t): (Refactored, _, _) =
self.hierarchy_command(doc, pos, kind, REFACTOR, &[json!(target), json!(choices)], &cancel).await?;
+1
Переглянути файл
@@ -26,6 +26,7 @@ mod launch;
mod library_source;
mod loading;
mod notebook;
mod phoxite;
mod plugin_requests;
mod pull;
mod scope;
+97
Переглянути файл
@@ -0,0 +1,97 @@
//! Pull Members Up / Push Members Down through Phoxite's own requests
//! (`phoxite/refactor/hierarchyMembers` and `phoxite/refactor/hierarchy`). A server says it
//! answers them with `experimental.phoxite.refactor` in its capabilities, so the server is
//! found by what it advertises, not by its name. As with the JDT extension, the server
//! checks the move and computes the edit; the UI shows its problems and applies the edit.
use crate::caps::ServerCaps;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
use crate::{DocSnap, LspManager, Target, convert, rpc_err};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
use ide_jsonrpc::RpcError;
use serde::Deserialize;
use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::time::Duration;
const MEMBERS: &str = "phoxite/refactor/hierarchyMembers";
const REFACTOR: &str = "phoxite/refactor/hierarchy";
/// The move is computed over the whole project.
const TIMEOUT: Duration = Duration::from_secs(120);
#[derive(Deserialize)]
struct Refactored {
problems: Vec<RefactoringProblem>,
edit: Option<lsp_types::WorkspaceEdit>,
}
/// Whether the server answers the `phoxite/refactor/*` requests.
fn refactors(caps: &ServerCaps) -> bool {
caps.raw.pointer("/experimental/phoxite/refactor").and_then(Value::as_bool) == Some(true)
}
impl LspManager {
/// The server of `doc` that answers `phoxite/refactor/*`, when one is attached.
pub(crate) async fn phoxite_refactor_target(&self, doc: DocId) -> Option<(DocSnap, Target)> {
let (snap, mut targets) = self.doc_targets(doc, "refactorings", refactors).await.ok()?;
Some((snap, targets.swap_remove(0)))
}
/// Sends one of the hierarchy requests. The server refuses a position it can't
/// refactor with LSP's `RequestFailed` and a message for the user: that is invalid
/// input, as the JDT extension's `refused` is. Any other error is the server failing.
async fn phoxite_hierarchy<R: DeserializeOwned>(
&self,
(snap, t): &(DocSnap, Target),
method: &str,
pos: Pos,
kind: HierarchyRefactoring,
extra: Value,
cancel: &CancellationToken,
) -> IdeResult<R> {
let mut params = json!({ "uri": snap.uri, "position": snap.position(t, pos), "kind": kind });
if let (Some(params), Value::Object(extra)) = (params.as_object_mut(), extra) {
params.extend(extra);
}
let request = t.run.peer.request::<Value, Value>(method, params, Some(cancel.clone()));
let answer = match tokio::time::timeout(TIMEOUT, request).await {
Ok(Ok(value)) => value,
Ok(Err(RpcError::Server { code, message, .. })) if code == ide_jsonrpc::codes::REQUEST_FAILED => {
return Err(IdeError::invalid(message));
}
Ok(Err(e)) => return Err(rpc_err(&t.server.name, method, e)),
Err(_) => return Err(rpc_err(&t.server.name, method, RpcError::Timeout)),
};
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
serde_json::from_value(answer).map_err(|e| rpc_err(&t.server.name, method, RpcError::Protocol(e.to_string())))
}
pub(crate) async fn phoxite_hierarchy_members(
&self,
target: &(DocSnap, Target),
pos: Pos,
kind: HierarchyRefactoring,
cancel: &CancellationToken,
) -> IdeResult<HierarchyMembers> {
self.phoxite_hierarchy(target, MEMBERS, pos, kind, Value::Null, cancel).await
}
pub(crate) async fn phoxite_hierarchy_refactor(
&self,
target: &(DocSnap, Target),
pos: Pos,
kind: HierarchyRefactoring,
destination: Option<String>,
choices: &[HierarchyChoice],
cancel: &CancellationToken,
) -> IdeResult<HierarchyRefactored> {
let extra = json!({ "target": destination, "choices": choices });
let refactored: Refactored = self.phoxite_hierarchy(target, REFACTOR, pos, kind, extra, cancel).await?;
let conv = self.conv(target.1.enc());
Ok(HierarchyRefactored {
problems: refactored.problems,
edit: refactored.edit.map(|e| convert::workspace_edit(&conv, e)),
})
}
}
+10
Переглянути файл
@@ -57,6 +57,16 @@ impl LspManager {
Ok(running.swap_remove(at))
}
/// Names (in the language definition) of the servers attached to `doc`, or of every
/// server of the project when the document is not open; only `server`'s when given.
pub fn server_names(&self, doc: ide_core::DocId, server: Option<ide_core::ServerId>) -> Vec<String> {
let servers = match self.snapshot(doc) {
Ok(snap) => snap.servers,
Err(_) => self.servers.lock().clone(),
};
servers.iter().filter(|s| server.is_none_or(|id| s.id == id)).map(|s| s.name.clone()).collect()
}
/// Sends a plugin's request to the running server named `server` (its name in the
/// language definition) and returns the result. `not_found` when it is not running,
/// `invalid` for a method that is not the server's own.
+88
Переглянути файл
@@ -7429,3 +7429,91 @@ async fn a_plugin_request_reaches_only_a_running_servers_own_methods() {
let e = h.mgr.server_request(&h.root, "main", "mock/routes", None, &cancel, timeout).await.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::Cancelled);
}
/// A server that advertises `experimental.phoxite.refactor` gets Pull Members Up / Push
/// Members Down as its own `phoxite/refactor/*` requests, whatever its name.
#[tokio::test(flavor = "multi_thread")]
async fn hierarchy_refactorings_use_phoxites_requests_when_the_server_advertises_them() {
let mut caps = incremental_caps();
caps["experimental"] = json!({ "phoxite": { "laravel": true, "refactor": true } });
let h = harness_for("php", "php", &[("any-name", caps)], &[]);
let s = h.launcher.state("any-name");
*s.responder.lock() = Some(Arc::new(|_, method, params| {
let uri = params["uri"].clone();
match (method, params["position"]["line"].as_u64()) {
("phoxite/refactor/hierarchyMembers", Some(0)) => Some(json!({
"className": "Dog",
"targets": [{ "id": "App\\Animal", "name": "Animal", "qualifiedName": "App\\Animal", "interface": false }],
"members": [
{ "id": "method:bark", "label": "bark(): string", "kind": "method", "selected": true, "abstractable": true },
{ "id": "constant:LEGS", "label": "LEGS", "kind": "field", "selected": false, "abstractable": false },
],
})),
("phoxite/refactor/hierarchy", _) => Some(json!({
"problems": [{ "severity": "warning", "message": "bark() uses $tail, which stays in Dog" }],
"edit": { "changes": { uri.as_str().unwrap(): [
{ "range": { "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 5 } }, "newText": "<?php" }
] } },
})),
_ => None,
}
}));
let text =
format!("<?php class Dog extends Animal {{ function bark(): string {{ return ''; }} }}{}", "\n".repeat(9));
let (doc, path) = h.open("Dog.php", &text);
h.wait_status("any-name", ServerStatus::Ready).await;
eventually(|| s.docs.lock().len() == 1).await;
let info =
h.mgr.hierarchy_members(doc, Pos::new(0, 40), HierarchyRefactoring::PullUp, Default::default()).await.unwrap();
assert_eq!((info.class_name.as_str(), info.targets[0].qualified_name.as_str()), ("Dog", "App\\Animal"));
assert!(info.members[0].selected && info.members[0].abstractable);
assert_eq!(
info.members.iter().map(|m| m.kind).collect::<Vec<_>>(),
[HierarchyMemberKind::Method, HierarchyMemberKind::Field]
);
assert_eq!(
s.requested("phoxite/refactor/hierarchyMembers"),
[json!({ "uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp" })]
);
let choices = vec![HierarchyChoice { id: "method:bark".into(), make_abstract: true }];
let done = h
.mgr
.hierarchy_refactor(
doc,
Pos::new(0, 40),
HierarchyRefactoring::PullUp,
Some("App\\Animal".into()),
choices,
Default::default(),
)
.await
.unwrap();
assert_eq!(done.problems[0].severity, ProblemSeverity::Warning);
let edit = done.edit.unwrap();
assert!(matches!(&edit.files[..], [FileEdit::Edit { path: p, edits, .. }] if p == &path && edits.len() == 1));
assert_eq!(
s.requested("phoxite/refactor/hierarchy"),
[json!({
"uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp",
"target": "App\\Animal", "choices": [{ "id": "method:bark", "makeAbstract": true }],
})]
);
assert!(s.requested("workspace/executeCommand").is_empty(), "not the JDT extension's commands");
// The server refuses a position with `RequestFailed` and a message for the user.
let refusal = (-32803, "'Dog' has no parent class or interface in the project".to_owned());
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), refusal);
let refused = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let e = refused.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::InvalidInput);
assert_eq!(e.message, "'Dog' has no parent class or interface in the project");
// Any other error is the server failing, not a reason to show as the user's mistake.
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), (-32603, "index out of bounds".to_owned()));
let failed = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let e = failed.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::Protocol);
assert_eq!(e.message, "any-name: index out of bounds");
}
+79
Переглянути файл
@@ -1022,3 +1022,82 @@ async fn basedpyright_and_ruff_serve_notebook_cells() {
mgr.close_notebook(&path);
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
}
/// Pull Members Up through Phoxite's own requests: the real server moves a method to
/// the parent class in another file.
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires phoxite-lsp on PATH (or OPENIDEA_TEST_PHOXITE_LSP)"]
async fn phoxite_pulls_a_member_up_end_to_end() {
use ide_core::FileEdit;
use ide_lsp::types::{HierarchyChoice, HierarchyRefactoring};
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
std::fs::create_dir(root.join("src")).unwrap();
std::fs::write(root.join("composer.json"), r#"{"autoload":{"psr-4":{"App\\":"src/"}}}"#).unwrap();
let animal = root.join("src").join("Animal.php");
std::fs::write(&animal, "<?php\n\nnamespace App;\n\nclass Animal\n{\n}\n").unwrap();
let path = root.join("src").join("Dog.php");
let source = "<?php\n\nnamespace App;\n\nclass Dog extends Animal\n{\n public function bark(): string\n {\n return 'woof';\n }\n}\n";
std::fs::write(&path, source).unwrap();
let mut php = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("php")).unwrap();
php.language_servers.retain(|s| s.name == "phoxite");
assert_eq!(php.language_servers.len(), 1);
php.language_servers[0].fallback = false;
if let Ok(bin) = std::env::var("OPENIDEA_TEST_PHOXITE_LSP") {
php.language_servers[0].command = bin;
}
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![php]));
let doc = DocId::next();
mgr.did_open(doc, &path, &LanguageId::new("php"), 1, source);
retry("phoxite ready", Duration::from_secs(30), || {
let status = last_status(&events, "phoxite");
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
panic!("phoxite failed: {msg:?}");
}
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
})
.await;
// On `bark`; the parent is known once the project is indexed.
let at = Pos::new(6, 22);
let info = retry("the movable members", Duration::from_secs(60), || {
let mgr = mgr.clone();
async move { mgr.hierarchy_members(doc, at, HierarchyRefactoring::PullUp, Default::default()).await.ok() }
})
.await;
assert_eq!(info.class_name, "Dog");
assert_eq!(
info.targets.iter().map(|t| t.qualified_name.trim_start_matches('\\')).collect::<Vec<_>>(),
["App\\Animal"]
);
let bark = info.members.iter().find(|m| m.label.starts_with("bark")).expect("bark is movable");
assert!(bark.selected, "{bark:?}");
let choices = vec![HierarchyChoice { id: bark.id.clone(), make_abstract: false }];
let done = mgr
.hierarchy_refactor(
doc,
at,
HierarchyRefactoring::PullUp,
Some(info.targets[0].id.clone()),
choices,
Default::default(),
)
.await
.unwrap();
let edit = done.edit.expect("an edit");
let mut edited: Vec<_> = edit
.files
.iter()
.filter_map(|f| match f {
FileEdit::Edit { path, edits, .. } if !edits.is_empty() => path.0.file_name()?.to_str().map(str::to_owned),
_ => None,
})
.collect();
edited.sort();
assert_eq!(edited, ["Animal.php", "Dog.php"], "the method leaves Dog and arrives in Animal");
// Outside any class the server refuses with `RequestFailed`: the reason reaches the user.
let refused = mgr.hierarchy_members(doc, Pos::new(0, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let refused = refused.unwrap_err();
assert_eq!(refused.kind, ide_core::error::ErrorKind::InvalidInput, "{refused:?}");
assert!(!refused.message.is_empty() && !refused.message.starts_with("phoxite:"), "{refused:?}");
mgr.shutdown_all().await;
}
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
4788f82b35966e155dbf51af520acb2d5e7773ddf9f36f4239b9bd51d51b0fb3
6a36bd56db7148032c1fe101bec8c38e326528b1de1ee26b5d7c5b9dd80b3e94
+10
Переглянути файл
@@ -22,3 +22,13 @@ title = "Send a method of LSP itself"
[[contributes.commands]]
id = "ungranted"
title = "Ask a server the manifest does not name"
[[contributes.commands]]
id = "ran"
title = "Run a command the mock server left to the client"
# The mock server's code lenses carry `mock.modelView` without executing it.
[[contributes.serverCommands]]
server = "mock"
command = "mock.modelView"
run = "ran"
+2
Переглянути файл
@@ -10,6 +10,8 @@ impl Plugin for LspRequests {
"request" => project.language_server_request("mock", "mock/routes", arg).map(Some),
"notify" => project.language_server_notify("mock", "mock/changed", arg).map(|()| None),
"standard" => project.language_server_request("mock", "textDocument/hover", arg).map(Some),
// Shows the server what arrived: the arguments of the command it handed to the client.
"ran" => project.language_server_notify("mock", "mock/ran", arg).map(|()| None),
"ungranted" => project.language_server_request("other", "other/status", arg).map(Some),
_ => Err(Error::NotFound(id.into())),
}
+15
Переглянути файл
@@ -33,6 +33,7 @@ pub(crate) fn virtual_env_marker(dir: &Path) -> Option<&'static str> {
/// Build files whose changes can change the detected roots.
pub(crate) const BUILD_FILES: &[&str] = &[
"pom.xml",
".classpath",
"build.gradle",
"build.gradle.kts",
"settings.gradle",
@@ -238,6 +239,20 @@ fn module_roots(root: &Path, rel: &str, files: &[String], out: &mut Vec<SourceFo
}
}
// An Eclipse project without Maven or Gradle: its `.classpath` is the source model.
if has(".classpath")
&& !has("pom.xml")
&& !GRADLE_FILES.iter().any(|f| has(f))
&& let Some(cp) = super::eclipse::classpath(&dir)
{
for (sub, test) in &cp.sources {
add(sub, if *test { RootKind::Test } else { RootKind::Source }, ".classpath");
}
if let Some(output) = &cp.output {
add(output, RootKind::Excluded, ".classpath");
}
}
// Before `package.json`: a Laravel app's `tests/` is the PHP test root.
if has("composer.json")
&& let Ok(text) = std::fs::read_to_string(dir.join("composer.json"))
+193
Переглянути файл
@@ -0,0 +1,193 @@
//! Eclipse projects without Maven or Gradle: `.classpath` names the source folders (tests
//! by their `test` attribute), the output folder and the library jars; a Dynamic Web
//! Project's `.settings/org.eclipse.wst.common.component` names the web content folder.
use std::path::Path;
/// What `.classpath` declares, with project-relative `/`-separated paths.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct EclipseClasspath {
/// Source folders and whether they hold tests.
pub sources: Vec<(String, bool)>,
pub output: Option<String>,
/// Library jars or class folders (`kind="lib"`), project-relative or absolute.
pub libraries: Vec<String>,
}
/// The value of `name="…"` in a tag's text.
fn attribute(tag: &str, name: &str) -> Option<String> {
let mut rest = tag;
while let Some(at) = rest.find(name) {
let before = rest[..at].chars().last();
let after = &rest[at + name.len()..];
rest = after;
if before.is_some_and(|c| !c.is_whitespace()) {
continue;
}
let Some(after) = after.trim_start().strip_prefix('=') else { continue };
let after = after.trim_start();
let quote = after.chars().next().filter(|c| *c == '"' || *c == '\'')?;
let value = &after[1..];
let end = value.find(quote)?;
return Some(unescape(&value[..end]));
}
None
}
fn unescape(value: &str) -> String {
value.replace("&quot;", "\"").replace("&apos;", "'").replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
}
/// Each element `<name …>…</name>` or `<name …/>` as (opening tag, inner text).
fn elements<'a>(text: &'a str, name: &str) -> Vec<(&'a str, &'a str)> {
let open = format!("<{name}");
let close = format!("</{name}>");
let mut out = Vec::new();
let mut rest = text;
while let Some(at) = rest.find(&open) {
let from = &rest[at..];
// `<classpathentry` must not match `<classpathentryX`.
if !from[open.len()..].starts_with(|c: char| c.is_whitespace() || c == '/' || c == '>') {
rest = &from[open.len()..];
continue;
}
let Some(end) = from.find('>') else { break };
let tag = &from[..=end];
if tag.ends_with("/>") {
out.push((tag, ""));
rest = &from[end + 1..];
} else {
let body = &from[end + 1..];
let stop = body.find(&close).unwrap_or(body.len());
out.push((tag, &body[..stop]));
rest = &body[stop..];
}
}
out
}
fn clean(path: &str) -> String {
let p = path.trim().replace('\\', "/");
let p = p.trim_start_matches("./").trim_end_matches('/');
p.to_owned()
}
pub fn parse_classpath(text: &str) -> EclipseClasspath {
let mut out = EclipseClasspath::default();
for (tag, body) in elements(text, "classpathentry") {
let (Some(kind), Some(path)) = (attribute(tag, "kind"), attribute(tag, "path")) else { continue };
let path = clean(&path);
match kind.as_str() {
// `/OtherProject` is a project reference, not a folder of this one.
"src" if !path.starts_with('/') && !path.is_empty() => {
let test = elements(body, "attribute").iter().any(|(a, _)| {
attribute(a, "name").as_deref() == Some("test") && attribute(a, "value").as_deref() == Some("true")
});
out.sources.push((path, test));
}
"output" if !path.is_empty() => out.output = Some(path),
"lib" if !path.is_empty() => out.libraries.push(path),
_ => {}
}
}
out
}
/// The project's `.classpath`, unless a Maven or Gradle build owns its model.
pub fn classpath(dir: &Path) -> Option<EclipseClasspath> {
if ["pom.xml", "build.gradle", "build.gradle.kts"].iter().any(|f| dir.join(f).is_file()) {
return None;
}
std::fs::read_to_string(dir.join(".classpath")).ok().map(|t| parse_classpath(&t))
}
/// The web content folder of a web project: the `wb-resource` deployed at `/`, else a
/// conventional `WebContent` / `WebRoot` / `web` / `src/main/webapp` holding `WEB-INF/web.xml`.
pub fn web_root(dir: &Path) -> Option<String> {
if let Ok(text) = std::fs::read_to_string(dir.join(".settings/org.eclipse.wst.common.component")) {
for (tag, _) in elements(&text, "wb-resource") {
if attribute(tag, "deploy-path").as_deref() == Some("/")
&& let Some(source) = attribute(tag, "source-path")
{
let source = clean(source.trim_start_matches('/'));
if dir.join(&source).is_dir() {
return Some(source);
}
}
}
}
["WebContent", "WebRoot", "web", "src/main/webapp"]
.into_iter()
.find(|d| dir.join(d).join("WEB-INF/web.xml").is_file())
.map(str::to_owned)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reads_sources_tests_output_and_libraries() {
let cp = parse_classpath(
r#"<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" output="bin/test" path="test">
<attributes>
<attribute name="test" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" path="/OtherProject"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="lib" path="WebContent/WEB-INF/lib/commons-lang.jar"/>
<classpathentry kind='lib' path='lib\mail.jar' sourcepath="lib/mail-src.zip"/>
<classpathentry kind="output" path="build/classes"/>
</classpath>"#,
);
assert_eq!(cp.sources, [("src".to_owned(), false), ("test".to_owned(), true)]);
assert_eq!(cp.output.as_deref(), Some("build/classes"));
assert_eq!(cp.libraries, ["WebContent/WEB-INF/lib/commons-lang.jar", "lib/mail.jar"]);
}
#[test]
fn finds_the_web_content_folder() {
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir_all(dir.path().join("site/WEB-INF")).unwrap();
std::fs::create_dir_all(dir.path().join(".settings")).unwrap();
std::fs::write(
dir.path().join(".settings/org.eclipse.wst.common.component"),
r#"<project-modules><wb-module deploy-name="shop">
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
<wb-resource deploy-path="/" source-path="/site" tag="defaultRootSource"/>
</wb-module></project-modules>"#,
)
.unwrap();
assert_eq!(web_root(dir.path()).as_deref(), Some("site"));
let plain = tempfile::tempdir().unwrap();
std::fs::create_dir_all(plain.path().join("WebRoot/WEB-INF")).unwrap();
assert_eq!(web_root(plain.path()), None);
std::fs::write(plain.path().join("WebRoot/WEB-INF/web.xml"), "<web-app/>").unwrap();
assert_eq!(web_root(plain.path()).as_deref(), Some("WebRoot"));
}
#[test]
fn detects_the_roots_of_an_eclipse_project() {
use super::super::{RootKind, detect};
let dir = tempfile::tempdir().unwrap();
for d in ["src", "test", "bin"] {
std::fs::create_dir_all(dir.path().join(d)).unwrap();
}
std::fs::write(
dir.path().join(".classpath"),
r#"<classpath><classpathentry kind="src" path="src"/><classpathentry kind="src" path="test"><attributes><attribute name="test" value="true"/></attributes></classpathentry><classpathentry kind="output" path="bin"/></classpath>"#,
)
.unwrap();
let roots: Vec<(String, RootKind)> = detect(dir.path()).into_iter().map(|r| (r.path, r.kind)).collect();
assert_eq!(
roots,
[("bin".into(), RootKind::Excluded), ("src".into(), RootKind::Source), ("test".into(), RootKind::Test)]
);
// A Maven build owns the model even with a stale `.classpath` next to it.
std::fs::write(dir.path().join("pom.xml"), "<project/>").unwrap();
assert!(detect(dir.path()).iter().all(|r| r.detected_from.as_deref() != Some(".classpath")));
}
}
+1
Переглянути файл
@@ -6,6 +6,7 @@
//! project-relative and `/`-separated; `""` is the project root itself.
mod detect;
pub mod eclipse;
pub(crate) use detect::{BUILD_FILES, virtual_env_marker};
mod gradle;
mod java;
+1 -1
Переглянути файл
@@ -128,7 +128,7 @@ With tabs placed left or right, the tab column is as wide as its longest name, u
| **Scroll to Center** | `⌃L` | `Ctrl+M` |
- **View › Active Editor › Soft-Wrap** wraps long lines in the current editor. To wrap some file types by default, use **Settings › Editor › General**, section **Soft Wraps**.
- **View › Reset Font Size in All Editors** undoes font zoom. Changing the font size with `⌘` / `Ctrl` + mouse wheel can be turned on in **Settings › Editor › General**, section **Mouse Control**.
- **View › Reset Font Size** undoes font zoom in the active editor or focused surface (**View › Reset Font Size in All Editors** resets every open editor). Changing the font size with `⌘` / `Ctrl` + mouse wheel (scoped to **Active editor** by default, or **All editors**) can be turned on in **Settings › Editor › General**, section **Mouse Control**.
- **View › Appearance › Enter Distraction Free Mode** hides tool windows, tabs, the status bar and the gutter and centres the text. Run the same command again to leave.
- Line numbers, whitespace, indent guides, caret style and the intention bulb are in **Settings › Editor › General › Appearance**. Breadcrumbs and sticky lines (the enclosing declarations pinned at the top while you scroll) have their own pages under **Settings › Editor › General**.
+3 -1
Переглянути файл
@@ -94,6 +94,7 @@ While the server runs, OpenIDEA writes its port and token to `mcp/server.json` i
| Commands | `run_command`, `wait_for_run`, `send_run_input`, `stop_run` |
| Command state | `get_run_status`, `read_run_output`, `list_runs` |
| Git | `get_repositories`, `git_status`, `git_diff` |
| HTTP Client | `http_list_requests`, `http_run_request` |
Notes on what they do:
@@ -105,6 +106,7 @@ Notes on what they do:
- `rename_refactoring` renames through the language server, so references that a text search would miss are updated too. It can preview without writing.
- `apply_patch` accepts the Codex `apply_patch` format and unified diffs. Paths must stay inside the project.
- `git_diff` compares files on disk, so unsaved editor text is not included.
- `http_list_requests` lists requests in a project `.http` / `.rest` file; `http_run_request` sends one by index (optional `env` from `http-client.env.json`), asks first, and returns status plus a truncated body — not request headers or body.
## Commands in the Run tool window
@@ -122,7 +124,7 @@ Plugins can add more tools; they appear in the same list. A plugin tool marked a
## Safety
- **Untrusted projects** expose only the read-only tools. Tools that write files, rename, reformat, build or run need a project you have trusted.
- **Running and building ask first.** `execute_run_configuration`, `build_project` and `run_command` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
- **Running and building ask first.** `execute_run_configuration`, `build_project`, `run_command` and `http_run_request` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
- Tools that write refuse paths outside the project.
## Limits
+3 -3
Переглянути файл
@@ -27,8 +27,8 @@ The **Refactor** menu has IntelliJ IDEA's refactorings with their usual shortcut
| **Inline…** | `⌥⌘N` | `Ctrl+Alt+N` | Language server |
| **Move…** | `F6` | `F6` | Language server (symbols); the IDE (files and folders) |
| **Safe Delete…** | `⌘⌦` | `Alt+Delete` | The IDE, using the server's references |
| **Pull Members Up…** | — | — | Java only |
| **Push Members Down…** | — | — | Java only |
| **Pull Members Up…** | — | — | Java; PHP with Phoxite |
| **Push Members Down…** | — | — | Java; PHP with Phoxite |
## Rename
@@ -80,7 +80,7 @@ In the editor, **Move…** on a symbol runs the server's move refactoring, where
## Pull Members Up and Push Members Down
These move fields and methods between a Java class and its superclasses or subclasses. A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. They are provided by the Java extension bundled with OpenIDEA, so they are not available for other languages.
These move fields and methods between a class and its superclasses or subclasses, in Java and, with Phoxite as the PHP server, in PHP (methods, properties and constants). A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. For Java they are provided by the extension bundled with OpenIDEA, for PHP by Phoxite; they are not available for other languages or other PHP servers.
## Undo
+1 -1
Переглянути файл
@@ -64,7 +64,7 @@ To create a theme or icon theme, see [Themes](/en/plugins/guides/themes) and [Ic
- **Enable ligatures** for fonts with programming ligatures.
- **Typography Settings**: **Main font weight**, **Bold font weight**, and a **Fallback font** for characters the main font lacks.
To change the size temporarily, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size in All Editors** goes back. On macOS, **Change font size with Command+Mouse Wheel** in **Settings › Editor › General** enables wheel zoom.
To change the size temporarily in the active editor, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size** (or **View › Reset Font Size in All Editors**) goes back. In **Settings › Editor › General**, **Change font size with Ctrl/Command+Mouse Wheel** enables wheel zoom for the **Active editor** (default) or **All editors**.
### UI font and zoom
+25 -24
Переглянути файл
@@ -100,30 +100,31 @@ The user approves **required** capabilities as a whole when installing. **Option
Each contribution point is a table (`[contributes.settings]`) or an array of tables (`[[contributes.commands]]`). Contributions are live as soon as the plugin is enabled, before its code loads.
| Point | Declaration | Code needed | Guide |
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
| Point | Declaration | Code needed | Guide |
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `serverCommands` | `server`, `command`, `run` (API 1.9) | yes | [README: Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
Item ids (commands, views, themes, …) match `[a-z0-9][a-z0-9._-]*`, at most 64 characters. Menus, shortcuts and status bar items refer to the plugin's own declared commands; inside the IDE a command's action id is `plugin.<plugin id>.<command id>`.
+1 -1
Переглянути файл
@@ -128,7 +128,7 @@ description: "多光标与选区、行编辑、剪贴板历史、代码折叠、
| **滚动到中央** | `⌃L` | `Ctrl+M` |
- **视图 › 活动编辑器 › 软换行** 让当前编辑器的长行自动折行。想让某些文件类型默认软换行,在 **设置 › 编辑器 › 常规** 的 **软换行** 一节中设置。
- **视图 › 重置所有编辑器中的字体大小** 撤销字体缩放。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开。
- **视图 › 重置字体大小** 撤销当前编辑器或焦点区域的字体缩放(**视图 › 重置所有编辑器中的字体大小** 会重置所有打开的编辑器)。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
- **视图 › 外观 › 进入无干扰模式** 隐藏工具窗口、标签页、状态栏和装订区域,并让正文居中。再执行一次即可退出。
- 行号、空白字符、缩进参考线、光标样式和意图灯泡在 **设置 › 编辑器 › 常规 › 外观** 中设置。痕迹导航和粘滞行(滚动时把所在的声明固定在顶部)在 **设置 › 编辑器 › 常规** 下各有单独的页面。
+14 -12
Переглянути файл
@@ -82,17 +82,18 @@ stdio 配置大致如下(路径以你机器上的为准):
## 工具
| 类别 | 工具 |
| ---------- | --------------------------------------------------------------------------- |
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
| Git | `get_repositories`、`git_status`、`git_diff` |
| 类别 | 工具 |
| ----------- | --------------------------------------------------------------------------- |
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
| Git | `get_repositories`、`git_status`、`git_diff` |
| HTTP 客户端 | `http_list_requests`、`http_run_request` |
几点说明:
@@ -104,6 +105,7 @@ stdio 配置大致如下(路径以你机器上的为准):
- `rename_refactoring` 通过语言服务器重命名,文本搜索找不到的引用也会一并更新;也可以只预览不写入。
- `apply_patch` 接受 Codex 的 `apply_patch` 格式和 unified diff,路径必须在项目内。
- `git_diff` 比较的是磁盘上的文件,不包含编辑器中尚未保存的内容。
- `http_list_requests` 列出项目中 `.http` / `.rest` 文件里的请求;`http_run_request` 按索引发送其中一个(可选 `env`,来自 `http-client.env.json`),会先询问,并返回状态和截断后的响应体——不含请求头或请求体。
## 在运行工具窗口中执行命令
@@ -121,7 +123,7 @@ stdio 配置大致如下(路径以你机器上的为准):
## 安全
- **未受信任的项目** 只开放只读工具。写文件、重命名、重新格式化、构建或运行的工具都要求项目已被信任。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project` 和 `run_command` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project`、`run_command` 和 `http_run_request` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- 会写入的工具拒绝项目之外的路径。
## 限制
+3 -3
Переглянути файл
@@ -27,8 +27,8 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
| **内联…** | `⌥⌘N` | `Ctrl+Alt+N` | 语言服务器 |
| **移动…** | `F6` | `F6` | 语言服务器(符号);IDE(文件和文件夹) |
| **安全删除…** | `⌘⌦` | `Alt+Delete` | IDE,借助服务器查找引用 |
| **上拉成员…** | — | — | 仅 Java |
| **下推成员…** | — | — | 仅 Java |
| **上拉成员…** | — | — | Java;PHP(使用 Phoxite) |
| **下推成员…** | — | — | Java;PHP(使用 Phoxite) |
## 重命名
@@ -73,7 +73,7 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
## 上拉成员与下推成员
用于在 Java 类和它的父类或子类之间移动字段和方法。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。这两项由 OpenIDEA 自带的 Java 扩展提供,其他语言不可用。
用于在类和它的父类或子类之间移动字段和方法:支持 Java,以及使用 Phoxite 作为 PHP 服务器时的 PHP(方法、属性和常量)。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。Java 由 OpenIDEA 自带的扩展提供,PHP 由 Phoxite 提供;其他语言和其他 PHP 服务器不可用。
## 撤销
+1 -1
Переглянути файл
@@ -64,7 +64,7 @@ OpenIDEA 会把主题(以及其中附带的编辑器配色方案)转换为
- **启用连字**:用于带编程连字的字体。
- **排版设置**:**主字重**、**粗体字重**,以及主字体缺少字符时使用的 **备用字体**。
临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置所有编辑器中的字体大小** 恢复。在 macOS 上,开启 **设置 › 编辑器 › 常规** 中的 **使用 Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放。
在当前编辑器中临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置字体大小**(或 **视图 › 重置所有编辑器中的字体大小**)恢复。在 **设置 › 编辑器 › 常规** 中开启 **使用 Ctrl/Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
### 界面字体与缩放
+25 -24
Переглянути файл
@@ -100,30 +100,31 @@ optional = ["net:api.openai.com", "secrets"]
每个贡献点是一张表(`[contributes.settings]`)或一个表数组(`[[contributes.commands]]`)。插件启用后贡献立即生效,不需要等代码加载。
| 贡献点 | 声明字段 | 需要代码 | 指南 |
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
| 贡献点 | 声明字段 | 需要代码 | 指南 |
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `serverCommands` | `server`、`command`、`run`(API 1.9) | 是 | [README:Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
条目 id(命令、视图、主题等)匹配 `[a-z0-9][a-z0-9._-]*`,不超过 64 个字符。菜单、快捷键和状态栏项只能引用插件自己声明的命令;在 IDE 内部,命令的操作 id 是 `plugin.<plugin id>.<command id>`。
+58
Переглянути файл
@@ -761,3 +761,61 @@ test("Find in Conversation skips user-select:none summaries and closed <details>
}));
expect(expandedHighlights).toEqual({ thoughtOpen: true, findCount: 2, currentCount: 1 });
});
test("keeps ordered, bulleted and task list markers unclipped inside measured rows when zoomed in", async ({
page,
}) => {
const numbered = Array.from({ length: 10 }, (_, i) => `${i + 1}. **Item ${i + 1}**\n - Nested bullet`).join("\n");
await openReply(page, `## Feature Gaps\n\n${numbered}\n\n- [x] Checked task\n- [ ] Open task`);
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const actionsPath = "/src/platform/actions.ts";
const store = await import(storePath);
const { executeAction } = await import(actionsPath);
store.openTaskInEditorLocation(task.id);
await new Promise((r) => setTimeout(r, 150));
const stream = document.querySelector<HTMLElement>("[class*='_stream_']");
stream?.focus();
for (let i = 0; i < 12; i++) await executeAction("editor.increaseFontSize");
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
const row = stream.locator("[class*='_conversationRow_'][data-measured]", { has: page.locator("ol") });
await expect(row).toBeVisible();
const bounds = await row.evaluate((rowEl) => {
const rowLeft = rowEl.getBoundingClientRect().left;
const items = [...rowEl.querySelectorAll<HTMLElement>("ol > li, ul > li")];
const markers = items
.filter((li) => getComputedStyle(li, "::before").content !== "none")
.map((li) => {
const rect = li.getBoundingClientRect();
const before = getComputedStyle(li, "::before");
const lineHeight = Number.parseFloat(getComputedStyle(li).lineHeight);
const markerRight = rect.right - Number.parseFloat(before.right);
const markerLeft = markerRight - Number.parseFloat(before.width);
return {
text: li.firstChild?.textContent?.trim() ?? "",
offsetFromRowLeft: Math.round((markerLeft - rowLeft) * 100) / 100,
singleLine: Number.parseFloat(before.height) <= lineHeight * 1.15,
};
});
const checkboxes = [...rowEl.querySelectorAll<HTMLInputElement>('li > input[type="checkbox"]')].map((input) => ({
offsetFromRowLeft: Math.round((input.getBoundingClientRect().left - rowLeft) * 100) / 100,
}));
return { fontSize: getComputedStyle(streamElement()!).fontSize, markers, checkboxes };
function streamElement() {
return rowEl.closest<HTMLElement>("[class*='_stream_']");
}
});
expect(bounds.fontSize).toBe("25px");
expect(bounds.markers.length).toBeGreaterThanOrEqual(10);
for (const m of bounds.markers) {
expect(m.singleLine, `single-line marker for ${m.text}`).toBe(true);
expect(m.offsetFromRowLeft, `marker for ${m.text}`).toBeGreaterThanOrEqual(0);
}
for (const cb of bounds.checkboxes) {
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
}
});
+3
Переглянути файл
@@ -0,0 +1,3 @@
# Per-user IDE state
/shelf/
/changelists.json
+31
Переглянути файл
@@ -157,6 +157,7 @@ work), but 0.1 code no longer runs: rebuild it against the 1.0 SDK.
| `fileIcons` | `id`, `patterns` (file names), `icon` (SVG), `iconDark?` — whatever icon theme is in use | no |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables = [{ name, prompt }]` — New menu | no |
| `commitChecks` | `id`, `title` — a before-commit check in Commit Options (see _Commits_) | yes |
| `serverCommands` | `server`, `command`, `run` — a language server's client command run by this plugin's command (API 1.9; see _Commands a server hands to the client_) |
A `viewItem.context` menu needs `view`, the id of one of the plugin's own
views. It adds the commands to the right-click menu of the items in that
@@ -432,6 +433,8 @@ matching SDK. Released 1.8 plugins keep working. New in 1.9:
(Debug runs the configuration and attaches to a process the run starts). See
_Environment and debugger_ under _Runs, terminal sessions and test results_.
- **`[[contributes.serverCommands]]`** routes a command a language server leaves
to the client (a code lens's, a code action's) to the plugin's own command.
- **Requests to a language server.** `Project::language_server_request` and
`language_server_notify` send a running server its own methods, behind the
high-risk `lsp:<server>` capability. See _Requests to a language server_.
@@ -781,6 +784,34 @@ project.language_server_notify("phoxite", "phoxite/refresh", None)?;
is at most 256 bytes, params at most 1 MiB.
- The project must be trusted; otherwise the call is `denied`.
#### Commands a server hands to the client
A server's code lens, code action or inlay hint can carry a command the server
does not execute itself (it is not in its `executeCommandProvider`): the client
is meant to. A plugin claims such a command in its manifest, and the IDE runs
the plugin's own command instead of failing with "no language server provides
command":
```toml
[[contributes.commands]]
id = "model-view"
title = "Show the Eloquent Model"
[[contributes.serverCommands]]
server = "phoxite" # the server whose results carry the command
command = "laravel.modelView" # the command name in the server's result
run = "model-view" # this plugin's command
```
- `run` gets the command's `arguments` array as JSON in `arg`, in the window and
editor where the lens or action was activated.
- The manifest must declare `lsp:<server>`, and the claim counts only while the
plugin holds that grant.
- A command listed in the server's `executeCommandProvider` still goes to the
server.
- When two installed plugins claim the same `server` and `command`, the first
one loaded keeps it and the conflict is logged.
In tests, `MockHost::set_language_server_response(server, method, json)` makes
a server run and answer, and `language_server_requests()` /
`language_server_notifications()` list what the plugin sent.
+1
Переглянути файл
@@ -250,6 +250,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
nav::find_files_named,
nav::find_dirs,
nav::find_symbols,
nav::find_symbols_named,
nav::mark_recent,
nav::recent_files,
nav::remove_recent,
+28 -6
Переглянути файл
@@ -24,8 +24,13 @@ pub fn index_file_extensions(window: Window, state: State<'_, AppState>) -> IdeR
#[tauri::command]
#[specta::specta]
pub fn find_files(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit)
pub async fn find_files(
window: Window,
state: State<'_, AppState>,
query: String,
limit: u32,
) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit).await
}
#[tauri::command]
@@ -37,8 +42,13 @@ pub async fn find_files_named(window: Window, state: State<'_, AppState>, name:
/// Folders holding indexed files, for `@` references.
#[tauri::command]
#[specta::specta]
pub fn find_dirs(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit)
pub async fn find_dirs(
window: Window,
state: State<'_, AppState>,
query: String,
limit: u32,
) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit).await
}
/// Spring Web mapping sources for the request-path index of Search Everywhere.
@@ -53,14 +63,26 @@ pub fn spring_route_sources(
#[tauri::command]
#[specta::specta]
pub fn find_symbols(
pub async fn find_symbols(
window: Window,
state: State<'_, AppState>,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit)
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit).await
}
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder).
#[tauri::command]
#[specta::specta]
pub async fn find_symbols_named(
window: Window,
state: State<'_, AppState>,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
ide_host::ops::nav::find_symbols_named(&state.host, window.label(), names, within).await
}
#[tauri::command]
+44 -9
Переглянути файл
@@ -6,6 +6,7 @@ use crate::windows::{self, Launch, OpenOutcome, WindowsState};
use ide_core::{IdeError, IdeResult, RequestId};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::BTreeMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use tauri::ipc::Channel;
@@ -636,12 +637,18 @@ pub async fn app_install_update(
}
/// Release notes of `version` from the update manifest (`latest.json`), read
/// through the configured source. An install records the notes it saw, so this
/// is only for an update installed outside the app. `Ok(None)` when the manifest
/// covers another version or carries no notes.
/// through the configured source: the `notes` text under `"en"` plus any
/// `notes.<lang>` translations keyed by their base language code, so the page
/// can show the UI's language and fall back to English. An install records the
/// notes it saw, so this is only for an update installed outside the app.
/// `Ok(None)` when the manifest covers another version or carries no notes.
#[tauri::command]
#[specta::specta]
pub async fn app_release_notes(app: AppHandle, version: String, source: UpdateSource) -> IdeResult<Option<String>> {
pub async fn app_release_notes(
app: AppHandle,
version: String,
source: UpdateSource,
) -> IdeResult<Option<BTreeMap<String, String>>> {
let endpoints = match update_endpoint_env() {
Some(url) => vec![url],
None => source_endpoints(config_endpoints(&app), source, is_nightly(&app.package_info().version.to_string())),
@@ -667,14 +674,32 @@ pub async fn app_release_notes(app: AppHandle, version: String, source: UpdateSo
Ok(None)
}
/// The notes of `version` in a manifest, when that is the entry it lists.
fn notes_for(manifest: &str, version: &str) -> Option<String> {
/// The notes of `version` in a manifest, when that is the entry it lists: the
/// `notes` text as English and each `notes.<lang>` entry under its base language
/// code (`notes.zh-CN` → `zh`), the way the UI's locales are keyed.
fn notes_for(manifest: &str, version: &str) -> Option<BTreeMap<String, String>> {
let value: serde_json::Value = serde_json::from_str(manifest).ok()?;
if value.get("version")?.as_str()? != version {
return None;
}
let notes = value.get("notes")?.as_str()?.trim();
(!notes.is_empty()).then(|| notes.to_string())
let mut notes = BTreeMap::new();
let entry =
|text: &serde_json::Value| text.as_str().map(str::trim).filter(|text| !text.is_empty()).map(str::to_string);
if let Some(text) = value.get("notes").and_then(entry) {
notes.insert("en".to_owned(), text);
}
for (key, text) in value.as_object().into_iter().flatten() {
let Some(tag) = key.strip_prefix("notes.").and_then(|tag| tag.split(['-', '_']).next()) else {
continue;
};
if tag.is_empty() {
continue;
}
if let Some(text) = entry(text) {
notes.insert(tag.to_ascii_lowercase(), text);
}
}
(!notes.is_empty()).then_some(notes)
}
#[cfg(test)]
@@ -684,10 +709,20 @@ mod tests {
let manifest = serde_json::json!({
"version": "0.1.40",
"notes": "## What's new\n\n- dev containers",
"notes.zh": "## 新变化\n\n- 开发容器",
"notes.ko-KR": "## 새 소식",
"notes.pl": " ",
"pub_date": "2026-11-01T00:00:00Z",
})
.to_string();
assert_eq!(notes_for(&manifest, "0.1.40").as_deref(), Some("## What's new\n\n- dev containers"));
assert_eq!(
notes_for(&manifest, "0.1.40"),
Some(BTreeMap::from([
("en".to_owned(), "## What's new\n\n- dev containers".to_owned()),
("zh".to_owned(), "## 新变化\n\n- 开发容器".to_owned()),
("ko".to_owned(), "## 새 소식".to_owned()),
]))
);
// Another version, empty notes, or not JSON: nothing to show.
assert_eq!(notes_for(&manifest, "0.1.41"), None);
assert_eq!(notes_for(r#"{ "version": "0.1.40", "notes": " " }"#, "0.1.40"), None);
+2 -1
Переглянути файл
@@ -439,7 +439,8 @@ pub fn spec(os: Os) -> Vec<Entry> {
SEP,
act("view.quickSwitchScheme", "Quick Switch Scheme…"),
SEP,
act("editor.resetFontSize", "Reset Font Size in All Editors"),
act("editor.resetFontSize", "Reset Font Size"),
act("editor.resetFontSizeAll", "Reset Font Size in All Editors"),
SEP,
act("view.notifications", "Notifications"),
],
+4 -2
Переглянути файл
@@ -1,10 +1,12 @@
//! Tauri runs a command declared without `async` on the main thread, so disk I/O or a
//! large diff there freezes the window (input, painting, every other IPC call).
/// Commands that read or write project files, Local History or `.env` files, or diff two
/// arbitrary texts: they must be `async` and do that work on the blocking pool.
/// Commands that read or write project files, Local History or `.env` files, diff two
/// arbitrary texts, or scan the project index in parallel: they must be `async` and do
/// that work on the blocking pool.
const OFF_MAIN_THREAD: &[(&str, &[&str])] = &[
("doc.rs", &["history_list", "history_content"]),
("nav.rs", &["find_files", "find_dirs", "find_symbols"]),
(
"vcs.rs",
&[
+4 -3
Переглянути файл
@@ -216,10 +216,11 @@ docker_snapshot trusted desktop bin
end_process trusted desktop bindings async
env_reload always project_host bindings async
file_dialog_needs_gtk trusted desktop bindings async
find_dirs always project_host bindings sync
find_files always project_host bindings sync
find_dirs always project_host bindings async
find_files always project_host bindings async
find_files_named always project_host bindings async
find_symbols always project_host bindings sync
find_symbols always project_host bindings async
find_symbols_named always project_host bindings async
fs_compare_directories always project_host bindings async
fs_copy always project_host bindings async
fs_copy_merge always project_host bindings async
+53 -5
Переглянути файл
@@ -491,6 +491,8 @@ export const commands = {
/** Folders holding indexed files, for `@` references. */
findDirs: (query: string, limit: number) => typedError<FileMatch[], IdeError>(__TAURI_INVOKE("find_dirs", { query, limit })),
findSymbols: (query: string, filter: SymbolFilter, limit: number) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols", { query, filter, limit })),
/** Index symbols named exactly one of `names` inside `within` (an agent task's folder). */
findSymbolsNamed: (names: string[], within: IpcPath) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols_named", { names, within })),
markRecent: (path: string) => typedError<null, IdeError>(__TAURI_INVOKE("mark_recent", { path })),
/** Recently opened files, most recent first (⌘E). */
recentFiles: () => typedError<IpcPath[], IdeError>(__TAURI_INVOKE("recent_files")),
@@ -1293,11 +1295,13 @@ export const commands = {
appInstallUpdate: (source: UpdateSource, request: RequestId, onProgress: Channel<UpdateProgress>) => typedError<null, IdeError>(__TAURI_INVOKE("app_install_update", { source, request, onProgress })),
/**
* Release notes of `version` from the update manifest (`latest.json`), read
* through the configured source. An install records the notes it saw, so this
* is only for an update installed outside the app. `Ok(None)` when the manifest
* covers another version or carries no notes.
* through the configured source: the `notes` text under `"en"` plus any
* `notes.<lang>` translations keyed by their base language code, so the page
* can show the UI's language and fall back to English. An install records the
* notes it saw, so this is only for an update installed outside the app.
* `Ok(None)` when the manifest covers another version or carries no notes.
*/
appReleaseNotes: (version: string, source: UpdateSource) => typedError<string | null, IdeError>(__TAURI_INVOKE("app_release_notes", { version, source })),
appReleaseNotes: (version: string, source: UpdateSource) => typedError<{ [key in string]: string } | null, IdeError>(__TAURI_INVOKE("app_release_notes", { version, source })),
debugExceptionFilters: () => typedError<SessionExceptionFilters[], IdeError>(__TAURI_INVOKE("debug_exception_filters")),
debugSetExceptionBreakpoints: (choices: { [key in string]: boolean }) => typedError<null, IdeError>(__TAURI_INVOKE("debug_set_exception_breakpoints", { choices })),
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
@@ -2938,7 +2942,9 @@ export type BuildResult = {
messages: BuildMessage[],
};
export type BuildSystem = "maven" | "gradle" | "cargo" | "go" | "typescript" | "cmake" | "dotnet";
export type BuildSystem = "maven" | "gradle" | "cargo" | "go" | "typescript" | "cmake" | "dotnet" |
/** A Java project without a build tool, compiled from its Project Structure. */
"javac";
export type BuildTool = "maven" | "gradle";
@@ -4899,6 +4905,8 @@ export type EditorConfigProps = {
export type EditorGeneralSettings = {
/** Change font size with ⌘ + mouse wheel. */
wheelZoom?: boolean,
/** Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors. */
wheelZoomScope?: string,
markdownImageFolder?: string,
markdownImageNamePattern?: string,
/** Drag-and-drop of selected text inside the editor. */
@@ -5253,6 +5261,24 @@ export type FieldValue = { kind: "label"; value: string } | { kind: "readonlyTex
selected: string,
} };
export type FileColor = {
/**
* A built-in scope (`Tests`, `Production`, `Project Files`, `Non-Project Files`) or a
* `scopes` entry, by name.
*/
scope?: string,
/** A palette name (`blue`, `green`, `orange`, `rose`, `violet`, `yellow`, `gray`) or `#rrggbb`. */
color?: string,
};
export type FileColorSettings = {
enabled?: boolean,
editorTabs?: boolean,
projectView?: boolean,
/** Scope → colour; the first scope that holds a file gives its colour. */
colors?: FileColor[],
};
export type FileCoverage = {
path: IpcPath,
/** Sorted by line. */
@@ -5723,6 +5749,11 @@ export type GitSettings = {
pushDialogOnlyProtected?: boolean,
/** Stashes and shelves share one tab. */
combineStashAndShelf?: boolean,
/**
* The non-modal Commit tool window works on the index: Staged / Unstaged groups,
* stage and unstage instead of inclusion checkboxes, and no change lists.
*/
stagingArea?: boolean,
};
export type GoBuildTags = {
@@ -7771,6 +7802,15 @@ export type ModuleStructureSettings = {
dependencies?: ModuleDependency[],
};
/**
* A named set of files: `file:src//*.ts && !file:*.test.ts` (project-relative path patterns
* joined with `||`, `&&`, `!` and parentheses).
*/
export type NamedScope = {
name?: string,
pattern?: string,
};
/**
* Where the Navigation Bar (the file path breadcrumbs) is shown. Mirrors
* IDEA's `View | Appearance | Navigation Bar` (Top / Status Bar / Don't show).
@@ -9884,6 +9924,10 @@ export type Settings_Deserialize = {
mcpServer?: McpServerSettings,
/** Tools › Agents: Command Execution Policy. */
agentSecurity?: AgentSecuritySettings,
/** Appearance & Behavior › Scopes: named file sets other settings refer to. */
scopes?: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors?: FileColorSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins?: { [key in string]: { [key in string]: unknown } },
};
@@ -9950,6 +9994,10 @@ export type Settings_Serialize = {
mcpServer: McpServerSettings,
/** Tools › Agents: Command Execution Policy. */
agentSecurity: AgentSecuritySettings,
/** Appearance & Behavior › Scopes: named file sets other settings refer to. */
scopes: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors: FileColorSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins: { [key in string]: { [key in string]: unknown } },
};
+57 -12
Переглянути файл
@@ -8,7 +8,7 @@ import { acceptCompletion, completionStatus } from "@codemirror/autocomplete";
import { executeAction, registerActions, type Action } from "@/platform/actions";
import { getContext } from "@/platform/context";
import { focusedSoftWrapSurface } from "@/workbench/softWrap";
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom } from "@/workbench/contributions";
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom, stepSurfaceFontZoomIn } from "@/workbench/contributions";
import { editorController, useGotoLine, useTabs } from "./controller";
import {
addCaretsToLineEnds,
@@ -71,7 +71,7 @@ import { copyReferenceToClipboard, declaredName, qualifiedReference, referenceOf
import { declarationChain } from "./view/outline";
import { recordClipboard } from "./clipboardHistory";
import { useDocMeta, useOutline } from "./model/document";
import { resetAllEditorsFontZoom, stepAllEditorsFontZoom } from "./cm/prefs";
import { resetAllEditorsFontZoom, resetConfiguredEditorsFontZoom, stepConfiguredEditorsFontZoom } from "./cm/prefs";
import { useProject } from "@/platform/project";
import { call, commands } from "@/platform/ipc";
import { editorPrefs } from "@/platform/editorSettings";
@@ -117,7 +117,12 @@ function withView(run: (view: EditorView, slot: EditorSlot) => unknown) {
};
}
/** Routes keyboard font zoom to focus, then the active editor slot. */
function activePaneEditorFocus(): Element | null {
if (typeof document === "undefined") return null;
return document.querySelector(`[data-pane-id="${useTabs.getState().activePane}"] [data-editor-focus]`);
}
/** Routes keyboard font zoom to focus, then the active editor slot or pane surface. */
function stepSurfaceFontSize(delta: 1 | -1): void {
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
if (activeEl) {
@@ -126,18 +131,55 @@ function stepSurfaceFontSize(delta: 1 | -1): void {
if (cmEl) {
const cmView = EditorView.findFromDOM(cmEl);
if (cmView) {
stepAllEditorsFontZoom(cmView, delta);
stepConfiguredEditorsFontZoom(cmView, delta);
return;
}
}
}
const slot = activeSlot();
if (!slot?.view) return;
stepAllEditorsFontZoom(slot.view, delta);
if (!slot?.view) {
stepSurfaceFontZoomIn(activePaneEditorFocus(), delta);
return;
}
stepConfiguredEditorsFontZoom(slot.view, delta);
if (!slot.view.hasFocus && !getContext().popupOpen) slot.view.focus();
}
function resetFontSize(): void {
const allScope = editorPrefs().general.wheelZoomScope === "all";
const surfaceOpts = allScope ? { isolatedOnly: true } : undefined;
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
if (activeEl) {
if (stepFocusedSurfaceFontZoom(0, surfaceOpts)) return;
if (!allScope) {
const cmEl = activeEl.closest?.(".cm-editor") as HTMLElement | null;
if (cmEl) {
const cmView = EditorView.findFromDOM(cmEl);
if (cmView) {
resetConfiguredEditorsFontZoom(cmView);
return;
}
}
}
}
const slot = activeSlot();
if (!allScope && slot?.view) {
resetConfiguredEditorsFontZoom(slot.view);
return;
}
if (!slot?.view && stepSurfaceFontZoomIn(activePaneEditorFocus(), 0, surfaceOpts)) return;
if (allScope) resetAllFontSize();
}
function resetAllFontSize(): void {
resetAllEditorsFontZoom();
if (typeof document !== "undefined") {
resetSurfaceFontZoom();
}
}
// --- extend / shrink selection ---------------------------------------------------
/** One stack per selection range (by index): ⌥↑ / ⌥↓ work on every caret. */
@@ -934,16 +976,19 @@ export function registerEditorActions(): () => void {
},
{
id: "editor.resetFontSize",
title: "Reset Font Size",
category: "View",
keywords: ["zoom", "font size", "mouse wheel"],
when: "projectOpen",
run: resetFontSize,
},
{
id: "editor.resetFontSizeAll",
title: "Reset Font Size in All Editors",
category: "View",
keywords: ["zoom", "font size", "mouse wheel"],
when: "projectOpen",
run: () => {
resetAllEditorsFontZoom();
if (typeof document !== "undefined") {
resetSurfaceFontZoom();
}
},
run: resetAllFontSize,
},
{
id: "editor.increaseFontSize",
+2 -1
Переглянути файл
@@ -270,7 +270,7 @@ describe("language modes", () => {
}
});
it("colours `this` and `super` as keywords in Java, JavaScript, TypeScript and C++", async () => {
it("colours `this`, `super` and Rust's `self` as keywords", async () => {
const highlighter = tagHighlighter([
{ tag: t.keyword, class: "keyword" },
{ tag: t.self, class: "self" },
@@ -281,6 +281,7 @@ 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]> = [];
+2 -1
Переглянути файл
@@ -308,8 +308,9 @@ const EXTRA_TAGS: Record<string, Parameters<typeof styleTags>[0]> = {
JSX: JS_TAGS,
TSX: JS_TAGS,
Java: JAVA_TAGS,
// CLion colours `this` as a keyword.
// CLion colours `this` as a keyword, RustRover `self`.
"C++": { this: t.keyword },
Rust: { self: t.keyword },
PHP: {
"; ,": t.separator,
"ClassDeclaration/Name BaseClause/Name InterfaceClause/Name": t.className,
+20 -4
Переглянути файл
@@ -37,7 +37,7 @@ import { markdownImages } from "./markdownImages";
import { selectionMarks } from "./selectionMarks";
import { seamlessSelection } from "./selectionLayer";
import { useEditorRegistry } from "@/editor/api";
import type { EditorExtras } from "@/platform/editorSettings";
import { editorPrefs, type EditorExtras } from "@/platform/editorSettings";
import { openideaHighlightStyle } from "./highlight";
import {
cursorHumpLeft,
@@ -426,11 +426,27 @@ export function stepAllEditorsFontZoom(origin: EditorView, delta: number): void
}
}
/** Resets one editor's font zoom to 0. */
export function resetEditorFontZoom(view: EditorView): void {
if (view.state.field(fontZoom, false)) view.dispatch({ effects: setFontZoom.of(0) });
}
/** Resets every open editor's font zoom, and the value new editors start from. */
export function resetAllEditorsFontZoom(): void {
sharedFontZoom = 0;
for (const ed of useEditorRegistry.getState().editors)
if (ed.view.state.field(fontZoom, false)) ed.view.dispatch({ effects: setFontZoom.of(0) });
for (const ed of useEditorRegistry.getState().editors) resetEditorFontZoom(ed.view);
}
/** Steps font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
export function stepConfiguredEditorsFontZoom(origin: EditorView, delta: number): void {
if (editorPrefs().general.wheelZoomScope === "all") stepAllEditorsFontZoom(origin, delta);
else stepFontZoom(origin, delta);
}
/** Resets font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
export function resetConfiguredEditorsFontZoom(origin: EditorView): void {
if (editorPrefs().general.wheelZoomScope === "all") resetAllEditorsFontZoom();
else resetEditorFontZoom(origin);
}
/** Exported for tests: the ⌘/Ctrl+wheel handler of the prefs compartment. */
@@ -438,7 +454,7 @@ export const wheelZoom = EditorView.domEventHandlers({
wheel(e, view) {
if (!e.metaKey && !e.ctrlKey) return false;
e.preventDefault();
stepAllEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
stepConfiguredEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
return true;
},
});
+12 -4
Переглянути файл
@@ -331,12 +331,20 @@ export class EditorController implements SlotHost {
this.disposers.push(
useTabs.subscribe((s, previous) => {
const open = openKeys(s);
const live = new Set<string>();
for (const pane of Object.values(s.panes)) for (const tab of pane.tabs) live.add(tab.id);
const closed = new Map<string, EditorInput>();
const closedTabs: Tab[] = [];
for (const pane of Object.values(previous.panes))
for (const tab of pane.tabs) if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
if (!this.replacingProject)
for (const input of closed.values())
useContributions.getState().editorKinds.get(input.kind)?.onClose?.(input);
for (const tab of pane.tabs) {
if (!live.has(tab.id)) closedTabs.push(tab);
if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
}
if (!this.replacingProject) {
const kinds = useContributions.getState().editorKinds;
for (const tab of closedTabs) kinds.get(tab.input.kind)?.onTabClose?.(tab.id, tab.input);
for (const input of closed.values()) kinds.get(input.kind)?.onClose?.(input);
}
const prev = prevTabs;
prevTabs = s;
if (
+21 -3
Переглянути файл
@@ -2,11 +2,12 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { useEditorRegistry, type TextEditorHandle } from "@/editor/api";
import { useProject } from "@/platform/project";
import { fontZoom, resetAllEditorsFontZoom, setFontZoom, stepAllEditorsFontZoom, wheelZoom } from "./cm/prefs";
const zoomOf = (view: EditorView) => view.state.field(fontZoom, false);
describe("shared editor font zoom (#2480)", () => {
describe("editor font zoom (active editor by default, all editors when configured)", () => {
const handles: TextEditorHandle[] = [];
const makeView = (extensions = [fontZoom, wheelZoom]) => {
const parent = document.createElement("div");
@@ -17,7 +18,10 @@ describe("shared editor font zoom (#2480)", () => {
handles.push(handle);
return view;
};
beforeEach(() => resetAllEditorsFontZoom());
beforeEach(() => {
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
afterEach(() => {
for (const handle of handles) {
useEditorRegistry.getState().editors.delete(handle);
@@ -26,9 +30,23 @@ describe("shared editor font zoom (#2480)", () => {
}
handles.length = 0;
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
it("zooms every open editor from ⌘/Ctrl+wheel on one of them", () => {
it("zooms only the active editor from ⌘/Ctrl+wheel by default (IDEA parity)", () => {
const first = makeView();
const second = makeView();
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
expect(zoomOf(first)).toBe(1);
expect(zoomOf(second)).toBe(0);
expect(zoomOf(makeView())).toBe(0);
second.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: 10 }));
expect(zoomOf(first)).toBe(1);
expect(zoomOf(second)).toBe(-1);
});
it("zooms every open editor from ⌘/Ctrl+wheel when wheelZoomScope is 'all' (#2480)", () => {
useProject.setState({ settings: { editor: { general: { wheelZoomScope: "all" } } } } as never);
const first = makeView();
const second = makeView();
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
+10
Переглянути файл
@@ -13,6 +13,8 @@ import {
import { _provideCodePreview, _provideDocumentAttacher, editorsFor } from "@/editor/api";
import { isUntitledUri } from "@/platform/virtualDocs";
import { formatDocument } from "@/editor/lsp/format";
import { chooserTitle, locationItems, pinToFind } from "@/editor/lsp/navigation";
import { openPopup } from "@/editor/lsp/popupStore";
import { editorController } from "./controller";
import { attachDocument } from "./model/attachment";
import { previewExtensions } from "./cm/preview";
@@ -64,6 +66,14 @@ export function activate(): void | (() => void) {
forgetSavedTabs: () => ctrl.forgetSavedTabs(),
keepSavedTabs: () => ctrl.keepSavedTabs(),
documentHistory: (command) => ctrl.documentHistory(command),
chooseDeclaration: async (targets, name, anchor) =>
openPopup({
kind: "list",
anchor,
title: chooserTitle("declaration", name, targets.length),
items: await locationItems(targets),
pin: pinToFind(name, targets),
}),
reformat: async (path) => {
const handle = editorsFor(path)[0];
return !!handle && (await formatDocument(handle.view, { explicit: false, selectionOnly: false })).applied;
+8 -1
Переглянути файл
@@ -12,11 +12,13 @@ afterEach(() => {
describe("custom editor close lifecycle", () => {
it("notifies once when the last split showing an input closes", async () => {
const close = vi.fn();
const tabClose = vi.fn();
const dispose = registerEditorKind({
kind: "close-probe",
title: () => "Probe",
component: () => null,
onClose: close,
onTabClose: tabClose,
});
controller = new EditorController(createMemoryBackend({}));
controller.start();
@@ -26,9 +28,14 @@ describe("custom editor close lifecycle", () => {
controller.split(useTabs.getState().activePane, "row");
const panes = Object.values(useTabs.getState().panes);
expect(panes).toHaveLength(2);
await controller.closeTab(panes[0]!.id, panes[0]!.tabs[0]!.id);
const firstTabId = panes[0]!.tabs[0]!.id;
const secondTabId = panes[1]!.tabs[0]!.id;
await controller.closeTab(panes[0]!.id, firstTabId);
expect(tabClose).toHaveBeenCalledExactlyOnceWith(firstTabId, input);
expect(close).not.toHaveBeenCalled();
await controller.closeInput(input.key);
expect(tabClose).toHaveBeenCalledTimes(2);
expect(tabClose).toHaveBeenLastCalledWith(secondTabId, input);
expect(close).toHaveBeenCalledExactlyOnceWith(input);
} finally {
dispose();
+11 -4
Переглянути файл
@@ -21,6 +21,7 @@ import {
prepareMenuGroups,
textEditorWrapperFor,
EditorShownProvider,
EditorTabIdProvider,
useContributions,
useFileDecorations,
useEditorDocumentRevision,
@@ -30,6 +31,7 @@ import {
type EditorKindContribution,
} from "@/workbench/contributions";
import { useDistractionFree } from "@/workbench/distractionFree";
import { useFileColors } from "@/workbench/fileColors";
import { EmptyEditor } from "@/workbench/EditorArea";
import {
EmptyState,
@@ -176,6 +178,7 @@ function PaneView({ paneId }: { paneId: string }) {
const dirty = tabs.map((tab, i) => inputDirty(tab.input, kinds) ?? textDirty[i] ?? false);
const colors = useFileDecorations(useShallow(() => paths.map((p) => (p ? (getFileDecoration(p)?.color ?? "") : ""))));
const tints = useFileDecorations(useShallow(() => paths.map((p) => (p ? (getFileDecoration(p)?.tint ?? "") : ""))));
const fileColors = useFileColors("editorTabs");
const hints = useTitleHints();
const [dropZone, setDropZone] = useState<DropZone | null>(null);
@@ -224,7 +227,8 @@ function PaneView({ paneId }: { paneId: string }) {
// (middle click, Shift+click, Delete) alive when its position is None.
showCloseButton,
color: colors[i] || undefined,
tint: tints[i] || undefined,
tint:
tints[i] || (fileColors && t.input.kind === "file" && t.input.path ? fileColors(t.input.path) : undefined),
tooltip: virtualTooltip(t.input) ?? (showFullPathOnHover ? (t.input.path ?? name) : undefined),
trailing:
kindMark || pin ? (
@@ -243,6 +247,7 @@ function PaneView({ paneId }: { paneId: string }) {
dirty,
colors,
tints,
fileColors,
hints,
showExtension,
markModified,
@@ -479,9 +484,11 @@ function KindEditor({ tab, shown, kept = false }: { tab: Tab; shown: boolean; ke
tabIndex={-1}
aria-hidden={shown ? undefined : true}
>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
<EditorTabIdProvider value={tab.id}>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
);
}
+15
Переглянути файл
@@ -135,6 +135,21 @@ describe("list popup", () => {
expect(onClose).toHaveBeenCalledOnce();
});
it("focuses the rows, not the header's pin button, when it opens", () => {
openPopup({
kind: "list",
anchor: { x: 0, y: 0 },
title: "Choose Declaration of foo (2 found)",
items: [
{ id: "a", label: "foo", run: vi.fn() },
{ id: "b", label: "foo", run: vi.fn() },
],
pin: { label: "Open in Find Tool Window", run: vi.fn() },
});
render(<LspPopups />);
expect(document.activeElement).toBe(screen.getByRole("listbox"));
});
it("pins the results elsewhere from the header button", () => {
const pin = vi.fn();
openPopup({
+1
Переглянути файл
@@ -210,6 +210,7 @@ function ListPopup({ popup }: { popup: Extract<LspPopup, { kind: "list" }> }) {
activeIndex={activeIndex}
onActiveChange={setActive}
hoverSelects
autoFocus
aria-label={popup.title}
onActivate={(r) => activate(r.item)}
empty={
+5
Переглянути файл
@@ -64,6 +64,11 @@ 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");
+2 -1
Переглянути файл
@@ -61,7 +61,8 @@ const TYPE_CLASS: Record<string, string> = {
lifetime: "annotation",
selfParameter: "self",
clsParameter: "self",
selfKeyword: "self",
// rust-analyzer's `self`: RustRover colours the self parameter as a keyword.
selfKeyword: "keyword",
};
const MODIFIER_CLASS: Record<string, string> = {
+2 -2
Переглянути файл
@@ -41,8 +41,8 @@ import {
import { safeDelete } from "./safeDelete";
import { startHierarchyRefactoring } from "./hierarchy";
/** Languages whose server runs the class-hierarchy refactorings (the app-owned JDT extension). */
const HIERARCHY_LANGUAGES = new Set(["java"]);
/** Languages with a server that runs the class-hierarchy refactorings (the app-owned JDT extension; Phoxite for PHP). */
const HIERARCHY_LANGUAGES = new Set(["java", "php"]);
/** Outcome of the server query: its answer, or why there is none. */
export type ServerAnswer =
+1 -1
Переглянути файл
@@ -30,7 +30,7 @@
.field :global(.cm-editor) {
background: transparent;
color: var(--fg-strong);
font-size: var(--fs-ui);
font-size: var(--agent-fs-ui, var(--fs-ui));
}
.field :global(.cm-editor.cm-focused) {
outline: none;
+4 -1
Переглянути файл
@@ -1,4 +1,7 @@
.home {
--agent-fs-ui: calc(var(--fs-ui) + var(--agent-font-zoom, 0px));
--agent-fs-small: calc(var(--fs-small) + var(--agent-font-zoom, 0px));
--agent-fs-code: calc(var(--fs-code) + var(--agent-font-zoom, 0px));
flex: 1;
min-height: 0;
overflow: auto;
@@ -22,7 +25,7 @@
}
.heading {
margin: 0 0 10px;
font-size: 18px;
font-size: calc(18px + var(--agent-font-zoom, 0px));
font-weight: 600;
text-align: center;
color: var(--fg-strong);
+9 -3
Переглянути файл
@@ -14,7 +14,8 @@ import { SubmitButton } from "./SubmitButton";
import { canSend, emptyDraft } from "./composerModel";
import { ConfigPickers } from "./ConfigPickers";
import { useEffortFocus } from "./effortFocus";
import { providerIcon } from "./model";
import { useAgentFontZoomSurface } from "./fontZoom";
import { HOME_KEY, providerIcon } from "./model";
import { ADD_AGENT, providerOptions as agentOptions } from "./providerOptions";
import {
HOME,
@@ -31,7 +32,7 @@ import {
import { useAgentSettings } from "./agentSettings";
import styles from "./Home.module.css";
export function HomeEditor({ docked = false }: { docked?: boolean; input?: EditorInput }) {
export function HomeEditor({ docked = false, input }: { docked?: boolean; input?: EditorInput }) {
const tx = useTx();
const txTemplate = useTxTemplate();
const draft = useAgents((s) => s.draft);
@@ -97,6 +98,7 @@ export function HomeEditor({ docked = false }: { docked?: boolean; input?: Edito
const { defaults, fitWindowWidth } = useAgentSettings();
const config = draftConfig(provider, draft, (provider && defaults[provider.id]) || {});
const homeRoot = useRef<HTMLDivElement>(null);
const { zoomStyle } = useAgentFontZoomSurface(homeRoot, input?.key ?? HOME_KEY, docked);
const unavailableModel = config.some(
(o) =>
o.category === "model" &&
@@ -127,7 +129,11 @@ export function HomeEditor({ docked = false }: { docked?: boolean; input?: Edito
};
return (
<div ref={homeRoot} className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}>
<div
ref={homeRoot}
className={clsx(styles.home, docked && styles.docked, fitWindowWidth && styles.fitWidth)}
style={zoomStyle}
>
<div className={styles.inner}>
{!docked && (
<h1 className={styles.heading}>
+88 -2
Переглянути файл
@@ -3,17 +3,20 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { clearMocks, mockIPC } from "@tauri-apps/api/mocks";
import { resetMermaidForTests } from "../viewers/markdown/mermaid";
import { StrictMode } from "react";
import { useProject } from "@/platform/project";
import type { SymbolMatch } from "@/platform/ipc";
import { Markdown, markdownBlocks, markdownHtml } from "./Markdown";
const { openFile, openExternalUrl } = vi.hoisted(() => ({
const { openFile, chooseDeclaration, openExternalUrl } = vi.hoisted(() => ({
openFile: vi.fn().mockResolvedValue(undefined),
chooseDeclaration: vi.fn().mockResolvedValue(undefined),
openExternalUrl: vi.fn().mockResolvedValue(undefined),
}));
const copyText = vi.hoisted(() => vi.fn());
const readImage = vi.fn<(path: string) => Promise<string>>();
const PIXEL = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
vi.mock("@/workbench/contributions", () => ({
editorService: () => ({ openFile }),
editorService: () => ({ openFile, chooseDeclaration }),
}));
vi.mock("@/platform/openUrl", () => ({ openExternalUrl }));
vi.mock("@/ui", async (importOriginal) => ({
@@ -349,3 +352,86 @@ describe("streamed replies", () => {
expect(container.textContent?.trim()).toBe("Something else");
});
});
describe("symbol links", () => {
const symbol = (name: string, path: string, line: number): SymbolMatch => ({
name,
kind: "class",
container: null,
path,
relPath: path.slice("/repo/".length),
range: { start: { line, col: 6 }, end: { line, col: 6 + name.length } },
score: 0,
indices: [],
});
const index = [
symbol("FooView", "/repo/src/view.ts", 4),
symbol("BarView", "/repo/src/bar.ts", 1),
symbol("BarView", "/repo/web/bar.ts", 9),
symbol("StreamView", "/repo/src/stream.ts", 2),
symbol("SinkView", "/repo/src/sink.ts", 1),
symbol("SinkView", "/repo/web/sink.ts", 7),
];
let lookups: string[][];
beforeEach(() => {
lookups = [];
useProject.setState({ project: { root: "/repo" } as never });
mockIPC((cmd, args) => {
if (cmd === "fs_probe") throw new Error("missing");
if (cmd !== "find_symbols_named") return null;
const { names } = args as { names: string[] };
lookups.push(names);
return index.filter((symbol) => names.includes(symbol.name));
});
});
afterEach(() => useProject.setState({ project: null }));
const code = (container: HTMLElement, text: string) =>
[...container.querySelectorAll<HTMLElement>("code")].find((span) => span.textContent === text)!;
it("opens the one definition a name has, and leaves other code plain", async () => {
const { container } = render(<Markdown text={"`FooView` runs `cargo test`, see `Missing`."} cwd="/repo/one" />);
await waitFor(() => expect(code(container, "FooView").dataset.path).toBe("/repo/src/view.ts"));
expect(code(container, "cargo test").dataset.path).toBeUndefined();
expect(code(container, "Missing").dataset.path).toBeUndefined();
expect(lookups).toEqual([["FooView", "Missing"]]);
fireEvent.click(code(container, "FooView"));
expect(openFile).toHaveBeenCalledWith("/repo/src/view.ts", { focus: true, selection: { line: 4, col: 6 } });
});
it("looks a streamed reply's names up once, after its text settles", async () => {
const reply = "First `StreamView`.\n\nThen `SinkView` in `web/sink.ts` and `StreamView` again.";
const { container, rerender } = render(<Markdown text={reply.slice(0, 10)} cwd="/repo/two" />);
for (let end = 12; end <= reply.length; end += 6) rerender(<Markdown text={reply.slice(0, end)} cwd="/repo/two" />);
rerender(<Markdown text={reply} cwd="/repo/two" />);
await waitFor(() => expect(code(container, "SinkView").dataset.path).toBe("/repo/web/sink.ts"));
expect(lookups).toEqual([["StreamView", "SinkView"]]);
rerender(<Markdown text={`${reply}\n\nDone with \`StreamView\`.`} cwd="/repo/two" />);
await new Promise((resolve) => setTimeout(resolve, 600));
expect(lookups).toHaveLength(1);
});
it("shows Go to Declaration's chooser when several files define the name", async () => {
const { container } = render(<Markdown text={"Both define `BarView`."} cwd="/repo" />);
await waitFor(() => expect(code(container, "BarView").className).not.toBe(""));
expect(code(container, "BarView").dataset.path).toBeUndefined();
fireEvent.click(code(container, "BarView"));
expect(openFile).not.toHaveBeenCalled();
expect(chooseDeclaration).toHaveBeenCalledWith(
[expect.objectContaining({ path: "/repo/src/bar.ts" }), expect.objectContaining({ path: "/repo/web/bar.ts" })],
"BarView",
expect.objectContaining({ x: expect.any(Number), y: expect.any(Number) }),
);
});
it("keeps a file a span names over a symbol of the same name", async () => {
mockIPC((cmd, args) => {
if (cmd === "fs_probe") return null;
if (cmd === "find_symbols_named") lookups.push((args as { names: string[] }).names);
return null;
});
const { container } = render(<Markdown text={"Open `Config.load`."} cwd="/repo/three" />);
await waitFor(() => expect(code(container, "Config.load").dataset.path).toBe("/repo/three/Config.load"));
});
});
+111 -12
Переглянути файл
@@ -1,25 +1,28 @@
/**
* Agent messages: Markdown → sanitized HTML (marked + DOMPurify). Fenced code is
* highlighted and gets a Copy button; inline code naming a file of the task opens it.
* highlighted and gets a Copy button; inline code naming a file of the task, or a symbol
* the index has, opens it.
* Mermaid fences become `[data-mermaid]` placeholders drawn by the Markdown viewer's
* shared renderer after each render; the block keeps a Copy button of its own, since
* the drawn diagram hides the code block, and `onDiagramDrawn` lets the conversation
* follow the end when a diagram draws after the last streamed chunk.
*/
import { useLayoutEffect, useRef, useSyncExternalStore } from "react";
import { useEffect, useLayoutEffect, useRef, useSyncExternalStore } from "react";
import { Marked } from "marked";
import DOMPurify from "dompurify";
import { highlightInto } from "@/editor/lsp/markdown";
import { iconNode } from "@/ui/iconNode";
import { tx } from "@/platform/i18n";
import { openExternalUrl } from "@/platform/openUrl";
import { useProject } from "@/platform/project";
import { copyText } from "@/ui";
import { editorService } from "@/workbench/contributions";
import { editorService, type DeclarationChoice } from "@/workbench/contributions";
import { hasMermaid, renderMermaidIn } from "@/features/viewers/markdown/mermaid";
import { subscribeTheme, themeKey } from "@/platform/themeWatch";
import { fileHref, pathLink, type PathLink } from "./conversation";
import { fileHref, pathLink, symbolRef, type PathLink, type SymbolRef } from "./conversation";
import { loadImages, type MessageImages } from "./markdownImages";
import { fileExists } from "./ReferenceChip";
import { inTaskFolder, lookupSymbols, symbolTargets } from "./symbolLinks";
import styles from "./Session.module.css";
const escapeHtml = (s: string) =>
@@ -172,6 +175,58 @@ export function openPathLink(link: PathLink) {
void editorService().openFile(link.path, { selection, focus: true });
}
/** The symbol each inline code span names. */
const symbolRefs = new WeakMap<Element, SymbolRef>();
/** Whether inline code that names a symbol also names an existing file (which it then opens). */
const fileChecks = new WeakMap<Element, Promise<boolean>>();
/** Inline code naming a symbol defined in several places: the chooser's targets. */
const choices = new WeakMap<Element, DeclarationChoice[]>();
/** How long a reply's text stays unchanged before its symbols are looked up. */
const SETTLE_MS = 400;
function mentionedPaths(root: HTMLElement): string[] {
const codePaths = [...root.querySelectorAll("code")].map((code) => pathLink(code.textContent ?? "", "")?.path);
const linkPaths = [...root.querySelectorAll("a[href]")].map(
(anchor) => fileHref(anchor.getAttribute("href") ?? "", "")?.path,
);
return [...codePaths, ...linkPaths].filter((path): path is string => !!path);
}
function markPath(element: HTMLElement, link: PathLink) {
element.classList.add(styles.fileLink!);
element.dataset.path = link.path;
if (link.line !== undefined) element.dataset.line = String(link.line);
if (link.col !== undefined) element.dataset.col = String(link.col);
element.title = tx`Open ${link.path}`;
}
/** Links `spans` of the reply in `root` to their definitions: one index lookup for all their names. */
async function linkSymbols(root: HTMLElement, spans: HTMLElement[], cwd: string) {
const projectRoot = useProject.getState().project?.root ?? cwd;
const refs = spans.map((code) => symbolRefs.get(code)!);
const answers = lookupSymbols(
projectRoot,
refs.map((ref) => ref.name),
);
const mentioned = mentionedPaths(root);
await Promise.all(
spans.map(async (code, at) => {
if (await fileChecks.get(code)) return;
const ref = refs[at]!;
const found = (await answers.get(ref.name)!).map((symbol) => inTaskFolder(symbol, projectRoot, cwd));
const targets = symbolTargets(ref, found, mentioned, cwd);
if (!code.isConnected || !targets.length) return;
if (targets.length > 1) {
code.classList.add(styles.fileLink!);
choices.set(code, targets);
return;
}
const { path, range } = targets[0]!;
markPath(code, { path, line: range.start.line, col: range.start.col });
}),
);
}
/** Highlighting, Copy buttons and file links over freshly rendered `root`. */
function enhance(root: HTMLElement, cwd: string, images: MessageImages): () => void {
let alive = true;
@@ -197,15 +252,15 @@ function enhance(root: HTMLElement, cwd: string, images: MessageImages): () => v
});
root.querySelectorAll<HTMLElement>("code").forEach((code) => {
if (code.parentElement?.tagName === "PRE" || code.closest("a")) return;
const link = pathLink(code.textContent ?? "", cwd);
const text = code.textContent ?? "";
const ref = symbolRef(text);
if (ref) symbolRefs.set(code, ref);
const link = pathLink(text, cwd);
if (!link) return;
void fileExists(link.path).then((exists) => {
if (!alive || !exists) return;
code.classList.add(styles.fileLink!);
code.dataset.path = link.path;
if (link.line !== undefined) code.dataset.line = String(link.line);
if (link.col !== undefined) code.dataset.col = String(link.col);
code.title = tx`Open ${link.path}`;
const exists = fileExists(link.path);
if (ref) fileChecks.set(code, exists);
void exists.then((found) => {
if (alive && found) markPath(code, link);
});
});
return () => {
@@ -276,6 +331,9 @@ export function Markdown({
const diagrams = useRef<Node[]>([]);
// Diagrams are drawn in the active theme's colours: a theme change redraws them.
const theme = useSyncExternalStore(subscribeTheme, themeKey, () => "");
useLayoutEffect(() => {
images.current.onLoaded = onDiagramDrawn;
}, [onDiagramDrawn]);
useLayoutEffect(() => {
const root = ref.current;
if (!root) return;
@@ -293,6 +351,39 @@ export function Markdown({
const blocks = painted.current;
return () => clearBlocks(blocks, 0);
}, []);
/** Symbol spans already looked up (or being looked up). */
const looked = useRef(new WeakSet<Element>());
// Symbols: once the text stops changing (a streamed reply changes its last block on every
// chunk), the spans not looked up yet, as they come into view.
useEffect(() => {
const root = ref.current;
if (!root) return;
let observer: IntersectionObserver | null = null;
const lookUp = (spans: HTMLElement[]) => {
spans.forEach((span) => looked.current.add(span));
if (spans.length) void linkSymbols(root, spans, cwd);
};
const timer = setTimeout(() => {
const spans = [...root.querySelectorAll<HTMLElement>("code")].filter(
(code) => symbolRefs.has(code) && !looked.current.has(code),
);
if (!spans.length) return;
if (typeof IntersectionObserver === "undefined") {
lookUp(spans);
return;
}
observer = new IntersectionObserver((entries) => {
const shown = entries.filter((entry) => entry.isIntersecting).map((entry) => entry.target as HTMLElement);
shown.forEach((span) => observer!.unobserve(span));
lookUp(shown);
});
spans.forEach((span) => observer!.observe(span));
}, SETTLE_MS);
return () => {
clearTimeout(timer);
observer?.disconnect();
};
}, [text, cwd]);
// Mermaid diagrams: before paint, so cached ones don't flash their source. Only a
// draw that lands after the render needs the follow — cached ones are in place by
// the time the conversation's own render pass scrolls.
@@ -318,6 +409,14 @@ export function Markdown({
void copyText(copy.dataset.copy ?? "");
return;
}
const code = target.closest<HTMLElement>("code");
const targets = code && choices.get(code);
if (targets && !window.getSelection()?.toString()) {
const rect = code.getBoundingClientRect();
const name = symbolRefs.get(code)!.name;
void editorService().chooseDeclaration?.(targets, name, { x: rect.left, y: rect.bottom + 2 });
return;
}
const file = target.closest<HTMLElement>("code[data-path]");
if (file && !window.getSelection()?.toString()) {
const line = file.dataset.line === undefined ? undefined : Number(file.dataset.line);
+4 -4
Переглянути файл
@@ -4,7 +4,7 @@
align-items: center;
gap: var(--space-1);
max-width: 100%;
height: 20px;
height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
padding: 0 6px 0 4px;
margin: 0 1px;
vertical-align: -4px;
@@ -12,8 +12,8 @@
background: color-mix(in srgb, var(--fg) 9%, transparent);
box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--fg) 14%, transparent);
color: var(--fg-strong);
font-size: var(--fs-small);
line-height: 20px;
font-size: var(--agent-fs-small, var(--fs-small));
line-height: calc(20px + max(0px, var(--agent-font-zoom, 0px)) * 1.4);
white-space: nowrap;
cursor: pointer;
user-select: none;
@@ -243,7 +243,7 @@
padding: 6px 10px;
color: var(--fg-editor);
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
line-height: 1.5;
white-space: pre;
overflow-x: auto;
+57 -32
Переглянути файл
@@ -1,6 +1,9 @@
.session {
--session-content-width: var(--agent-conversation-width);
--session-card-width: 80%;
--agent-fs-ui: calc(var(--fs-ui) + var(--agent-font-zoom, 0px));
--agent-fs-small: calc(var(--fs-small) + var(--agent-font-zoom, 0px));
--agent-fs-code: calc(var(--fs-code) + var(--agent-font-zoom, 0px));
flex: 1;
min-height: 0;
min-width: 0;
@@ -252,6 +255,7 @@
padding: var(--space-3);
display: flex;
flex-direction: column;
font-size: var(--agent-fs-ui, var(--fs-ui));
}
/* Actual row heights keep WebKit's scrollbar and cross-message selections anchored. */
.stream > * {
@@ -322,7 +326,7 @@
-webkit-user-select: none;
user-select: none;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: nowrap;
}
.messageHead > .role {
@@ -357,7 +361,7 @@
gap: 5px;
margin-bottom: 3px;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
@@ -551,7 +555,7 @@
}
.markdown :global(code) {
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
padding: 0 2px;
border-radius: 3px;
background: var(--md-code-bg);
@@ -620,12 +624,19 @@
display: none;
}
.markdown :global(.mermaid-output) {
overflow: hidden;
overflow-x: auto;
overflow-y: hidden;
text-align: center;
/* Node labels are drawing, not text: selecting across a reply skips them. */
-webkit-user-select: none;
user-select: none;
}
.markdown :global(.mermaid-output svg[data-natural-width]) {
display: block;
margin: 0 auto;
width: calc(min(var(--diagram-width), 100%) * var(--markdown-zoom-scale, 1));
height: auto;
}
.markdown :global([data-mermaid-state="error"] > .mermaid-output) {
margin-top: 6px;
padding: 6px 10px;
@@ -634,7 +645,7 @@
background: var(--bg-elev);
color: var(--danger);
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
text-align: left;
white-space: pre-wrap;
}
@@ -648,10 +659,17 @@
.markdown :global(ul),
.markdown :global(ol) {
--md-list-indent: 1.55em;
margin: 0 0 8px;
padding-left: 20px;
padding-left: var(--md-list-indent);
list-style: none;
}
.markdown :global(ol) {
--md-list-indent: 2.1em;
}
.markdown :global(ol:has(> li:nth-child(100))) {
--md-list-indent: 2.75em;
}
/* Markers are drawn as pseudo-elements: WebKit paints a selection box around a native marker,
leaving a broken stripe down the gutter when a list is selected. */
.markdown :global(li) {
@@ -659,7 +677,8 @@
}
.markdown :global(li)::before {
position: absolute;
right: calc(100% + 6px);
right: calc(100% + 0.45em);
white-space: nowrap;
-webkit-user-select: none;
user-select: none;
}
@@ -721,7 +740,11 @@
border-top: 1px solid var(--border);
}
.markdown :global(img) {
max-width: 100%;
max-width: calc(100% * var(--markdown-zoom-scale, 1));
}
.markdown :global(img[data-natural-width]) {
width: calc(min(var(--image-width), 100%) * var(--markdown-zoom-scale, 1));
height: auto;
}
.loadImage {
padding: 2px 8px;
@@ -736,7 +759,7 @@
background: var(--bg-hover);
}
.markdown :global(li:has(> input[type="checkbox"])) {
margin-left: -20px;
margin-left: calc(-1 * var(--md-list-indent));
}
.markdown :global(li:has(> input[type="checkbox"]))::before {
content: none;
@@ -762,9 +785,9 @@
align-items: center;
gap: var(--space-1);
min-width: 0;
height: var(--h-row);
min-height: var(--h-row);
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
@@ -817,7 +840,7 @@
}
.toolTitle {
min-width: 0;
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
@@ -830,7 +853,7 @@
}
.toolDiff {
font: inherit;
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
border: 0;
background: none;
padding: 0 4px;
@@ -861,7 +884,7 @@
padding: 0 calc(var(--space-2) / 2);
border-radius: var(--radius-row);
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
@@ -917,7 +940,7 @@
border: 1px solid var(--border);
background: var(--bg-elev);
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: pre-wrap;
overflow-wrap: anywhere;
color: var(--fg-secondary);
@@ -974,7 +997,7 @@
.permissionCommand {
min-width: 0;
max-width: 100%;
max-height: calc(var(--lh-code) * 6);
max-height: calc((var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6) * 6);
box-sizing: border-box;
margin: 0;
padding: var(--space-2);
@@ -984,8 +1007,8 @@
background: var(--bg-editor);
color: var(--fg);
font-family: var(--font-mono);
font-size: var(--fs-code);
line-height: var(--lh-code);
font-size: var(--agent-fs-code, var(--fs-code));
line-height: calc(var(--lh-code) + var(--agent-font-zoom, 0px) * 1.6);
white-space: pre-wrap;
overflow-wrap: anywhere;
tab-size: 2;
@@ -1023,7 +1046,7 @@
text-overflow: ellipsis;
white-space: nowrap;
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.permissionDone {
padding: calc(var(--space-2) / 2) 0;
@@ -1031,7 +1054,7 @@
border-radius: var(--radius-small);
background: none;
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.permissionRecord {
display: block;
@@ -1120,6 +1143,7 @@
padding: 0 4px 0 8px;
border-radius: var(--radius-row);
background: var(--bg-elev);
font-size: var(--agent-fs-ui, var(--fs-ui));
}
.queuedText {
flex: 1;
@@ -1212,7 +1236,7 @@
flex-wrap: wrap;
gap: var(--space-1) var(--space-1-5);
margin-top: 4px;
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.attachment {
display: inline-flex;
@@ -1425,7 +1449,7 @@
flex: none;
margin-left: auto;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
@@ -1433,7 +1457,7 @@
padding-left: 22px;
color: var(--fg-muted);
font-family: var(--font-mono);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
@@ -1441,7 +1465,7 @@
.subagentSection > summary {
padding-left: 22px;
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
cursor: pointer;
list-style: none;
}
@@ -1510,7 +1534,7 @@
.messageFrom {
margin-bottom: 2px;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.readOnly {
@@ -1567,6 +1591,7 @@
border: 1px solid var(--border-strong);
border-radius: var(--radius-control);
background: var(--bg-elev);
font-size: var(--agent-fs-ui, var(--fs-ui));
container: question-card / inline-size;
}
.questionTabCheck {
@@ -1617,7 +1642,7 @@
border-radius: var(--radius-small);
background: var(--bg-hover);
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionLabel .questionTag {
margin: 0 0 0 8px;
@@ -1674,13 +1699,13 @@
}
.questionDescription {
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
overflow-wrap: anywhere;
}
.questionKey {
flex: none;
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionOther {
margin: 2px 0 0 30px;
@@ -1725,7 +1750,7 @@
}
.questionPreviewCaption {
color: var(--fg-muted);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionPreviewBody {
margin: 0;
@@ -1735,14 +1760,14 @@
border-radius: var(--radius-small);
background: var(--bg-editor);
font-family: var(--font-mono);
font-size: var(--fs-code);
font-size: var(--agent-fs-code, var(--fs-code));
}
.questionPreviewEmpty {
padding: 8px;
border: 1px dashed var(--border);
border-radius: var(--radius-small);
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
}
.questionActions {
display: flex;
@@ -1758,7 +1783,7 @@
}
.questionPage {
color: var(--fg-subtle);
font-size: var(--fs-small);
font-size: var(--agent-fs-small, var(--fs-small));
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
+40 -13
Переглянути файл
@@ -81,6 +81,7 @@ import {
} from "./composerModel";
import { ConfigPickers } from "./ConfigPickers";
import { useEffortFocus } from "./effortFocus";
import { useAgentFontZoomSurface } from "./fontZoom";
import { findRanges, formatDuration, formatSentAt, isFindRangeShown } from "./conversation";
import { ImagePreview, imageSrc } from "./ImagePreview";
import { useAgentSettings } from "./agentSettings";
@@ -115,6 +116,7 @@ import {
hasTaskTerminal,
isBusy,
providerIcon,
sessionKey,
statusLabel,
subagentStatusLabel,
subagentTitle,
@@ -223,6 +225,7 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
const [inputFocus, setInputFocus] = useState(0);
const { fitWindowWidth } = useAgentSettings();
const sessionRoot = useRef<HTMLDivElement>(null);
const { fontZoom, zoomStyle } = useAgentFontZoomSurface(sessionRoot, sessionKey(id), docked, !!task);
const canFocusInput = shown && !!task && task.status !== "archived" && !view;
const session = useMemo<FocusedSession>(
() => ({
@@ -255,7 +258,7 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
changesOpen && !docked && styles.withChanges,
fitWindowWidth && styles.fitWidth,
)}
style={changesWidth}
style={{ ...changesWidth, ...zoomStyle }}
onFocusCapture={() => shown && setFocusedSession(session)}
onBlurCapture={(e) => {
if (!e.currentTarget.contains(e.relatedTarget as Node | null) && focusedSession() === session) {
@@ -291,6 +294,7 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
onOpenSubagent={openSubagent}
finding={finding && shown}
findFocus={findFocus}
fontZoom={fontZoom}
onCloseFind={() => setFinding(false)}
/>
</FoldedContent.Provider>
@@ -611,9 +615,10 @@ function useOffscreenRows(
visible: boolean,
enabled: boolean,
fitWindowWidth: boolean,
fontZoom: number,
) {
// The container width and column mode the marked rows were laid out at.
const measured = useRef<{ width: number; fitWindowWidth: boolean } | null>(null);
// The container width, column mode and font zoom the marked rows were laid out at.
const measured = useRef<{ width: number; fitWindowWidth: boolean; fontZoom: number } | null>(null);
useLayoutEffect(() => {
const el = ref.current;
if (!el) return;
@@ -628,10 +633,15 @@ function useOffscreenRows(
return;
}
if (!visible) return;
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
measured.current = { width: el.clientWidth, fitWindowWidth };
if (
measured.current?.width === el.clientWidth &&
measured.current.fitWindowWidth === fitWindowWidth &&
measured.current.fontZoom === fontZoom
)
return;
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
unmark();
}, [ref, visible, enabled, fitWindowWidth]);
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
useEffect(() => {
const el = ref.current;
if (!el || !enabled || !visible) return;
@@ -654,8 +664,13 @@ function useOffscreenRows(
});
};
const remeasure = () => {
if (measured.current?.width === el.clientWidth && measured.current.fitWindowWidth === fitWindowWidth) return;
measured.current = { width: el.clientWidth, fitWindowWidth };
if (
measured.current?.width === el.clientWidth &&
measured.current.fitWindowWidth === fitWindowWidth &&
measured.current.fontZoom === fontZoom
)
return;
measured.current = { width: el.clientWidth, fitWindowWidth, fontZoom };
unmark();
};
remeasure();
@@ -676,7 +691,7 @@ function useOffscreenRows(
rows.disconnect();
resize.disconnect();
};
}, [ref, visible, enabled, fitWindowWidth]);
}, [ref, visible, enabled, fitWindowWidth, fontZoom]);
}
interface StreamProps {
@@ -689,6 +704,7 @@ interface StreamProps {
finding: boolean;
/** Bumped by Find in Conversation: focus the find field again. */
findFocus: number;
fontZoom: number;
onCloseFind: () => void;
}
@@ -704,7 +720,17 @@ function scrollsInside(target: EventTarget | null, root: HTMLElement): boolean {
return false;
}
function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, findFocus, onCloseFind }: StreamProps) {
function Stream({
loadError,
task,
entries,
subagent,
onOpenSubagent,
finding,
findFocus,
fontZoom,
onCloseFind,
}: StreamProps) {
const ref = useRef<HTMLDivElement>(null);
useSelectionBoundary(ref);
const [openFolds] = useState(() => new Map<string, boolean>());
@@ -799,7 +825,7 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
// Hidden behind another tab, it has no layout to scroll; shown again, it follows the end again.
const visible = useEditorShown();
const { foldTurns, toolCalls, fitWindowWidth } = useAgentSettings();
useOffscreenRows(ref, visible, !finding, fitWindowWidth);
useOffscreenRows(ref, visible, !finding, fitWindowWidth, fontZoom);
/** A diagram that drew after the last streamed chunk grows the conversation: keep following. */
const onDiagramDrawn = useCallback(() => {
const el = ref.current;
@@ -968,9 +994,10 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
className={clsx(styles.stream, selectableText)}
tabIndex={-1}
onWheel={(e) => {
if (e.defaultPrevented) return;
markUserScroll();
if (e.deltaY < 0 && !e.ctrlKey && !e.defaultPrevented) stopFollowing(e.target);
else if (e.deltaY > 0 && !e.ctrlKey && !e.defaultPrevented) scrollingUp.current = false;
if (e.deltaY < 0 && !e.ctrlKey && !e.metaKey) stopFollowing(e.target);
else if (e.deltaY > 0 && !e.ctrlKey && !e.metaKey) scrollingUp.current = false;
}}
onTouchStart={(e) => {
touchY.current = e.touches.length === 1 ? e.touches[0]!.clientY : null;
+39
Переглянути файл
@@ -7,6 +7,7 @@ import {
isFindRangeShown,
pathLink,
quoteText,
symbolRef,
withQuote,
} from "./conversation";
@@ -46,6 +47,44 @@ describe("pathLink", () => {
});
});
describe("symbolRef", () => {
it("reads the forms a reply names a symbol in", () => {
expect(symbolRef("FooView")).toMatchObject({ name: "FooView", kinds: expect.arrayContaining(["class"]) });
expect(symbolRef("load()")).toMatchObject({ name: "load", kinds: ["function", "method", "constructor"] });
expect(symbolRef("validate(input)")).toMatchObject({ name: "validate" });
expect(symbolRef("has_header")).toMatchObject({ name: "has_header", kinds: ["function", "method", "constructor"] });
expect(symbolRef("loadConfig")).toMatchObject({ name: "loadConfig" });
expect(symbolRef("Config.load")).toMatchObject({ name: "load", container: "Config" });
expect(symbolRef("Config::load()")).toMatchObject({ name: "load", container: "Config" });
expect(symbolRef("lib.rs::has_header")).toMatchObject({ name: "has_header", file: "lib.rs" });
expect(symbolRef("src/a.ts#load")).toMatchObject({ name: "load", file: "src/a.ts" });
});
it("leaves words, keywords, literals, commands and code plain", () => {
for (const text of [
"true",
"null",
"inventory",
"None",
"False",
"Self",
"Some(x)",
"None.value",
"42",
"1.5",
"cargo test",
"git log --oneline",
"x = 1",
"a && b",
"$HOME",
"foo(bar(1))",
"TODO",
"src/",
]) {
expect(symbolRef(text)).toBeNull();
}
});
});
describe("fileHref", () => {
const cwd = "C:/repo";
it("resolves a link against the task folder", () => {
+44 -1
Переглянути файл
@@ -1,5 +1,6 @@
/** Reading an agent conversation: quoting, file links, turn times and finding text. */
/** Reading an agent conversation: quoting, file and symbol links, turn times and finding text. */
import type { SymbolKind } from "@/platform/ipc";
import { opensOtherShare } from "@/platform/paths";
/** `text` as a Markdown quote for the composer, followed by an empty line to type in. */
@@ -64,6 +65,48 @@ export function pathLink(text: string, cwd: string): PathLink | null {
return out;
}
/** A symbol an inline code span names: `name`, inside `container` or `file` when the text says so. */
export interface SymbolRef {
name: string;
container?: string;
/** The tail of the defining file's path (`lib.rs`, `src/a.ts`). */
file?: string;
kinds: readonly SymbolKind[];
}
const IDENT = "[A-Za-z_$][\\w$]*";
const CALL = "(\\([^()]*\\))?";
const SYMBOL = new RegExp(`^(?:(${IDENT})(?:\\.|#|::))?(${IDENT})${CALL}$`);
const FILE_SYMBOL = new RegExp(`^((?:[\\w.@-]+\\/)*[\\w@-]+\\.[A-Za-z]\\w*)(?:#|::)(${IDENT})${CALL}$`);
const TYPE_KINDS: readonly SymbolKind[] = ["class", "interface", "struct", "enum", "trait", "typeAlias", "function"];
const CALLABLE_KINDS: readonly SymbolKind[] = ["function", "method", "constructor"];
const MEMBER_KINDS: readonly SymbolKind[] = [...CALLABLE_KINDS, "field", "property", "constant", "enumMember"];
const ANY_KINDS: readonly SymbolKind[] = [...new Set<SymbolKind>([...TYPE_KINDS, ...MEMBER_KINDS, "variable"])];
/** Capitalized keywords and literals that read like a type name. */
const LITERALS = new Set(["None", "True", "False", "Self", "Some", "Ok", "Err", "Null", "Nil", "NaN", "Infinity"]);
/**
* The symbol inline code names (`FooView`, `load()`, `has_header`, `Config.load`,
* `lib.rs::has_header`, `a.ts#load`); null for words, keywords, literals and anything
* with spaces or shell syntax (`cargo test`, `true`, `None`, `x = 1`).
*/
export function symbolRef(text: string): SymbolRef | null {
const trimmed = text.trim();
const inFile = FILE_SYMBOL.exec(trimmed);
if (inFile) return { name: inFile[2]!, file: inFile[1]!, kinds: ANY_KINDS };
const match = SYMBOL.exec(trimmed);
if (!match) return null;
const [, container, name, call] = match;
if (LITERALS.has(container ?? name!)) return null;
if (container) return { name: name!, container, kinds: MEMBER_KINDS };
if (call) return { name: name!, kinds: CALLABLE_KINDS };
if (/^[A-Z]\w*[a-z]/.test(name!)) return { name: name!, kinds: TYPE_KINDS };
if (/^[a-z]\w*[a-z\d][A-Z]/.test(name!) || /^[a-z][a-z\d]*(?:_[a-z\d]+)+$/.test(name!)) {
return { name: name!, kinds: CALLABLE_KINDS };
}
return null;
}
/** `850ms`, `12s`, `1m 05s`, `2h 03m`. */
export function formatDuration(ms: number): string {
if (ms < 1000) return `${Math.max(0, Math.round(ms))}ms`;
+380
Переглянути файл
@@ -0,0 +1,380 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { act, cleanup, render } from "@testing-library/react";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import type { AgentEntry, AgentTask } from "@/bindings";
import { _addEditor, _removeEditor, type EditorDocContext } from "@/editor/api";
import { fontZoom as cmFontZoom, resetAllEditorsFontZoom } from "@/editor/core/cm/prefs";
import type { EditorSlot } from "@/editor/core/model/slot";
import { executeAction } from "@/platform/actions";
import { useContextKeys } from "@/platform/context";
import { useProject } from "@/platform/project";
import { EditorShownProvider, EditorTabIdProvider } from "@/workbench/contributions";
import { HomeEditor } from "./HomeEditor";
import { SessionEditor } from "./SessionEditor";
import {
clearAgentTabFontZoom,
clearAgentTaskFontZoom,
resetAllAgentFontZoom,
stepAgentSurfaceFontZoom,
useAgentFontZoom,
} from "./fontZoom";
import { SESSION_KIND, sessionKey } from "./model";
import { disconnect, useAgents } from "./store";
import styles from "./Session.module.css";
let activeSlot: Partial<EditorSlot> | null = null;
const imageReads = new Map<string, string>();
vi.mock("@/editor/core/controller", async (importOriginal) => ({
...(await importOriginal<object>()),
editorController: () => ({
get activeSlot() {
return activeSlot;
},
}),
}));
vi.mock("@tauri-apps/api/webview", () => ({
getCurrentWebview: () => ({
onDragDropEvent: () => Promise.resolve(() => {}),
}),
}));
vi.mock("@/platform/ipc", async (original) => ({
...(await original<typeof import("@/platform/ipc")>()),
commands: {
fsProbe: async () => ({
status: "ok",
data: { size: 1, binary: false, tooLarge: false },
}),
fsReadImage: async (path: string) => {
const url = imageReads.get(path);
if (url) return { status: "ok", data: url };
return { status: "error", error: { kind: "notFound", message: path } };
},
agentEntries: async () => ({ status: "ok", data: [] as AgentEntry[] }),
agentChanges: async () => ({ status: "ok", data: [] }),
agentGroupedChanges: async () => ({ status: "ok", data: { uncommitted: [], commits: [] } }),
agentProviders: async () => ({ status: "ok", data: [] }),
vcsBranchInfo: async () => ({ status: "ok", data: { head: "main" } }),
vcsBranches: async () => ({ status: "ok", data: [] }),
},
}));
const { registerEditorActions } = await import("@/editor/core/actions");
const { useTabs } = await import("@/editor/core/controller");
const makeTask = (id: string): AgentTask => ({
id,
title: id,
provider: "copilot",
status: "ready",
isolation: "local",
model: null,
cwd: "/project",
branch: null,
base: null,
baseCommit: null,
error: null,
createdMs: 0,
updatedMs: 0,
config: [],
commands: [],
usage: null,
queue: [],
});
describe("Agent chat font size zoom", () => {
const disposers: Array<() => void> = [];
const views: EditorView[] = [];
beforeEach(() => {
resetAllEditorsFontZoom();
resetAllAgentFontZoom();
imageReads.clear();
disposers.push(registerEditorActions());
useContextKeys.setState({ projectOpen: true, textEditorActive: false, editorFocus: true, popupOpen: false });
useProject.setState({
project: { name: "openidea", root: "/project", isGit: true, workspace: null } as never,
settings: null,
});
const t1 = makeTask("t1");
const t2 = makeTask("t2");
useAgents.setState({
loaded: true,
tasks: new Map([
[t1.id, t1],
[t2.id, t2],
]),
entries: new Map([
[t1.id, [{ type: "agent", text: "Hello `world`" }]],
[t2.id, [{ type: "agent", text: "Second task" }]],
]),
});
});
afterEach(() => {
cleanup();
for (const view of views.splice(0)) view.destroy();
for (const dispose of disposers.splice(0).reverse()) dispose();
activeSlot = null;
disconnect();
resetAllAgentFontZoom();
useProject.setState({ project: null, settings: null });
useContextKeys.setState({}, true);
});
it("scales only the focused Agent chat tab with ⌘=/⌘-/⌘0, clamped to -6..36, leaving other chat tabs untouched", async () => {
const { container } = render(
<div>
<div data-pane-id="left">
<div data-editor-focus="" tabIndex={-1}>
<EditorTabIdProvider value="tab-1">
<EditorShownProvider value={true}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
<EditorTabIdProvider value="tab-kept">
<EditorShownProvider value={false}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t2"), data: { task: "t2" } }} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
<div data-pane-id="right">
<div data-editor-focus="" tabIndex={-1}>
<EditorTabIdProvider value="tab-2">
<EditorShownProvider value={true}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
</div>
<HomeEditor docked />
</div>,
);
act(() => useTabs.setState((s) => ({ ...s, activePane: "left" })));
const sessions = container.querySelectorAll<HTMLElement>(`.${styles.session}`);
const leftSession = sessions[0]!;
const keptSession = sessions[1]!;
const rightSession = sessions[2]!;
const home = container.querySelector<HTMLElement>('[class*="home"]')!;
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(home.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
// Works when the composer's CodeMirror input in tab-1 has focus — only tab-1 changes.
leftSession.querySelector<HTMLElement>(".cm-content")!.focus();
await act(() => executeAction("editor.increaseFontSize"));
await act(() => executeAction("editor.increaseFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
expect(leftSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("1.1538");
expect(keptSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(home.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
// Focusing right split tab-2 (even showing the same task t1) zooms only tab-2.
rightSession.querySelector<HTMLElement>(".cm-content")!.focus();
await act(() => executeAction("editor.decreaseFontSize"));
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("-1px");
expect(rightSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("0.9231");
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
// ⌘0 while focused in tab-2 resets only tab-2, keeping tab-1 at +2px.
await act(() => executeAction("editor.resetFontSize"));
expect(rightSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
// Works when the active pane's KindEditor [data-editor-focus] wrapper or body has focus.
const leftWrapper = container.querySelector<HTMLElement>('[data-pane-id="left"] [data-editor-focus]')!;
leftWrapper.focus();
await act(() => executeAction("editor.increaseFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("3px");
document.body.focus();
await act(() => executeAction("editor.decreaseFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("2px");
// Clamped to -6..36.
act(() => stepAgentSurfaceFontZoom("tab:tab-1", 100));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(36);
await act(() => executeAction("editor.increaseFontSize"));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(36);
act(() => stepAgentSurfaceFontZoom("tab:tab-1", -100));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(-6);
await act(() => executeAction("editor.decreaseFontSize"));
expect(useAgentFontZoom.getState().bySurface["tab:tab-1"]).toBe(-6);
// ⌘0 on the active pane resets tab-1.
await act(() => executeAction("editor.resetFontSize"));
expect(leftSession.style.getPropertyValue("--agent-font-zoom")).toBe("0px");
expect(leftSession.style.getPropertyValue("--markdown-zoom-scale")).toBe("1");
});
it("isolates docked Agent chat and code editor resets from each other", async () => {
const ctx: EditorDocContext = {
doc: 1,
path: "/project/a.ts",
language: "typescript",
uiMode: null,
readOnly: false,
};
const view = new EditorView({ state: EditorState.create({ doc: "const x = 1;", extensions: [cmFontZoom] }) });
document.body.appendChild(view.dom);
const handle = { view, ctx };
_addEditor(handle);
disposers.push(() => {
_removeEditor(handle);
view.dom.remove();
});
views.push(view);
activeSlot = { view, disposed: false };
const { container } = render(
<SessionEditor docked input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />,
);
const stream = container.querySelector<HTMLElement>(`.${styles.stream}`)!;
// Zoom code editor first (+2), then zoom docked chat (+1).
view.contentDOM.focus();
await act(() => executeAction("editor.increaseFontSize"));
await act(() => executeAction("editor.increaseFontSize"));
expect(view.state.field(cmFontZoom)).toBe(2);
stream.focus();
await act(() => executeAction("editor.increaseFontSize"));
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBe(1);
expect(view.state.field(cmFontZoom)).toBe(2);
// Resetting in code editor leaves docked chat at +1.
view.contentDOM.focus();
await act(() => executeAction("editor.resetFontSize"));
expect(view.state.field(cmFontZoom)).toBe(0);
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBe(1);
// Zoom code editor again (+1); resetting in docked chat leaves code editor at +1.
await act(() => executeAction("editor.increaseFontSize"));
expect(view.state.field(cmFontZoom)).toBe(1);
stream.focus();
await act(() => executeAction("editor.resetFontSize"));
expect(useAgentFontZoom.getState().bySurface["docked:agent:t1"]).toBeUndefined();
expect(view.state.field(cmFontZoom)).toBe(1);
});
it("zooms with ⌘/Ctrl+wheel only on the hovered chat tab when editor.general.wheelZoom is enabled", () => {
const { container } = render(
<div>
<EditorTabIdProvider value="tab-1">
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorTabIdProvider>
<EditorTabIdProvider value="tab-2">
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t2"), data: { task: "t2" } }} />
</EditorTabIdProvider>
</div>,
);
const streams = container.querySelectorAll<HTMLElement>(`.${styles.stream}`);
const stream1 = streams[0]!;
const offEvent = new WheelEvent("wheel", { bubbles: true, cancelable: true, metaKey: true, deltaY: -100 });
act(() => {
stream1.dispatchEvent(offEvent);
});
expect(offEvent.defaultPrevented).toBe(false);
expect(useAgentFontZoom.getState().bySurface).toEqual({});
act(() =>
useProject.setState((s) => ({
...s,
settings: { editor: { general: { wheelZoom: true } } } as never,
})),
);
const up = new WheelEvent("wheel", { bubbles: true, cancelable: true, metaKey: true, deltaY: -100 });
act(() => {
stream1.dispatchEvent(up);
});
expect(up.defaultPrevented).toBe(true);
expect(useAgentFontZoom.getState().bySurface).toEqual({ "tab:tab-1": 1 });
const down = new WheelEvent("wheel", { bubbles: true, cancelable: true, ctrlKey: true, deltaY: 100 });
act(() => {
stream1.dispatchEvent(down);
});
expect(down.defaultPrevented).toBe(true);
expect(useAgentFontZoom.getState().bySurface).toEqual({});
const plain = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: -100 });
act(() => {
stream1.dispatchEvent(plain);
});
expect(plain.defaultPrevented).toBe(false);
});
it("sizes SVG and raster images in replies so they scale with --markdown-zoom-scale", async () => {
const svgUrl = `data:image/svg+xml;base64,${btoa('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 120"></svg>')}`;
const pngUrl = "data:image/png;base64,iVBORw0KGgo=";
imageReads.set("/project/diagram.svg", svgUrl);
imageReads.set("/project/shot.png", pngUrl);
act(() =>
useAgents.setState((s) => ({
...s,
entries: new Map([["t1", [{ type: "agent", text: "![Diagram](diagram.svg)\n\n![Shot](shot.png)" }]]]),
})),
);
const { container } = render(
<EditorShownProvider value={true}>
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
</EditorShownProvider>,
);
await vi.waitFor(() => {
const diag = container.querySelector<HTMLImageElement>('img[alt="Diagram"]');
expect(diag?.getAttribute("src")).toBe(svgUrl);
});
const diag = container.querySelector<HTMLImageElement>('img[alt="Diagram"]')!;
expect(diag.hasAttribute("data-natural-width")).toBe(true);
expect(diag.style.getPropertyValue("--image-width")).toBe("320px");
const shot = container.querySelector<HTMLImageElement>('img[alt="Shot"]')!;
Object.defineProperty(shot, "naturalWidth", { value: 640, configurable: true });
Object.defineProperty(shot, "naturalHeight", { value: 360, configurable: true });
act(() => {
shot.dispatchEvent(new Event("load"));
});
expect(shot.hasAttribute("data-natural-width")).toBe(true);
expect(shot.style.getPropertyValue("--image-width")).toBe("640px");
});
it("prunes bySurface entries when a tab closes or a task is removed", () => {
stepAgentSurfaceFontZoom("tab:tab-a", 4);
stepAgentSurfaceFontZoom("tab:tab-b", -2);
stepAgentSurfaceFontZoom("docked:agent:t1", 3);
stepAgentSurfaceFontZoom("agent:t1", 2);
expect(useAgentFontZoom.getState().bySurface).toEqual({
"tab:tab-a": 4,
"tab:tab-b": -2,
"docked:agent:t1": 3,
"agent:t1": 2,
});
clearAgentTabFontZoom("tab-a");
expect(useAgentFontZoom.getState().bySurface).toEqual({
"tab:tab-b": -2,
"docked:agent:t1": 3,
"agent:t1": 2,
});
clearAgentTaskFontZoom("agent:t1");
expect(useAgentFontZoom.getState().bySurface).toEqual({
"tab:tab-b": -2,
});
});
});
+95
Переглянути файл
@@ -0,0 +1,95 @@
import { useEffect, type CSSProperties, type RefObject } from "react";
import { create } from "zustand";
import { editorPrefs } from "@/platform/editorSettings";
import { useProject } from "@/platform/project";
import { registerFontZoomSurface, useEditorShown, useEditorTabId, useToolWindowShown } from "@/workbench/contributions";
const MIN_FONT_ZOOM = -6;
const MAX_FONT_ZOOM = 36;
const DEFAULT_UI_FONT_SIZE = 13;
export const useAgentFontZoom = create<{ bySurface: Record<string, number> }>(() => ({ bySurface: {} }));
export function agentSurfaceZoomKey(fallbackKey: string, docked: boolean, tabId: string | null): string {
if (docked) return `docked:${fallbackKey}`;
return tabId ? `tab:${tabId}` : fallbackKey;
}
/** Steps one Agent chat surface's font zoom by `delta` px (-6..36), or resets it when `delta === 0`. */
export function stepAgentSurfaceFontZoom(surfaceKey: string, delta: number): void {
useAgentFontZoom.setState((s) => {
const current = s.bySurface[surfaceKey] ?? 0;
const next = delta === 0 ? 0 : Math.max(MIN_FONT_ZOOM, Math.min(MAX_FONT_ZOOM, current + delta));
if (next === current) return s;
if (next === 0) {
const { [surfaceKey]: _, ...rest } = s.bySurface;
return { bySurface: rest };
}
return { bySurface: { ...s.bySurface, [surfaceKey]: next } };
});
}
export function clearAgentTabFontZoom(tabId: string): void {
stepAgentSurfaceFontZoom(`tab:${tabId}`, 0);
}
export function clearAgentTaskFontZoom(taskKey: string): void {
useAgentFontZoom.setState((s) => {
const dockedKey = `docked:${taskKey}`;
if (!(taskKey in s.bySurface) && !(dockedKey in s.bySurface)) return s;
const { [taskKey]: _a, [dockedKey]: _b, ...rest } = s.bySurface;
return { bySurface: rest };
});
}
export function resetAllAgentFontZoom(): void {
useAgentFontZoom.setState({ bySurface: {} });
}
function uiFontSizeOf(settings: unknown): number {
if (!settings || typeof settings !== "object") return DEFAULT_UI_FONT_SIZE;
const a = (settings as { appearance?: { useCustomFont?: unknown; uiFontSize?: unknown } }).appearance;
return a?.useCustomFont && typeof a.uiFontSize === "number" && a.uiFontSize > 0 ? a.uiFontSize : DEFAULT_UI_FONT_SIZE;
}
/**
* Wires per-tab keyboard font zoom (`editor.increaseFontSize` / `decreaseFontSize` / `resetFontSize`)
* and `⌘/Ctrl+wheel` (when `editor.general.wheelZoom` is on) to an Agent chat surface.
*/
export function useAgentFontZoomSurface(
ref: RefObject<HTMLElement | null>,
fallbackKey: string,
docked: boolean,
enabled = true,
): { fontZoom: number; zoomStyle: CSSProperties } {
const editorShown = useEditorShown();
const toolWindowShown = useToolWindowShown();
const tabId = useEditorTabId();
const surfaceKey = agentSurfaceZoomKey(fallbackKey, docked, tabId);
const active = enabled && (docked ? toolWindowShown : editorShown);
const fontZoom = useAgentFontZoom((s) => s.bySurface[surfaceKey] ?? 0);
const baseSize = useProject((s) => uiFontSizeOf(s.settings));
useEffect(() => {
const el = ref.current;
if (!active || !el) return;
const step = (delta: number) => stepAgentSurfaceFontZoom(surfaceKey, delta);
const onWheel = (e: WheelEvent) => {
if ((!e.ctrlKey && !e.metaKey) || e.deltaY === 0 || !editorPrefs().general.wheelZoom) return;
e.preventDefault();
e.stopPropagation();
step(e.deltaY < 0 ? 1 : -1);
};
el.addEventListener("wheel", onWheel, { capture: true, passive: false });
const release = registerFontZoomSurface(el, step, { isolated: true });
return () => {
el.removeEventListener("wheel", onWheel, { capture: true });
release();
};
}, [ref, active, surfaceKey]);
const zoomScale = Number((Math.max(4, baseSize + fontZoom) / baseSize).toFixed(4));
const zoomStyle = {
"--agent-font-zoom": `${fontZoom}px`,
"--markdown-zoom-scale": String(zoomScale),
} as CSSProperties;
return { fontZoom, zoomStyle };
}
+3
Переглянути файл
@@ -38,6 +38,7 @@ import {
import { sendPaths, sendSelection, trackEditorCopies } from "./references";
import { focusedSession } from "./sessionFocus";
import { cycleFocusedEffort } from "./effortFocus";
import { clearAgentTabFontZoom } from "./fontZoom";
import {
closeActiveTask,
closeAndNewTask,
@@ -188,6 +189,7 @@ export function activate(): () => void {
const s = useAgents.getState();
if (s.ephemeral.has(task) && s.docked !== task) void discardEphemeral(task);
},
onTabClose: (tabId) => clearAgentTabFontZoom(tabId),
// Rebuilding a long conversation on every switch back is slow.
keepAlive: true,
}),
@@ -199,6 +201,7 @@ export function activate(): () => void {
const task = useAgents.getState().tasks.get((input.data as { task: string }).task);
return task ? providerIcon(task.provider) : "toolwindow-agents";
},
onTabClose: (tabId) => clearAgentTabFontZoom(tabId),
restorable: true,
}),
// An explicit editor drop sets the placement for subsequent sessions too.
+35 -6
Переглянути файл
@@ -1,6 +1,7 @@
import { call, commands } from "@/platform/ipc";
import { ipcPath } from "@/platform/paths";
import { tx } from "@/platform/i18n";
import { applyImageZoomWidth, svgDataUrlSize } from "@/ui/svgSize";
import styles from "./Session.module.css";
const hasControl = (text: string) => [...text].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127);
@@ -39,16 +40,41 @@ export function imageTarget(source: string, cwd: string): ImageTarget | null {
}
/** What one message has loaded: streaming reuses it, later replies read a new QR at the same path and ask again. */
export type MessageImages = { reads: Map<string, Promise<string>>; asked: Set<string> };
export type MessageImages = {
reads: Map<string, Promise<string>>;
asked: Set<string>;
onLoaded?: () => void;
};
export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: MessageImages): () => void {
export function loadImages(root: HTMLElement, cwd: string, imagesState: MessageImages): () => void {
const { reads, asked } = imagesState;
let alive = true;
const held: HTMLButtonElement[] = [];
const images = [...root.querySelectorAll<HTMLImageElement>("img")];
const bindUrl = (img: HTMLImageElement, url: string, asyncLoad: boolean) => {
const svgSize = svgDataUrlSize(url);
if (svgSize && applyImageZoomWidth(img, svgSize) && asyncLoad) imagesState.onLoaded?.();
img.onload = () => {
if (!alive) return;
if (!img.hasAttribute("data-natural-width") && img.naturalWidth > 0 && img.naturalHeight > 0) {
if (applyImageZoomWidth(img, { w: img.naturalWidth, h: img.naturalHeight }) && asyncLoad) {
imagesState.onLoaded?.();
}
} else if (asyncLoad) {
imagesState.onLoaded?.();
}
};
img.src = url;
if (!img.hasAttribute("data-natural-width") && img.complete && img.naturalWidth > 0 && img.naturalHeight > 0) {
applyImageZoomWidth(img, { w: img.naturalWidth, h: img.naturalHeight });
}
};
for (const img of images) {
applyImageZoomWidth(img);
const source = img.dataset.imageSrc ?? "";
const fail = () => {
if (!alive) return;
img.onload = null;
img.onerror = null;
img.removeAttribute("src");
img.alt = tx`Unable to load image: ${source}`;
@@ -62,7 +88,7 @@ export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: Mes
const { url } = target;
if (/^data:/i.test(url) || asked.has(url)) {
img.hidden = false;
img.src = url;
bindUrl(img, url, false);
} else {
// A reply can be steered into naming an address that carries data out: the user decides.
// That holds for this machine too, where a server may pass the request on.
@@ -75,7 +101,7 @@ export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: Mes
asked.add(url);
load.remove();
img.hidden = false;
img.src = url;
bindUrl(img, url, true);
};
img.hidden = true;
img.before(load);
@@ -89,13 +115,16 @@ export function loadImages(root: HTMLElement, cwd: string, { reads, asked }: Mes
void pending.catch(() => reads.delete(target.path));
}
void pending.then((url) => {
if (alive) img.src = url;
if (alive) bindUrl(img, url, true);
}, fail);
}
}
return () => {
alive = false;
for (const img of images) img.onerror = null;
for (const img of images) {
img.onload = null;
img.onerror = null;
}
for (const load of held) load.remove();
};
}
+4
Переглянути файл
@@ -20,6 +20,7 @@ import type {
Isolation,
} from "@/bindings";
import { useChangesOptions } from "./changesOptions";
import { clearAgentTaskFontZoom, resetAllAgentFontZoom } from "./fontZoom";
import { basename, useProject } from "@/platform/project";
import { defaultTaskProject } from "./project";
import { call, commands, isTauri } from "@/platform/ipc";
@@ -518,6 +519,7 @@ export function disconnect() {
arrivedWhileLoading.clear();
streamingReply.clear();
modelFlights.clear();
resetAllAgentFontZoom();
useAgents.setState({
loaded: false,
error: null,
@@ -576,6 +578,7 @@ function onEvent(e: AgentEvent) {
organize,
...(s.docked === e.id ? { docked: null } : {}),
});
clearAgentTaskFontZoom(sessionKey(e.id));
void editorService().closeInput?.(sessionKey(e.id));
break;
}
@@ -1274,6 +1277,7 @@ export async function discardEphemeral(task: string): Promise<void> {
lastComposer: state.lastComposer === task ? HOME : state.lastComposer,
};
});
clearAgentTaskFontZoom(sessionKey(task));
void editorService().closeInput?.(sessionKey(task));
}
+81
Переглянути файл
@@ -0,0 +1,81 @@
import { afterEach, describe, expect, it } from "vitest";
import { clearMocks, mockIPC } from "@tauri-apps/api/mocks";
import type { SymbolKind, SymbolMatch } from "@/platform/ipc";
import { symbolRef } from "./conversation";
import { inTaskFolder, lookupSymbols, symbolTargets } from "./symbolLinks";
const symbol = (
name: string,
path: string,
kind: SymbolKind = "class",
container: string | null = null,
): SymbolMatch => ({
name,
kind,
container,
path,
relPath: path.replace(/^\/repo\//, ""),
range: { start: { line: 3, col: 6 }, end: { line: 3, col: 6 + name.length } },
score: 0,
indices: [],
});
afterEach(clearMocks);
describe("symbolTargets", () => {
const views = [symbol("FooView", "/repo/web/view.ts"), symbol("FooView", "/repo/app/view.ts")];
it("keeps only exact matches of the named kind, container and file", () => {
const found = [
symbol("load", "/repo/a.ts", "method", "Config"),
symbol("load", "/repo/b.ts", "method", "Loader"),
symbol("load", "/repo/c.ts", "variable"),
];
expect(symbolTargets(symbolRef("Config.load")!, found, [], "/repo").map((found) => found.path)).toEqual([
"/repo/a.ts",
]);
expect(symbolTargets(symbolRef("b.ts#load")!, found, [], "/repo").map((found) => found.path)).toEqual([
"/repo/b.ts",
]);
expect(symbolTargets(symbolRef("load()")!, found, [], "/repo").map((found) => found.path)).toEqual([
"/repo/a.ts",
"/repo/b.ts",
]);
expect(symbolTargets(symbolRef("FooView")!, [symbol("FooView", "/repo/x.ts", "variable")], [], "/repo")).toEqual(
[],
);
});
it("prefers a file the reply names, then the task's folder", () => {
const ref = symbolRef("FooView")!;
expect(symbolTargets(ref, views, ["/app/view.ts"], "/repo/web").map((found) => found.path)).toEqual([
"/repo/app/view.ts",
]);
expect(symbolTargets(ref, views, [], "/repo/web").map((found) => found.path)).toEqual(["/repo/web/view.ts"]);
expect(symbolTargets(ref, views, ["/other.ts"], "/repo")).toHaveLength(2);
});
it("puts a worktree task's targets under its own folder", () => {
const [view] = views;
expect(inTaskFolder(view!, "/repo", "/repo/web").path).toBe("/repo/web/view.ts");
expect(inTaskFolder(view!, "/repo", "/worktrees/fix").path).toBe("/worktrees/fix/web/view.ts");
});
});
describe("lookupSymbols", () => {
it("asks the index once per name and folder, in one request", async () => {
const asked: string[][] = [];
mockIPC((cmd, args) => {
if (cmd !== "find_symbols_named") return null;
const { names } = args as { names: string[] };
asked.push(names);
return names.map((name) => symbol(name, `/repo/${name}.ts`));
});
const first = lookupSymbols("/batch", ["FooView", "load", "FooView"]);
expect((await first.get("load"))!.map((found) => found.path)).toEqual(["/repo/load.ts"]);
const second = lookupSymbols("/batch", ["load", "BarView"]);
expect((await second.get("BarView"))!.map((found) => found.name)).toEqual(["BarView"]);
await lookupSymbols("/elsewhere", ["load"]).get("load");
expect(asked).toEqual([["FooView", "load"], ["BarView"], ["load"]]);
});
});
+73
Переглянути файл
@@ -0,0 +1,73 @@
/**
* Symbol links in agent replies: the names a reply shows are looked up in the symbol index
* in one batch, and each name only once per task folder.
*/
import { call, commands, type SymbolMatch } from "@/platform/ipc";
import type { SymbolRef } from "./conversation";
/** Index answers by the folder they were asked in, then by name. */
const answers = new Map<string, Map<string, Promise<SymbolMatch[]>>>();
const NAMES_PER_FOLDER = 2000;
/** The index's symbols named exactly each of `names` inside `within`; one request for the names not asked before. */
export function lookupSymbols(within: string, names: Iterable<string>): Map<string, Promise<SymbolMatch[]>> {
const known = answers.get(within) ?? new Map<string, Promise<SymbolMatch[]>>();
answers.set(within, known);
const wanted = new Set(names);
const missing = [...wanted].filter((name) => !known.has(name));
if (missing.length) {
const found = call(commands.findSymbolsNamed(missing, within)).catch(() => []);
for (const name of missing) {
if (known.size >= NAMES_PER_FOLDER) known.delete(known.keys().next().value!);
known.set(
name,
found.then((symbols) => symbols.filter((symbol) => symbol.name === name)),
);
}
}
return new Map([...wanted].map((name) => [name, known.get(name)!]));
}
/** Narrows `symbols` by each preference in turn, skipping one that would leave nothing. */
function preferred(symbols: SymbolMatch[], ...preferences: Array<(symbol: SymbolMatch) => boolean>): SymbolMatch[] {
return preferences.reduce((pool, prefers) => {
const narrowed = pool.filter(prefers);
return narrowed.length ? narrowed : pool;
}, symbols);
}
const trimSlash = (path: string) => path.replace(/\/$/, "");
const under = (folder: string, path: string) => path.startsWith(`${trimSlash(folder)}/`);
/**
* The definitions `ref` names among `symbols` (same name, kind, container and file), the
* ones in a file the reply names first, then the ones in the task's folder `cwd`.
*/
export function symbolTargets(
ref: SymbolRef,
symbols: readonly SymbolMatch[],
mentioned: readonly string[],
cwd: string,
): SymbolMatch[] {
const exact = symbols.filter(
(symbol) =>
symbol.name === ref.name &&
ref.kinds.includes(symbol.kind) &&
(!ref.container || symbol.container?.split(/\.|::/).pop() === ref.container) &&
(!ref.file || symbol.path.endsWith(`/${ref.file}`)),
);
return preferred(
exact,
(symbol) => mentioned.some((path) => symbol.path.endsWith(`/${path.replace(/^\.?\//, "")}`)),
(symbol) => under(cwd, symbol.path),
);
}
/**
* `symbol` as the task sees it: a task in a worktree outside the indexed project root has
* the same file under its own folder.
*/
export function inTaskFolder(symbol: SymbolMatch, projectRoot: string, cwd: string): SymbolMatch {
if (trimSlash(cwd) === trimSlash(projectRoot) || under(projectRoot, cwd)) return symbol;
return { ...symbol, path: `${trimSlash(cwd)}/${symbol.relPath}` };
}
+41 -14
Переглянути файл
@@ -9,6 +9,7 @@ import {
Spinner,
SymbolBadge,
Tabs,
showContextMenu,
Tree,
badgeKind,
type TreeHandle,
@@ -17,8 +18,11 @@ import {
} from "@/ui";
import { openLocation } from "./ipc";
import {
closeHierarchy,
closeHierarchyTab,
pinHierarchyTab,
ROOT_ID,
selectHierarchyTab,
tabHierarchy,
directionLabel,
hierarchyTitle,
hierarchyTarget,
@@ -54,22 +58,44 @@ useHierarchyOptions.subscribe((s) => {
}
});
/** Tool window header: `Callers of foo` content tab. */
/** Tool window header: the `Callers of foo` content tabs. */
export function HierarchyTabs() {
const mode = useHierarchy((s) => s.mode);
const direction = useHierarchy((s) => s.direction);
const root = useHierarchy((s) => s.root);
if (!root) return null;
const label = hierarchyTitle(mode, direction, root.name);
const state = useHierarchy();
const tabs = state.tabs.flatMap((tab) => {
const h = tabHierarchy(state, tab);
return h.root ? [{ tab, label: hierarchyTitle(h.mode, h.direction, h.root.name) }] : [];
});
if (!tabs.length || state.active === null) return null;
return (
<Tabs
variant="compact"
className={styles.tabs}
aria-label="Hierarchies"
items={[{ id: "current", label, closable: true }]}
activeId="current"
onSelect={() => undefined}
onClose={closeHierarchy}
items={tabs.map(({ tab, label }) => ({ id: String(tab.id), label, closable: true, pinned: tab.pinned }))}
activeId={String(state.active)}
onSelect={(id) => selectHierarchyTab(Number(id))}
onClose={(id) => closeHierarchyTab(Number(id))}
onTogglePin={(id) => {
const tab = tabs.find((t) => t.tab.id === Number(id))?.tab;
if (tab) pinHierarchyTab(tab.id, !tab.pinned);
}}
onContextMenu={(id, e) => {
const tab = tabs.find((t) => t.tab.id === Number(id))?.tab;
if (!tab) return;
// IDEA's content tab menu.
showContextMenu(e, [
{ id: "close", label: "Close Tab", run: () => closeHierarchyTab(tab.id) },
{ id: "closeAll", label: "Close All Tabs", run: () => tabs.forEach((t) => closeHierarchyTab(t.tab.id)) },
{
id: "closeOthers",
label: "Close Other Tabs",
disabled: tabs.length < 2,
run: () => tabs.forEach((t) => t.tab.id !== tab.id && closeHierarchyTab(t.tab.id)),
},
{ kind: "separator" },
{ id: "pin", label: tab.pinned ? "Unpin Tab" : "Pin Tab", run: () => pinHierarchyTab(tab.id, !tab.pinned) },
]);
}}
/>
);
}
@@ -114,7 +140,7 @@ function HierarchyToolbar() {
}
export function HierarchyView() {
const { mode, direction, root, children, failed, notes, loading, generation } = useHierarchy();
const { mode, direction, root, children, failed, notes, loading, expanded, generation } = useHierarchy();
const projectRoot = useProject((s) => s.project?.root ?? "");
const roots = useMemo<Node[]>(() => (root ? [{ kind: "root", id: ROOT_ID }] : []), [root]);
@@ -224,11 +250,12 @@ export function HierarchyView() {
getChildren={getChildren}
isExpandable={isExpandable}
loadChildren={(n) => (n.kind === "item" ? loadChildren(n.node) : undefined)}
onExpandedChange={(_expanded, n, open) => {
onExpandedChange={(opened, n, open) => {
useHierarchy.setState({ expanded: [...opened] });
const shown = open ? children.get(n.id) : undefined;
if (shown) prefetchLevels(shown);
}}
defaultExpanded={[ROOT_ID]}
defaultExpanded={expanded}
handleRef={tree}
isOccurrence={() => true}
onSelectionChange={(_sel, n) => {
+42
Переглянути файл
@@ -306,3 +306,45 @@ describe("closing the hierarchy tab", () => {
expect(hide).toHaveBeenCalledWith("hierarchy", { removeFromStripe: true });
});
});
describe("hierarchy tabs", () => {
it("replace the selected tab unless it is pinned, and keep each tab's tree", async () => {
const { closeHierarchyTab, pinHierarchyTab, selectHierarchyTab, tabHierarchy } = await import("./hierarchy");
const names = () => {
const s = useHierarchy.getState();
return s.tabs.map((t) => `${tabHierarchy(s, t).mode}:${t.pinned ? "pinned" : ""}`);
};
resetHierarchy();
await showHierarchy("call");
await showHierarchy("type");
expect(names()).toEqual(["type:"]);
const first = useHierarchy.getState().active!;
pinHierarchyTab(first, true);
await showHierarchy("call");
expect(names()).toEqual(["type:pinned", "call:"]);
const second = useHierarchy.getState().active!;
expect(
useHierarchy
.getState()
.children.get(ROOT_ID)
?.map((n) => n.item.name),
).toEqual(["main"]);
selectHierarchyTab(first);
expect(useHierarchy.getState().mode).toBe("type");
selectHierarchyTab(second);
expect(useHierarchy.getState().mode).toBe("call");
expect(
useHierarchy
.getState()
.children.get(ROOT_ID)
?.map((n) => n.item.name),
).toEqual(["main"]);
closeHierarchyTab(second);
expect(useHierarchy.getState()).toMatchObject({ active: first, mode: "type" });
expect(names()).toEqual(["type:pinned"]);
closeHierarchyTab(first);
expect(useHierarchy.getState()).toMatchObject({ root: null, tabs: [], active: null });
});
});
+111 -1
Переглянути файл
@@ -54,8 +54,27 @@ interface HierarchyState {
/** Parent id → why its children may be missing callers. */
notes: ReadonlyMap<string, string>;
loading: boolean;
/** Ids of the expanded nodes, so a tab shown again keeps its tree open. */
expanded: readonly string[];
/** Bumped per (re)query so stale responses are dropped and the tree resets. */
generation: number;
/** Content tabs; the selected one's hierarchy is the state above. */
tabs: readonly HierarchyTab[];
active: number | null;
}
/** The hierarchy of a tab that isn't selected. */
export type SavedHierarchy = Pick<
HierarchyState,
"mode" | "direction" | "root" | "children" | "failed" | "notes" | "loading" | "expanded"
>;
export interface HierarchyTab {
id: number;
/** Pinned: a new hierarchy opens beside it instead of taking its place. */
pinned: boolean;
/** Null for the selected tab. */
saved: SavedHierarchy | null;
}
export const ROOT_ID = "root";
@@ -68,9 +87,89 @@ export const useHierarchy = create<HierarchyState>(() => ({
failed: new Set(),
notes: new Map(),
loading: false,
expanded: [ROOT_ID],
generation: 0,
tabs: [],
active: null,
}));
let tabSeq = 0;
function saved(s: HierarchyState): SavedHierarchy {
const { mode, direction, root, children, failed, notes, loading, expanded } = s;
return { mode, direction, root, children, failed, notes, loading, expanded };
}
/** A tab's mode, direction and root: the live state's for the selected one. */
export function tabHierarchy(s: HierarchyState, tab: HierarchyTab): SavedHierarchy {
return tab.saved ?? saved(s);
}
/**
* As IDEA: a new hierarchy takes the place of the selected tab unless it is pinned,
* then it opens in a tab of its own.
*/
function openTab() {
const s = useHierarchy.getState();
const current = s.tabs.find((t) => t.id === s.active);
if (current && !current.pinned) return;
cancelInflight();
const id = ++tabSeq;
useHierarchy.setState({
tabs: [
...s.tabs.map((t) => (t.id === s.active ? { ...t, saved: saved(s) } : t)),
{ id, pinned: false, saved: null },
],
active: id,
root: null,
children: new Map(),
failed: new Set(),
notes: new Map(),
loading: false,
expanded: [ROOT_ID],
generation: s.generation + 1,
});
}
export function selectHierarchyTab(id: number) {
const s = useHierarchy.getState();
const target = s.tabs.find((t) => t.id === id);
if (id === s.active || !target?.saved) return;
cancelInflight();
const next = target.saved;
useHierarchy.setState({
...next,
loading: false,
generation: s.generation + 1,
active: id,
tabs: s.tabs.map((t) => (t.id === s.active ? { ...t, saved: saved(s) } : t.id === id ? { ...t, saved: null } : t)),
});
// Its requests were dropped when it was left: load it again.
if (next.loading) void loadRoot();
}
/** Closes a tab; the tool window goes with the last one. */
export function closeHierarchyTab(id: number) {
const s = useHierarchy.getState();
const at = s.tabs.findIndex((t) => t.id === id);
if (at < 0) return;
const rest = s.tabs.filter((t) => t.id !== id);
if (!rest.length) {
closeHierarchy();
return;
}
if (id !== s.active) {
useHierarchy.setState({ tabs: rest });
return;
}
useHierarchy.setState({ tabs: rest, active: null });
selectHierarchyTab((s.tabs[at + 1] ?? s.tabs[at - 1])!.id);
}
export function pinHierarchyTab(id: number, pinned: boolean) {
useHierarchy.setState((s) => ({ tabs: s.tabs.map((t) => (t.id === id ? { ...t, pinned } : t)) }));
}
/** Call hierarchy requests the current tree still waits for. */
const inflight = new Set<RequestId>();
@@ -88,7 +187,10 @@ export function resetHierarchy() {
failed: new Set(),
notes: new Map(),
loading: false,
expanded: [ROOT_ID],
generation: s.generation + 1,
tabs: [],
active: null,
}));
}
@@ -248,7 +350,14 @@ async function loadRoot(quiet = false): Promise<RootResult> {
if (!root) return "stale";
const generation = s.generation + 1;
cancelInflight();
useHierarchy.setState({ generation, children: new Map(), failed: new Set(), notes: new Map(), loading: true });
useHierarchy.setState({
generation,
children: new Map(),
failed: new Set(),
notes: new Map(),
loading: true,
expanded: [ROOT_ID],
});
try {
const { items, incomplete } = await withDocument(root.path, (doc) =>
request(s.mode, doc, root.path, root.line, root.col, s.direction),
@@ -365,6 +474,7 @@ export async function showHierarchy(mode: HierarchyMode) {
hint("Open a file to show the hierarchy");
return;
}
openTab();
const s = useHierarchy.getState();
const direction = s.mode === mode ? s.direction : mode === "call" ? "incoming" : "outgoing";
useHierarchy.setState({
+1
Переглянути файл
@@ -191,6 +191,7 @@ function providePluginEndpoints(pluginId: string): () => void {
export function defineBuiltinUiPoints(): () => void {
const disposers = [
defineUiPoint("mcpTools", {}),
defineUiPoint("serverCommands", {}),
defineUiPoint("endpoints", { project: ({ pluginId }) => providePluginEndpoints(pluginId) }),
defineUiPoint<CommandDecl>("commands", {
title: "Commands",
+7
Переглянути файл
@@ -33,6 +33,7 @@ import {
useFileDecoration,
type DecorationSegment,
} from "@/workbench/contributions";
import { useFileColors } from "@/workbench/fileColors";
import {
FILES_DRAG,
REMOTE_FILES_DRAG,
@@ -461,6 +462,7 @@ export function ProjectView() {
useFileIconRevision();
const root = useProjectTree((s) => s.root);
const model = useProjectTree(selectModel);
const fileColors = useFileColors("projectView");
const expanded = useProjectTree((s) => s.expanded);
const selected = useProjectTree((s) => s.selected);
const editing = useProjectTree((s) => s.editing);
@@ -872,6 +874,11 @@ export function ProjectView() {
loadChildren={loadChildren}
renderNode={renderNode}
rowClassName={(n) => (n.excluded ? styles.excludedRow : undefined)}
rowTint={
fileColors
? (n) => (n.excluded || n.group || n.placeholder ? undefined : fileColors(n.path, n.dir))
: undefined
}
expanded={expanded}
onExpandedChange={onExpandedChange}
selected={selected}
+12
Переглянути файл
@@ -151,8 +151,20 @@ describe("project view context menu", () => {
"Git",
"-",
"Compare With…",
"File Color",
]);
expect(sub(items, "Refactor")).toEqual(["Rename…", "Move File…", "Copy File…", "-", "Safe Delete…"]);
expect(sub(items, "File Color")).toEqual([
"Blue",
"Green",
"Orange",
"Rose",
"Violet",
"Yellow",
"Gray",
"-",
"Edit File Colors…",
]);
expect(sub(items, "Open In")).toEqual([revealLabel(), "Terminal"]);
expect(sub(items, "Git")?.slice(0, 4)).toEqual(["Commit File…", "Add", "-", "Annotate with Git Blame"]);
});
+5
Переглянути файл
@@ -9,6 +9,7 @@ import type { MenuItem } from "@/ui";
import { menuGroupItems, toolWindowService, type MenuGroupContext } from "@/workbench/contributions";
import type { FolderRole } from "@/platform/languageSettings";
import { directoryRole, markDirectory } from "./markDirectory";
import { fileColorMenu } from "./fileColor";
import type { ProjectNode } from "./model";
import { packageKindAt } from "./packages";
import {
@@ -456,6 +457,10 @@ export function contextMenuItems(nodes: ProjectNode[]): MenuItem[] {
],
});
}
if (inProject && single && !single.root && !single.placeholder && !single.group) {
const color = fileColorMenu(single.path, single.dir);
if (color) push(color);
}
return items;
}
+55
Переглянути файл
@@ -0,0 +1,55 @@
/**
* Project view › File Color: gives a file or folder its own background colour, kept as a
* scope of that path and a File Colors entry in the project's settings.
*/
import { executeAction } from "@/platform/actions";
import { FILE_COLOR_NAMES, ownFileColor, pathPattern, withOwnFileColor } from "@/platform/fileColors";
import { call, commands, isTauri } from "@/platform/ipc";
import { loadSettings, relativePath, useProject } from "@/platform/project";
import type { MenuItem } from "@/ui";
const LABELS: Record<(typeof FILE_COLOR_NAMES)[number], string> = {
blue: "Blue",
green: "Green",
orange: "Orange",
rose: "Rose",
violet: "Violet",
yellow: "Yellow",
gray: "Gray",
};
export async function setFileColor(path: string, dir: boolean, color: string | null): Promise<void> {
const { project, settings } = useProject.getState();
if (!project || !isTauri()) return;
const next = withOwnFileColor(settings, relativePath(project.root, path), dir, color);
if (!next) return;
await call(commands.settingsSet("project", "scopes", JSON.stringify(next.scopes)));
await call(commands.settingsSet("project", "fileColors", JSON.stringify(next.fileColors)));
await loadSettings();
}
/** The File Color submenu of a file or folder inside the project, or null when it can't have one. */
export function fileColorMenu(path: string, dir: boolean): MenuItem | null {
const { project, settings } = useProject.getState();
if (!project) return null;
const rel = relativePath(project.root, path);
if (rel === path || !pathPattern(rel, dir)) return null;
const current = ownFileColor(rel, dir, settings)?.toLowerCase();
return {
id: "fileColor",
label: "File Color",
submenu: [
...FILE_COLOR_NAMES.map((name): MenuItem => ({
id: name,
label: LABELS[name],
checked: current === name,
run: () => void setFileColor(path, dir, name),
})),
{ kind: "separator" },
...(current
? [{ id: "clear", label: "Clear File Color", run: () => void setFileColor(path, dir, null) } as MenuItem]
: []),
{ id: "edit", label: "Edit File Colors…", run: () => void executeAction("file.settings", "fileColors") },
],
};
}
Loaded 100 of 155 files, more files were not shown because too many files have changed in this diff. Show more