дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 17:10:45 +02:00
Порівняти коміти
23
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
55a19bbbe1 | ||
|
|
efa4fb3b43 | ||
|
|
6df0087038 | ||
|
|
bedd9d2fc9 | ||
|
|
696abb08d8 | ||
|
|
f99ae11c01 | ||
|
|
b0fbc5a76c | ||
|
|
273564687e | ||
|
|
5436b7202d | ||
|
|
9fdb067ec5 | ||
|
|
c8112f9010 | ||
|
|
0d376cae44 | ||
|
|
b5c86bc064 | ||
|
|
78e169f820 | ||
|
|
601f1ee10a | ||
|
|
ea65b8c074 | ||
|
|
10ddb4aa89 | ||
|
|
1259423fdc | ||
|
|
3fed53ced7 | ||
|
|
ad236cf1a1 | ||
|
|
3b06fc037d | ||
|
|
6d70458e22 | ||
|
|
bbd7c36c40 |
No files matched your search
@@ -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
|
||||
@@ -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({
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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>");
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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")?) });
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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}");
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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]) {
|
||||
|
||||
@@ -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::*;
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
@@ -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`.
|
||||
|
||||
@@ -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?;
|
||||
|
||||
@@ -26,6 +26,7 @@ mod launch;
|
||||
mod library_source;
|
||||
mod loading;
|
||||
mod notebook;
|
||||
mod phoxite;
|
||||
mod plugin_requests;
|
||||
mod pull;
|
||||
mod scope;
|
||||
|
||||
@@ -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)),
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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
|
||||
@@ -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"
|
||||
@@ -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())),
|
||||
}
|
||||
|
||||
@@ -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"))
|
||||
|
||||
@@ -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(""", "\"").replace("'", "'").replace("<", "<").replace(">", ">").replace("&", "&")
|
||||
}
|
||||
|
||||
/// 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")));
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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**.
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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>`.
|
||||
|
||||
|
||||
@@ -128,7 +128,7 @@ description: "多光标与选区、行编辑、剪贴板历史、代码折叠、
|
||||
| **滚动到中央** | `⌃L` | `Ctrl+M` |
|
||||
|
||||
- **视图 › 活动编辑器 › 软换行** 让当前编辑器的长行自动折行。想让某些文件类型默认软换行,在 **设置 › 编辑器 › 常规** 的 **软换行** 一节中设置。
|
||||
- **视图 › 重置所有编辑器中的字体大小** 撤销字体缩放。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开。
|
||||
- **视图 › 重置字体大小** 撤销当前编辑器或焦点区域的字体缩放(**视图 › 重置所有编辑器中的字体大小** 会重置所有打开的编辑器)。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
|
||||
- **视图 › 外观 › 进入无干扰模式** 隐藏工具窗口、标签页、状态栏和装订区域,并让正文居中。再执行一次即可退出。
|
||||
- 行号、空白字符、缩进参考线、光标样式和意图灯泡在 **设置 › 编辑器 › 常规 › 外观** 中设置。痕迹导航和粘滞行(滚动时把所在的声明固定在顶部)在 **设置 › 编辑器 › 常规** 下各有单独的页面。
|
||||
|
||||
|
||||
@@ -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 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
|
||||
- 会写入的工具拒绝项目之外的路径。
|
||||
|
||||
## 限制
|
||||
|
||||
@@ -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 服务器不可用。
|
||||
|
||||
## 撤销
|
||||
|
||||
|
||||
@@ -64,7 +64,7 @@ OpenIDEA 会把主题(以及其中附带的编辑器配色方案)转换为
|
||||
- **启用连字**:用于带编程连字的字体。
|
||||
- **排版设置**:**主字重**、**粗体字重**,以及主字体缺少字符时使用的 **备用字体**。
|
||||
|
||||
临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置所有编辑器中的字体大小** 恢复。在 macOS 上,开启 **设置 › 编辑器 › 常规** 中的 **使用 Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放。
|
||||
在当前编辑器中临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置字体大小**(或 **视图 › 重置所有编辑器中的字体大小**)恢复。在 **设置 › 编辑器 › 常规** 中开启 **使用 Ctrl/Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
|
||||
|
||||
### 界面字体与缩放
|
||||
|
||||
|
||||
@@ -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>`。
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,3 @@
|
||||
# Per-user IDE state
|
||||
/shelf/
|
||||
/changelists.json
|
||||
@@ -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.
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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"),
|
||||
],
|
||||
|
||||
@@ -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",
|
||||
&[
|
||||
|
||||
@@ -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 } },
|
||||
};
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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]> = [];
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
},
|
||||
});
|
||||
|
||||
@@ -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 (
|
||||
|
||||
@@ -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 }));
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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({
|
||||
|
||||
@@ -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={
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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> = {
|
||||
|
||||
@@ -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 =
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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}>
|
||||
|
||||
@@ -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"));
|
||||
});
|
||||
});
|
||||
@@ -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,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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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", () => {
|
||||
|
||||
@@ -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`;
|
||||
|
||||
@@ -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: "\n\n" }]]]),
|
||||
})),
|
||||
);
|
||||
|
||||
const { container } = render(
|
||||
<EditorShownProvider value={true}>
|
||||
<SessionEditor input={{ kind: SESSION_KIND, key: sessionKey("t1"), data: { task: "t1" } }} />
|
||||
</EditorShownProvider>,
|
||||
);
|
||||
|
||||
await vi.waitFor(() => {
|
||||
const diag = container.querySelector<HTMLImageElement>('img[alt="Diagram"]');
|
||||
expect(diag?.getAttribute("src")).toBe(svgUrl);
|
||||
});
|
||||
|
||||
const diag = container.querySelector<HTMLImageElement>('img[alt="Diagram"]')!;
|
||||
expect(diag.hasAttribute("data-natural-width")).toBe(true);
|
||||
expect(diag.style.getPropertyValue("--image-width")).toBe("320px");
|
||||
|
||||
const shot = container.querySelector<HTMLImageElement>('img[alt="Shot"]')!;
|
||||
Object.defineProperty(shot, "naturalWidth", { value: 640, configurable: true });
|
||||
Object.defineProperty(shot, "naturalHeight", { value: 360, configurable: true });
|
||||
act(() => {
|
||||
shot.dispatchEvent(new Event("load"));
|
||||
});
|
||||
expect(shot.hasAttribute("data-natural-width")).toBe(true);
|
||||
expect(shot.style.getPropertyValue("--image-width")).toBe("640px");
|
||||
});
|
||||
|
||||
it("prunes bySurface entries when a tab closes or a task is removed", () => {
|
||||
stepAgentSurfaceFontZoom("tab:tab-a", 4);
|
||||
stepAgentSurfaceFontZoom("tab:tab-b", -2);
|
||||
stepAgentSurfaceFontZoom("docked:agent:t1", 3);
|
||||
stepAgentSurfaceFontZoom("agent:t1", 2);
|
||||
expect(useAgentFontZoom.getState().bySurface).toEqual({
|
||||
"tab:tab-a": 4,
|
||||
"tab:tab-b": -2,
|
||||
"docked:agent:t1": 3,
|
||||
"agent:t1": 2,
|
||||
});
|
||||
|
||||
clearAgentTabFontZoom("tab-a");
|
||||
expect(useAgentFontZoom.getState().bySurface).toEqual({
|
||||
"tab:tab-b": -2,
|
||||
"docked:agent:t1": 3,
|
||||
"agent:t1": 2,
|
||||
});
|
||||
|
||||
clearAgentTaskFontZoom("agent:t1");
|
||||
expect(useAgentFontZoom.getState().bySurface).toEqual({
|
||||
"tab:tab-b": -2,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -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 };
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
@@ -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();
|
||||
};
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
|
||||
@@ -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"]]);
|
||||
});
|
||||
});
|
||||
@@ -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}` };
|
||||
}
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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 });
|
||||
});
|
||||
});
|
||||
@@ -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({
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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"]);
|
||||
});
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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
Reference in new issue
Заблокувати користувача