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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 1375620b99 fix(project-view): keep the tree still when a file is dragged out of it
Dragging a file from the Project view to the terminal (or any target below
the tree) scrolled the tree on and on: WebKit autoscrolls the pressed
scroll container toward the pointer once it leaves the container. During a
drag the tree now keeps its scroll position while the pointer is outside
it, and scrolls itself only while the pointer is within 24 px of its top or
bottom edge, as IDEA's tree does when you drag toward an edge.
2026-11-17 15:10:27 +08:00
344 змінених файлів з 13677 додано та 14667 видалено

No files matched your search

-3
Переглянути файл
@@ -98,9 +98,6 @@ jobs:
# Test fixtures write LF files; keep Git from converting them on checkout.
- run: git config --global core.autocrlf false
- run: cargo nextest run --workspace --no-fail-fast
# nextest skips doctests; ide-command's are its compile-fail tests.
- if: runner.os == 'Linux'
run: cargo test --doc -p ide-command
# nextest ran export_bindings, which rewrites src/bindings.ts and the command snapshot.
- name: Bindings and command snapshot are up to date
if: runner.os == 'Linux'
+119
Переглянути файл
@@ -0,0 +1,119 @@
name: Nightly
# Twice a day, builds the newest main commit that passed CI as a prerelease tagged with its own
# version, so remote development finds the server of that version. The `nightly` release holds
# the manifest the nightly app updates from; its tag marks the commit last built, and a run with
# nothing newer stops there. Only the latest builds are kept.
on:
schedule:
- cron: "17 2,14 * * *"
workflow_dispatch:
inputs:
force:
description: "Build even if nothing is newer than the last nightly"
type: boolean
default: false
permissions:
contents: read
concurrency:
group: nightly
env:
GH_TOKEN: ${{ github.token }}
GH_REPO: ${{ github.repository }}
jobs:
prepare:
permissions:
actions: read
contents: write
if: github.repository == 'l0ng-ai/openidea'
runs-on: ubuntu-latest
outputs:
sha: ${{ steps.commit.outputs.sha }}
tag: ${{ steps.release.outputs.tag }}
release_id: ${{ steps.release.outputs.id }}
steps:
- id: commit
env:
FORCE: ${{ inputs.force }}
run: |
sha="$(gh run list --workflow ci.yml --branch main --event push --status success --limit 1 \
--json headSha --jq '.[0].headSha // ""')"
if [ -z "$sha" ]; then
echo "::notice::no main commit has passed CI"
exit 0
fi
# No `nightly` tag yet (the first run): compare fails and the build goes on.
status="$(gh api "repos/$GH_REPO/compare/nightly...$sha" --jq .status 2>/dev/null)" || status=ahead
if [ "$status" != ahead ] && [ "$FORCE" != true ]; then
echo "::notice::$sha is not newer than the last nightly"
exit 0
fi
echo "sha=$sha" >> "$GITHUB_OUTPUT"
- uses: actions/checkout@v5
if: steps.commit.outputs.sha != ''
with: { ref: "${{ steps.commit.outputs.sha }}" }
- uses: actions/setup-node@v5
if: steps.commit.outputs.sha != ''
with: { node-version: 22 }
- uses: dtolnay/rust-toolchain@stable
if: steps.commit.outputs.sha != ''
- id: release
if: steps.commit.outputs.sha != ''
env:
SHA: ${{ steps.commit.outputs.sha }}
run: |
version="$(node scripts/nightly-prepare.ts "$(date -u +%Y%m%d%H%M)")"
tag="v$version"
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git commit -am "chore: $tag"
git tag "$tag"
git push origin "$tag"
id="$(gh api -X POST "repos/$GH_REPO/releases" -f tag_name="$tag" -f name="OpenIDEA Nightly $version" \
-F draft=true -F prerelease=true -f body="Built from $SHA." --jq .id)"
echo "tag=$tag" >> "$GITHUB_OUTPUT"
echo "id=$id" >> "$GITHUB_OUTPUT"
binaries:
permissions:
contents: write
needs: prepare
if: needs.prepare.outputs.tag != ''
uses: ./.github/workflows/release-build.yml
with:
tag: ${{ needs.prepare.outputs.tag }}
release_id: ${{ needs.prepare.outputs.release_id }}
secrets: inherit
publish:
permissions:
contents: write
needs: [prepare, binaries]
runs-on: ubuntu-latest
env:
TAG: ${{ needs.prepare.outputs.tag }}
SHA: ${{ needs.prepare.outputs.sha }}
KEEP: 14
steps:
- name: Publish the build
run: gh release edit "$TAG" --tag "$TAG" --draft=false
- name: Point the updater at it
run: |
gh release download "$TAG" -p latest.json -D "$RUNNER_TEMP"
gh release view nightly >/dev/null 2>&1 ||
gh release create nightly --prerelease --latest=false --target "$SHA" --title "OpenIDEA Nightly" \
--notes "The update manifest of the nightly builds, and the commit last built."
gh release upload nightly "$RUNNER_TEMP/latest.json" --clobber
gh api -X PATCH "repos/$GH_REPO/git/refs/tags/nightly" -f sha="$SHA" -F force=true --silent
# Failed builds' drafts go too, once they are this old.
- name: Delete old builds
run: |
gh release list --limit 200 --json tagName,createdAt --jq \
'[.[] | select(.tagName | contains("-nightly."))] | sort_by(.createdAt) | reverse | .[env.KEEP | tonumber:][].tagName' |
while read -r tag; do
gh release delete "$tag" --cleanup-tag --yes
done
+9 -8
Переглянути файл
@@ -1,7 +1,7 @@
name: Release build
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release
# (run by release.yml).
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release.
# Stable releases (release.yml) and nightly builds (nightly.yml) both run it.
on:
workflow_call:
inputs:
@@ -224,17 +224,18 @@ jobs:
return;
}
// Bundle suffix → updater platform keys, as tauri-action names them.
const windows = (arch, msi, nsis) => [
[msi, [`windows-${arch}`, `windows-${arch}-msi`]],
[nsis, [`windows-${arch}-nsis`]],
];
// Nightly versions don't fit MSI or RPM, so those builds offer NSIS on Windows.
const nightly = tag.includes("-nightly.");
const windows = (arch, msi, nsis) => nightly
? [[nsis, [`windows-${arch}`, `windows-${arch}-nsis`]]]
: [[msi, [`windows-${arch}`, `windows-${arch}-msi`]], [nsis, [`windows-${arch}-nsis`]]];
const kinds = [
[/_aarch64\.AppImage$/, ["linux-aarch64", "linux-aarch64-appimage"]],
[/_arm64\.deb$/, ["linux-aarch64-deb"]],
[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]],
...(nightly ? [] : [[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]]]),
[/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
[/_amd64\.deb$/, ["linux-x86_64-deb"]],
[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]],
...(nightly ? [] : [[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]]]),
[/_aarch64\.app\.tar\.gz$/, ["darwin-aarch64", "darwin-aarch64-app"]],
[/_x64\.app\.tar\.gz$/, ["darwin-x86_64", "darwin-x86_64-app"]],
...windows("aarch64", /_arm64_en-US\.msi$/, /_arm64-setup\.exe$/),
+3 -2
Переглянути файл
@@ -1,7 +1,7 @@
name: Release
on:
push:
tags: ["v*"]
tags: ["v*", "!v*-nightly.*"]
workflow_dispatch:
inputs:
tag:
@@ -23,6 +23,7 @@ env:
jobs:
# Creates (or reuses) one draft release that every platform build uploads into.
create-release:
if: ${{ !contains(github.event.inputs.tag || github.ref_name, '-nightly.') }}
permissions:
contents: write
runs-on: ubuntu-latest
@@ -61,7 +62,7 @@ jobs:
core.setOutput("id", existing.id);
return;
}
// Prereleases are skipped: the notes span stable release to stable release.
// Nightly builds are prereleases: the notes span stable release to stable release.
const previous = releases.find((r) => !r.draft && !r.prerelease);
const { data: notes } = await github.rest.repos.generateReleaseNotes({
owner, repo, tag_name: tag, previous_tag_name: previous?.tag_name,
+1 -5
Переглянути файл
@@ -9,8 +9,7 @@ Visual style: dark, low-contrast greys, one cool accent
- `crates/ide-*` — backend crates; one domain each. Depend on `ide-core` for shared
types; never reach into another crate's internals.
- `src-tauri/` — glue only: `state.rs` (AppState / Project), `commands/<domain>.rs`
(desktop-only commands; the adapters of `ide-host` commands are derived), `events.rs`.
No domain logic here.
(thin typed IPC adapters), `events.rs`. No domain logic here.
- `src/bindings.ts` — generated by tauri-specta (`pnpm gen:bindings`). Never edit.
- `src/platform/` — ipc (`call`, `onIdeEvent`, `nextRequestId`), actions registry,
keymap + dispatcher, context keys / `when` clauses, project store.
@@ -34,9 +33,6 @@ Visual style: dark, low-contrast greys, one cool accent
- IPC coordinates: 0-based lines, **UTF-16** columns/offsets everywhere (`ide-core::text`).
- Every command returns `IdeResult<T>`; convert internal errors at the crate edge.
- Declare a command once, on its implementation: `#[command(trust = …)]` in `ide-host::ops`
plus its module's `domain!` list (Tauri adapter, server handler and bindings are derived);
desktop-only commands use `#[desktop_command(trust = …)]` and `desktop_domain!`.
- Streaming → `tauri::ipc::Channel<T>`; cancellable → UI-allocated `RequestId` +
`cancel_request`. Backend → UI notifications → `IdeEvent` via `EventSink`.
- Long work never blocks the UI thread or a Tauri command thread: use
Створено
-13
Переглянути файл
@@ -4235,17 +4235,6 @@ dependencies = [
"png 0.18.1",
]
[[package]]
name = "ide-command"
version = "0.1.47"
dependencies = [
"heck 0.5.0",
"proc-macro2",
"quote",
"serde",
"syn 2.0.119",
]
[[package]]
name = "ide-core"
version = "0.1.47"
@@ -4435,7 +4424,6 @@ dependencies = [
"ide-agent",
"ide-analysis",
"ide-build",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
@@ -6673,7 +6661,6 @@ dependencies = [
"ide-build",
"ide-cli",
"ide-clipboard",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
-7
Переглянути файл
@@ -42,7 +42,6 @@ ide-fonts = { path = "crates/ide-fonts" }
ide-ssh = { path = "crates/ide-ssh" }
ide-remote = { path = "crates/ide-remote" }
ide-host = { path = "crates/ide-host" }
ide-command = { path = "crates/ide-command" }
ide-mcp = { path = "crates/ide-mcp" }
ide-scaffold = { path = "crates/ide-scaffold" }
ide-notebook = { path = "crates/ide-notebook" }
@@ -125,12 +124,6 @@ uuid = { version = "1", features = ["v4"] }
keyring = "4.2"
keyring-core = "1"
# proc macros
heck = "0.5"
proc-macro2 = "1"
quote = "1"
syn = { version = "2", features = ["full"] }
# testing
insta = { version = "1", features = ["yaml"] }
proptest = "1"
+12 -33
Переглянути файл
@@ -935,50 +935,29 @@ impl AgentManager {
Ok(item)
}
/// Sends queued message `queued` now: into the running turn when the agent takes
/// messages mid-turn, else next, cancelling the current turn if there is one.
pub async fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
/// Sends queued message `queued` next, cancelling the current turn if there is one.
pub fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
let task = self.task(id)?;
let (item, busy) = {
let idle = {
let mut s = task.state.lock();
let i =
s.task.queue.iter().position(|q| q.id == queued).ok_or_else(|| IdeError::not_found("already sent"))?;
let item = s.task.queue.remove(i);
let busy = s.busy;
if !busy {
if s.busy {
s.task.queue.insert(0, item);
None
} else {
s.busy = true;
Some(item)
}
(item, busy)
};
task.persist();
task.emit_task();
if !busy {
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
return Ok(());
}
// Out of the queue while it is steered, so the turn ending meanwhile doesn't send it twice.
let prompt = match task.steer(item.prompt).await {
Ok(()) => return Ok(()),
Err(prompt) => prompt,
};
let start = {
let mut s = task.state.lock();
if s.busy {
s.task.queue.insert(0, AgentQueued { id: item.id, prompt });
None
} else {
// The turn ended while steering was tried: nothing is left to interrupt.
s.busy = true;
Some(prompt)
}
};
match start {
Some(prompt) => {
self.shared.runtime.spawn(async move { task.run(prompt).await });
match idle {
Some(item) => {
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
}
None => {
task.persist();
task.emit_task();
task.send_now.store(true, Ordering::Release);
task.cancel();
}
@@ -3042,7 +3021,7 @@ fn blocks(prompt: &AgentPrompt, contents: &[Option<String>]) -> Vec<Value> {
});
}
for i in &prompt.images {
out.push(json!({ "type": "image", "mimeType": i.media_type(), "data": i.data }));
out.push(json!({ "type": "image", "mimeType": i.mime_type, "data": i.data }));
}
out
}
-16
Переглянути файл
@@ -281,22 +281,6 @@ pub struct AgentImage {
pub name: Option<String>,
}
impl AgentImage {
/// The type the bytes are in. Agents reject an image whose declared type doesn't match its
/// bytes, and a pasted image's declared type can be wrong (a browser's JPEG or WebP copied as
/// `image/png`). Falls back to `mime_type` for formats not recognised here.
pub fn media_type(&self) -> &str {
let head = crate::acp::normalize_base64(&self.data[..self.data.len().min(16)]);
match head.as_slice() {
[0x89, b'P', b'N', b'G', ..] => "image/png",
[0xFF, 0xD8, 0xFF, ..] => "image/jpeg",
[b'G', b'I', b'F', b'8', ..] => "image/gif",
[b'R', b'I', b'F', b'F', _, _, _, _, b'W', b'E', b'B', b'P', ..] => "image/webp",
_ => &self.mime_type,
}
}
}
/// A message to the agent: text, plus files to look at and images.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+31 -101
Переглянути файл
@@ -19,7 +19,6 @@ mod translate;
mod tests;
use super::Shim;
use crate::BACKGROUND_TASKS_UPDATE;
use crate::acp::AUTH_REQUIRED;
use crate::provider::ProviderSpec;
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
@@ -297,25 +296,6 @@ struct SessionEntry {
prompt: Option<oneshot::Sender<TurnTerminal>>,
early_cancel: Option<Instant>,
temp_files: Vec<PathBuf>,
/// Copilot's main agent loop is processing. It goes idle (`assistant.idle`) before the
/// turn ends (`session.idle`) while background shells or agents it started still run.
main_busy: bool,
/// Counts `session.tasks.list` requests, so only the latest answer is reported.
tasks_seq: u64,
}
impl SessionEntry {
fn new(settings: Settings) -> Self {
Self {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
main_busy: false,
tasks_seq: 0,
}
}
}
struct CopilotEvents(Weak<CopilotShim>);
@@ -431,7 +411,6 @@ impl CopilotShim {
"session/set_config_option" => self.set_config(&params).await,
"session/prompt" => self.prompt(&params, false).await,
"_openidea/steer" => self.prompt(&params, true).await,
"_openidea/stop_task" => self.stop_task(&params).await,
"session/close" => self.close_session(&params).await,
_ => Err(error(codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
}
@@ -446,7 +425,7 @@ impl CopilotShim {
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
"mcpCapabilities": { "http": true, "sse": true, "stdio": true },
"sessionCapabilities": { "close": {}, "list": {} },
"_meta": { "openidea": { "steer": true, "backgroundTasks": true } },
"_meta": { "openidea": { "steer": true } },
},
"agentInfo": {
"name": "copilot",
@@ -513,7 +492,16 @@ impl CopilotShim {
}
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(session_id.clone(), SessionEntry::new(settings));
self.state.lock().sessions.insert(
session_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.publish_commands(&session_id, cwd);
Ok(json!({
"sessionId": session_id,
@@ -560,7 +548,16 @@ impl CopilotShim {
}
let actual_id = resumed.get("sessionId").and_then(Value::as_str).unwrap_or(&session_id).to_owned();
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(actual_id.clone(), SessionEntry::new(settings));
self.state.lock().sessions.insert(
actual_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.publish_commands(&actual_id, cwd);
Ok(json!({
"sessionId": actual_id,
@@ -662,11 +659,7 @@ impl CopilotShim {
let (text, attachments, temp_files) = build_prompt_payload(&session_id, blocks);
if steer {
let (is_running, main_busy) = {
let st = self.state.lock();
let entry = st.sessions.get(&session_id);
(entry.is_some_and(|e| e.prompt.is_some()), entry.is_some_and(|e| e.main_busy))
};
let is_running = self.state.lock().sessions.get(&session_id).is_some_and(|e| e.prompt.is_some());
if !is_running {
cleanup_files(&temp_files);
return Err(error(codes::INVALID_PARAMS, "no turn running to steer"));
@@ -674,25 +667,14 @@ impl CopilotShim {
let mut send_req = json!({
"sessionId": session_id,
"prompt": text,
"mode": "immediate",
});
// Joins the running loop; once it went idle (only background work is left), a plain
// send starts the loop again with this message.
if main_busy {
send_req["mode"] = json!("immediate");
}
if !attachments.is_empty() {
send_req["attachments"] = Value::Array(attachments);
}
if !main_busy && let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
// Stop must abort the run this send starts, even before `assistant.turn_start`.
entry.main_busy = true;
}
let res = self.call("session.send", send_req).await;
if let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
entry.temp_files.extend(temp_files);
if res.is_err() && !main_busy {
entry.main_busy = false;
}
}
res?;
return Ok(json!({}));
@@ -709,7 +691,6 @@ impl CopilotShim {
let mode = entry.settings.mode.wire();
if !early {
entry.prompt = Some(done_tx);
entry.main_busy = true;
}
(mode, early)
};
@@ -759,24 +740,19 @@ impl CopilotShim {
}
fn cancel(&self, session_id: &str) {
let (has_turn, ended) = {
let has_turn = {
let mut st = self.state.lock();
match st.sessions.get_mut(session_id) {
Some(entry) if entry.prompt.is_none() => {
if let Some(entry) = st.sessions.get_mut(session_id) {
if entry.prompt.is_none() {
entry.early_cancel = Some(Instant::now());
(false, None)
false
} else {
true
}
// The agent is done with the turn and only its background work runs, which
// `session.idle` waits for: the turn ends now and that work keeps running
// (it shows as background tasks, stoppable one by one).
Some(entry) if !entry.main_busy => (false, entry.prompt.take()),
Some(_) => (true, None),
None => (false, None),
} else {
false
}
};
if let Some(tx) = ended {
let _ = tx.send(TurnTerminal::Idle { aborted: true });
}
if has_turn {
let peer = self.copilot().clone();
let sid = session_id.to_owned();
@@ -820,23 +796,10 @@ impl CopilotShim {
return;
}
let main_agent = event.get("agentId").and_then(Value::as_str).is_none_or(str::is_empty);
let event_type = event.get("type").and_then(Value::as_str).unwrap_or_default();
if main_agent && event_type == "session.background_tasks_changed" {
self.refresh_background_tasks(session_id);
}
let catalog_snapshot = self.catalog.try_lock().ok().and_then(|g| g.clone());
let (updates, done) = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
if main_agent {
match event_type {
"assistant.turn_start" => entry.main_busy = true,
"assistant.idle" | "session.idle" | "session.error" => entry.main_busy = false,
_ => {}
}
}
let fallback_limit =
catalog_snapshot.as_deref().and_then(|models| entry.settings.active_context_tokens(models));
let translated = entry.translator.translate(session_id, event, fallback_limit);
@@ -846,44 +809,11 @@ impl CopilotShim {
for (target_session, update) in updates {
self.send_update(&target_session, update);
}
if main_agent && event_type == "session.idle" {
// Nothing runs in the background any more.
self.send_update(session_id, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": [] }));
}
if let Some((tx, outcome)) = done {
let _ = tx.send(outcome);
}
}
/// Reports the session's running background shells and agents (`session.tasks.list`).
fn refresh_background_tasks(self: &Arc<Self>, session_id: &str) {
let seq = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
entry.tasks_seq += 1;
entry.tasks_seq
};
let shim = self.clone();
let sid = session_id.to_owned();
self.runtime.spawn(async move {
let Ok(list) = shim.call("session.tasks.list", json!({ "sessionId": sid })).await else { return };
let latest = shim.state.lock().sessions.get(&sid).is_some_and(|e| e.tasks_seq == seq);
if latest {
let tasks = translate::background_tasks(&list);
shim.send_update(&sid, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": tasks }));
}
});
}
/// Stops one background shell or agent (`session.tasks.cancel`).
async fn stop_task(self: &Arc<Self>, params: &Value) -> Result<Value, ResponseError> {
let session_id = str_param(params, "sessionId")?;
let task_id = str_param(params, "taskId")?;
self.call("session.tasks.cancel", json!({ "sessionId": session_id, "id": task_id })).await?;
self.refresh_background_tasks(session_id);
Ok(json!({}))
}
fn handle_permission_event(self: &Arc<Self>, session_id: &str, event: &Value) {
let data = &event["data"];
if data.get("resolvedByHook").and_then(Value::as_bool) == Some(true) {
+2 -97
Переглянути файл
@@ -6,7 +6,6 @@ use ide_jsonrpc::{Framing, Handler, Peer, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::sync::{Arc, OnceLock};
use std::time::Duration;
fn sample_models_list() -> Value {
json!({
@@ -341,12 +340,6 @@ fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
struct FakeCopilotServer {
peer: OnceLock<Peer>,
calls: Mutex<Vec<(String, Value)>>,
/// `session.send` leaves a shell running: the main loop goes idle but the session doesn't.
background_shell: bool,
}
fn copilot_event(sid: &str, event: Value) -> Value {
json!({ "sessionId": sid, "event": event })
}
impl Handler for FakeCopilotServer {
@@ -370,28 +363,6 @@ impl Handler for FakeCopilotServer {
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
Ok(json!({ "success": true }))
}
"session.tasks.list" => Ok(json!({ "tasks": [
{ "id": "shell-1", "type": "shell", "status": "running", "description": "",
"command": "gh pr checks 3819 --watch", "attachmentMode": "attached" },
{ "id": "shell-0", "type": "shell", "status": "completed", "description": "ls", "command": "ls" },
] })),
"session.tasks.cancel" => Ok(json!({ "cancelled": true })),
"session.abort" => Ok(json!({})),
"session.send" if self.background_shell => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
std::thread::spawn(move || {
for event in [
json!({ "id": "b1", "type": "assistant.turn_start", "data": { "turnId": "t1" } }),
json!({ "id": "b2", "type": "assistant.idle", "data": {} }),
json!({ "id": "b3", "type": "session.background_tasks_changed", "data": {} }),
] {
let _ = peer.notify("session.event", copilot_event(&sid, event));
}
});
}
Ok(json!({ "messageId": "msg-1" }))
}
"session.send" => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
@@ -454,8 +425,7 @@ impl Handler for CollectUpdates {
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
@@ -573,8 +543,7 @@ async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_t
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_forwards_disabled_mcp_servers_on_create_and_resume() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates, move |events| {
@@ -621,67 +590,3 @@ async fn shim_forwards_disabled_mcp_servers_on_create_and_resume() {
let (_, resume_params) = calls.iter().find(|(m, _)| m == "session.resume").unwrap();
assert_eq!(resume_params["disabledMcpServers"], disabled);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn stop_ends_a_turn_left_running_only_by_background_shells() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: true });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["backgroundTasks"], true);
let _: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
let prompt_client = client.clone();
let turn = tokio::spawn(async move {
prompt_client
.request::<_, Value>(
"session/prompt",
json!({ "sessionId": "cop-sess-1", "prompt": [{ "type": "text", "text": "watch CI" }] }),
None,
)
.await
});
// The running shell shows as a background task.
let mut shown = None;
for _ in 0..500 {
shown = updates.0.lock().iter().find(|u| u["sessionUpdate"] == crate::BACKGROUND_TASKS_UPDATE).cloned();
if shown.is_some() {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(
shown.unwrap()["tasks"],
json!([{ "task_id": "shell-1", "task_type": "local_bash", "description": "gh pr checks 3819 --watch" }])
);
let _: Value = client
.request("_openidea/stop_task", json!({ "sessionId": "cop-sess-1", "taskId": "shell-1" }), None)
.await
.unwrap();
assert!(
server
.calls
.lock()
.iter()
.any(|(m, p)| m == "session.tasks.cancel" && p["sessionId"] == "cop-sess-1" && p["id"] == "shell-1")
);
// The main loop is idle, so Stop ends the turn even though `session.idle` never comes.
assert!(!turn.is_finished());
client.notify("session/cancel", json!({ "sessionId": "cop-sess-1" })).unwrap();
let res = tokio::time::timeout(Duration::from_secs(5), turn).await.unwrap().unwrap().unwrap();
assert_eq!(res["stopReason"], "cancelled");
assert!(!server.calls.lock().iter().any(|(m, _)| m == "session.abort"));
}
-22
Переглянути файл
@@ -576,28 +576,6 @@ pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Optio
out
}
/// The running entries of a `session.tasks.list` result, in the background-task shape the
/// app shows (`task_id`, `task_type`, `description`).
pub(super) fn background_tasks(list: &Value) -> Vec<Value> {
let tasks = list.get("tasks").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
tasks
.iter()
.filter(|t| matches!(str_of(t, "status"), Some("running" | "idle")))
.filter_map(|t| {
let id = str_of(t, "id")?;
let kind = str_of(t, "type").unwrap_or_default();
let task_type = match kind {
"shell" => "local_bash",
"agent" => "local_agent",
other => other,
};
let description =
str_of(t, "description").filter(|d| !d.is_empty()).or_else(|| str_of(t, "command")).unwrap_or(kind);
Some(json!({ "task_id": id, "task_type": task_type, "description": description }))
})
.collect()
}
fn trim_tail(text: &mut String) {
if text.len() > MAX_OUTPUT {
let mut cut = text.len() - MAX_OUTPUT;
+18 -61
Переглянути файл
@@ -1214,15 +1214,25 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert_eq!(queue.iter().map(|q| q.prompt.text.as_str()).collect::<Vec<_>>(), ["again"]);
assert!(mgr.prompt(&task.id, text(" "), false).await.is_err());
// Sending it now joins the running turn when the agent takes messages mid-turn.
mgr.send_queued_now(&task.id, &queue[0].id).await.unwrap();
assert!(agent.calls.lock().iter().any(|c| c == "_openidea/steer \"again\""));
assert!(!agent.calls.lock().iter().any(|c| c == "session/cancel"));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: true, .. } if text == "again")));
mgr.cancel(&task.id, None).unwrap();
mgr.send_queued_now(&task.id, &queue[0].id).unwrap();
for _ in 0..500 {
if mgr.entries(&task.id, None).unwrap().iter().any(|e| *e == AgentEntry::Agent { text: "second turn".into() }) {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let users: Vec<String> = mgr
.entries(&task.id, None)
.unwrap()
.into_iter()
.filter_map(|e| match e {
AgentEntry::User { text, .. } => Some(text),
_ => None,
})
.collect();
assert_eq!(users, ["wait", "again"]);
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
// Stopping a turn keeps the queue for later.
mgr.prompt(&task.id, text("wait"), false).await.unwrap();
@@ -1237,40 +1247,6 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
}
#[tokio::test(flavor = "multi_thread")]
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent { session_steering: true, ..FakeAgent::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("wait"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
mgr.prompt(&task.id, text("too late"), false).await.unwrap();
let queued = mgr.task(&task.id).unwrap().state.lock().task.queue[0].id.clone();
mgr.send_queued_now(&task.id, &queued).await.unwrap();
// The fake agent's next turn asks for permission.
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
let calls = agent.calls.lock().clone();
assert!(calls.contains(&"_session/steering \"too late\"".to_owned()), "{calls:?}");
assert!(calls.contains(&"session/cancel".to_owned()), "{calls:?}");
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: false, .. } if text == "too late")));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn subagents_get_their_own_conversation() {
let tmp = tempfile::tempdir().unwrap();
@@ -1335,25 +1311,6 @@ async fn subagents_get_their_own_conversation() {
check(&manager(tmp.path(), Arc::new(FakeAgent::default())));
}
#[test]
fn image_blocks_declare_the_type_of_their_bytes() {
let image = |mime: &str, data: &str| AgentImage { mime_type: mime.into(), data: data.into(), name: None };
let cases = [
// A browser's JPEG pasted as PNG.
(image("image/png", "/9j/4AAQSkZJRgABAQ"), "image/jpeg"),
(image("image/jpeg", "iVBORw0KGgoAAAANSUhEUg"), "image/png"),
(image("image/png", "R0lGODlhAQABAIAAAP"), "image/gif"),
(image("image/png", "UklGRiQAAABXRUJQVlA4"), "image/webp"),
// Not recognised: as declared.
(image("image/bmp", "Qk02AAAAAAAAADYAAA"), "image/bmp"),
(image("image/png", "AAA"), "image/png"),
];
for (image, expected) in cases {
let p = AgentPrompt { text: String::new(), files: vec![], images: vec![image] };
assert_eq!(blocks(&p, &[])[0]["mimeType"], expected, "{:?}", p.images[0].data);
}
}
#[test]
fn prompts_become_acp_content_blocks() {
let p = AgentPrompt {
+13 -81
Переглянути файл
@@ -10,14 +10,11 @@ use std::process::Command as ProcCommand;
/// Output file of the `dependency:build-classpath` probe, relative to each module.
const CP_FILE: &str = "target/ide-compile-cp.txt";
// Older records include undeclared reactor test outputs even in runtime classpaths.
const CLASSPATH_CACHE_VERSION: u32 = 1;
/// The resolved dependency classpath for one module and scope, tied to the same
/// inputs as its launch build so POM, JDK, settings and profile changes invalidate it.
#[derive(Debug, Deserialize, Serialize)]
struct CachedClasspath {
version: u32,
fingerprint: LaunchFingerprint,
classpath: String,
}
@@ -135,7 +132,6 @@ pub fn module_classpath(
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
@@ -146,7 +142,7 @@ pub fn module_classpath(
return Err(IdeError::cancelled());
}
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
let cached = CachedClasspath { fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
}
@@ -212,11 +208,11 @@ fn classpath(
if dir == target.module {
continue;
}
// A dependency's tests are not exported with its main artifact. Any explicitly
// declared test artifact is supplied by Maven's resolved classpath below.
let path = dir.join("target/classes");
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
for classes in ["target/classes", "target/test-classes"] {
let path = dir.join(classes);
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
}
}
}
}
@@ -341,19 +337,13 @@ mod tests {
root,
"pom.xml",
r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>
<packaging>pom</packaging><modules><module>shared</module><module>lib</module><module>app</module></modules></project>"#,
<packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,
);
write(
root,
"lib/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>lib</artifactId><dependencies><dependency><groupId>demo</groupId><artifactId>shared</artifactId><version>1</version></dependency></dependencies></project>"#,
);
write(
root,
"shared/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>shared</artifactId></project>"#,
<artifactId>lib</artifactId></project>"#,
);
write(
root,
@@ -364,7 +354,6 @@ mod tests {
write(root, "app/src/main/java/demo/Main.java", "class Main {}");
write(root, "app/src/test/java/demo/MainTest.java", "class MainTest {}");
write(root, "lib/target/classes/Lib.class", "built");
write(root, "shared/target/classes/Shared.class", "built");
crate::load(root, &root.join("cache"), None)
}
@@ -447,9 +436,7 @@ mod tests {
let target = single_file_target(root, &model, &file).unwrap();
assert!(target.top.command.ends_with("mvnw"));
assert_eq!(target.pl, "app");
fs::create_dir_all(root.join("lib/target/test-classes")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
assert!(!std::env::split_paths(&cp).any(|p| p == root.join("lib/target/test-classes")), "{cp}");
let separator = ':';
// Reactor class directories first, so fresh outputs shadow installed snapshots.
let lib = root.join("lib/target/classes").to_string_lossy().into_owned();
@@ -464,16 +451,9 @@ mod tests {
assert!(cp.split(separator).count() >= 3, "{cp}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(!args.lines().any(|a| a == "compile" || a == "package"), "{args}");
fs::create_dir_all(root.join("app/target/test-classes")).unwrap();
let target = single_file_target(root, &model, &root.join("app/src/test/java/demo/MainTest.java")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
let paths: Vec<_> = std::env::split_paths(&cp).collect();
assert_eq!(paths[0], root.join("app/target/test-classes"));
assert!(paths.contains(&root.join("app/target/classes")), "{cp}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{cp}");
}
/// Launches request Maven's matching scope without adding reactor test outputs.
/// A launch uses runtime dependencies, while tests additionally see test-scope ones.
#[cfg(unix)]
#[test]
fn launch_module_classpath_uses_the_matching_dependency_scope() {
@@ -485,29 +465,15 @@ mod tests {
let script = root.join("mvnw");
fs::write(
&script,
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/fixture-tests.jar:/repo/fixture/target/test-classes' > \"$pl/target/ide-compile-cp.txt\"\n",
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/test.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
)
.unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
let model = crate::load(root, &root.join("cache"), None);
for dir in
["app/target/classes", "app/target/test-classes", "lib/target/test-classes", "shared/target/test-classes"]
{
fs::create_dir_all(root.join(dir)).unwrap();
}
let cache = root.join("cache");
let runtime =
module_classpath(root, &model, &root.join("app"), false, None, &cache, &CancellationToken::new()).unwrap();
let paths: Vec<_> = std::env::split_paths(&runtime).collect();
assert!(paths.contains(&root.join("app/target/classes")), "{runtime}");
assert!(paths.contains(&root.join("lib/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("app/target/test-classes")), "{runtime}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{runtime}");
assert!(paths.contains(&root.join("shared/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture-tests.jar")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{runtime}");
assert!(runtime.contains("/repo/runtime.jar"), "{runtime}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "compile"), "{args}");
@@ -516,15 +482,7 @@ mod tests {
let test =
module_classpath(root, &model, &root.join("app"), true, None, &cache, &CancellationToken::new()).unwrap();
assert!(test.contains("/repo/fixture-tests.jar"), "{test}");
let paths: Vec<_> = std::env::split_paths(&test).collect();
assert!(paths.contains(&root.join("app/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("app/target/classes")), "{test}");
assert!(paths.contains(&root.join("lib/target/classes")), "{test}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("shared/target/classes")), "{test}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{test}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{test}");
assert!(test.contains("/repo/test.jar"), "{test}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
}
@@ -533,7 +491,7 @@ mod tests {
/// build input changes; the probe does not run packaging plugins.
#[cfg(unix)]
#[test]
fn launch_classpath_cache_follows_the_runner_jdk_and_format() {
fn launch_classpath_cache_follows_the_runner_jdk() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
@@ -555,7 +513,6 @@ mod tests {
fs::write(home.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
fs::write(home.join("bin/java"), "").unwrap();
}
fs::create_dir_all(root.join("app/target/classes")).unwrap();
let cache = root.join("classpath-cache");
let cancel = CancellationToken::new();
let jdk21 = root.join("jdk21");
@@ -569,30 +526,6 @@ mod tests {
assert_eq!(second, first);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "x");
let record = classpath_cache_path(root, &cache, &root.join("app"), false).unwrap();
let current: serde_json::Value = serde_json::from_slice(&fs::read(&record).unwrap()).unwrap();
let test_output = root.join("lib/target/test-classes");
fs::create_dir_all(&test_output).unwrap();
let polluted = std::env::join_paths(std::env::split_paths(&first).chain([test_output])).unwrap();
let mut calls = "x".to_owned();
for version in [None, Some(0), Some(u32::MAX)] {
let mut stale = current.clone();
stale["classpath"] = polluted.to_string_lossy().as_ref().into();
if let Some(version) = version {
stale["version"] = version.into();
} else {
stale.as_object_mut().unwrap().remove("version");
}
fs::write(&record, serde_json::to_vec(&stale).unwrap()).unwrap();
let rebuilt = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(rebuilt, first, "incompatible cache format {version:?} must be rebuilt");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
let reused = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(reused, rebuilt);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
}
let jdk8 = root.join("jdk8");
for project in &mut model.maven.as_mut().unwrap().projects {
project.env.insert("JAVA_HOME".into(), jdk8.to_string_lossy().into_owned());
@@ -600,7 +533,6 @@ mod tests {
let switched = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert!(switched.contains("jdk8/classpath/jdk.jar"), "{switched}");
assert!(!switched.contains("jdk21/classpath/jdk.jar"), "{switched}");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "xx");
}
}
-18
Переглянути файл
@@ -1,18 +0,0 @@
[package]
name = "ide-command"
description = "Declares OpenIDEA's backend commands once and derives their adapters, trust class and placement"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
proc-macro = true
[dependencies]
heck.workspace = true
proc-macro2.workspace = true
quote.workspace = true
syn.workspace = true
[dev-dependencies]
serde.workspace = true
-92
Переглянути файл
@@ -1,92 +0,0 @@
// Stand-in for the parts of `ide-host` that the code generated by `#[command]`, `domain!` and
// `domains!` names; doctests `include!` it at their crate root.
pub type IdeResult<T> = Result<T, IdeError>;
#[derive(Debug)]
pub struct IdeError(pub String);
impl IdeError {
pub fn unavailable(m: impl Into<String>) -> Self {
Self(m.into())
}
}
pub struct Host;
impl Host {
pub fn plugin_host(&self) -> Option<std::sync::Arc<plugins::PluginHost>> {
None
}
}
pub mod plugins {
pub struct PluginHost;
}
pub mod catalogue {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TrustClass {
Always,
OutsideRestricted,
Trusted,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Placement {
Desktop,
ProjectHost,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
Sync,
Async,
Spawn,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
pub bindings: bool,
pub mode: Mode,
}
}
pub mod ops {
pub struct Channel<T>(pub std::marker::PhantomData<T>);
pub type Emit<T> = std::sync::Arc<dyn Fn(T) + Send + Sync>;
}
pub mod rpc {
use crate::catalogue::TrustClass;
use crate::{IdeResult, ops::Channel};
pub struct Call {
pub host: std::sync::Arc<crate::Host>,
pub window: String,
}
impl Call {
pub fn arg<T: Default>(&self, _name: &str) -> IdeResult<T> {
Ok(T::default())
}
pub fn sender<T>(&self, _name: &str) -> IdeResult<Channel<T>> {
Ok(Channel(std::marker::PhantomData))
}
}
#[derive(Default)]
pub struct Dispatcher(pub Vec<(&'static str, TrustClass)>);
impl Dispatcher {
pub fn add<F, Fut, T>(&mut self, name: &'static str, trust: TrustClass, _f: F) -> &mut Self
where
F: Fn(Call) -> Fut + Send + Sync + 'static,
Fut: Future<Output = IdeResult<T>> + Send + 'static,
T: serde::Serialize,
{
self.0.push((name, trust));
self
}
}
}
-884
Переглянути файл
@@ -1,884 +0,0 @@
//! Declares OpenIDEA's backend commands once, on the fn that implements them.
//!
//! A command that runs on the project host is an `ide-host` fn with `#[command]`; its module
//! lists it in `domain!`, and `ide-host` lists its domains in `domains!`. From that `src-tauri`
//! derives the Tauri adapter and its bindings entry, and `ide-host` derives the JSON-RPC handler
//! `openidea-server` answers. A command only the desktop runs keeps its hand-written Tauri fn,
//! with `#[desktop_command]`, and its module lists it in `desktop_domain!`. Every command
//! declares its trust class, and each declaration yields a `COMMAND`
//! (`ide_host::catalogue::Command`): its name, trust class, placement, bindings entry and
//! execution mode.
//!
//! The examples below build against a stand-in for `ide-host` (`src/doctest_host.rs`). Every
//! `compile_fail` example differs from the example before it only by the mistake it names.
use heck::ToLowerCamelCase;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as T2;
use quote::{ToTokens, format_ident, quote};
use syn::ext::IdentExt;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{FnArg, GenericArgument, Ident, ItemFn, Pat, PathArguments, ReturnType, Token, Type};
/// `#[command(trust = …)]` on a project-host command's implementation in `ide-host`.
///
/// The fn's name is the command's name and its `///` lines are the bindings' docs. Parameters
/// of type `&Host` or `&Arc<Host>`, `window: &str` and `plugins: &Arc<PluginHost>` are injected;
/// every other parameter is an argument, owned, whose key is its camelCase name, and
/// `Channel<T>` streams values back. `async fn` gives an async Tauri adapter, `fn` a sync one.
/// A result of type `IdeResult<T>` is returned as is; any other result is a success. A JSON-RPC
/// request that leaves out an argument marked `#[default]` gets the type's default, so servers
/// keep answering clients older than the argument.
///
/// Options:
/// - `trust = always | outside_restricted | trusted` (required): where the command may run;
/// `always` includes Restricted Mode, `outside_restricted` needs no project or a trusted
/// one, `trusted` needs a trusted project.
/// - `desktop_body = async | sync | spawn`: the Tauri adapter calls the hand-written fn of the
/// same name in `src-tauri` instead of this one, which stays the server's implementation.
/// `spawn` runs that sync body off the invoking thread.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::{Host, IdeResult, ops::Channel};
/// use ide_command::command;
///
/// /// Renames a branch.
/// #[command(trust = trusted)]
/// pub async fn vcs_rename_branch(
/// host: &Host,
/// window: &str,
/// from: String,
/// to: String,
/// unset_upstream: bool,
/// ) -> IdeResult<()> {
/// Ok(())
/// }
///
/// #[command(trust = always)]
/// pub fn vcs_watch(window: &str, #[default] depth: u32, on_event: Channel<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_rename_branch, vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
///
/// fn main() {
/// use catalogue::{Mode, Placement, TrustClass};
/// let mut d = rpc::Dispatcher::default();
/// register_domains(&mut d);
/// assert_eq!(d.0, [("vcs_rename_branch", TrustClass::Trusted), ("vcs_watch", TrustClass::Always)]);
/// let watch = vcs::__cmd_vcs_watch::COMMAND;
/// assert_eq!((watch.placement, watch.bindings, watch.mode), (Placement::ProjectHost, true, Mode::Sync));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_unwatch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// Two commands with one name, in different modules:
///
/// ```compile_fail,E0428
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// pub mod search {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(search: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A borrowed argument:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, path: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A stream that isn't a `Channel<T>`:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::ops::Emit;
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, on_event: Emit<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_command(opts: Opts, mut f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "desktop_body"])?;
let trust = opts.trust()?;
// `#[default]` is read here and not emitted.
let defaulted: Vec<bool> = f
.sig
.inputs
.iter_mut()
.map(|input| match input {
FnArg::Typed(pt) => {
let before = pt.attrs.len();
pt.attrs.retain(|a| !a.path().is_ident("default"));
pt.attrs.len() != before
}
FnArg::Receiver(_) => false,
})
.collect();
let name = &f.sig.ident;
if !f.sig.generics.params.is_empty() {
return Err(syn::Error::new_spanned(&f.sig.generics, "a command is not generic"));
}
let is_async = f.sig.asyncness.is_some();
let (run, body) = match opts.value("desktop_body") {
None if is_async => (format_ident!("async"), quote!(derived)),
None => (format_ident!("sync"), quote!(derived)),
Some(Some(m)) if ["async", "sync", "spawn"].contains(&m.to_string().as_str()) => (m, quote!(desktop)),
Some(v) => return Err(error(v.as_ref().unwrap_or(name), "`desktop_body = async | sync | spawn`")),
};
let mode = match run.to_string().as_str() {
"async" => quote!(Async),
"spawn" => quote!(Spawn),
_ => quote!(Sync),
};
let mut aliases = Vec::new(); // one type alias per argument, resolved in the fn's own scope
let mut args = Vec::new(); // the arguments, for the Tauri adapter's signature
let mut call = Vec::new(); // every parameter in declared order, for the Tauri adapter's call
let mut rpc_call = Vec::new(); // the same, for the JSON-RPC handler
let mut needs_plugins = false;
for (input, defaulted) in f.sig.inputs.iter().zip(defaulted) {
let FnArg::Typed(pt) = input else {
return Err(error(input, "a command is a free fn"));
};
let Pat::Ident(pi) = &*pt.pat else {
return Err(error(&pt.pat, "command parameters are plain identifiers"));
};
let ident = &pi.ident;
let plain_only = || error(ident, "`#[default]` marks a plain argument");
if defaulted && injected(ident, &pt.ty).is_some() {
return Err(plain_only());
}
match injected(ident, &pt.ty) {
Some(Injected::Host) => {
call.push(quote!((inj host)));
rpc_call.push(quote!(&c.host));
continue;
}
Some(Injected::Window) => {
call.push(quote!((inj window)));
rpc_call.push(quote!(&c.window));
continue;
}
Some(Injected::Plugins) => {
needs_plugins = true;
call.push(quote!((inj plugins)));
rpc_call.push(quote!(&plugins));
continue;
}
None => {}
}
if matches!(&*pt.ty, Type::Reference(_)) {
return Err(error(
&pt.ty,
"command arguments are owned; the injected references are `&Host`, `window: &str` and `plugins: &Arc<PluginHost>`",
));
}
let seg = last_segment(&pt.ty);
if seg.is_some_and(|s| s.ident == "Emit") {
return Err(error(&pt.ty, "a command streams through `Channel<T>`, not `Emit<T>`"));
}
let key = ident.unraw().to_string().to_lower_camel_case();
let alias = format_ident!("A{}", args.len());
if let Some(inner) = seg.filter(|s| s.ident == "Channel").and_then(type_argument) {
if defaulted {
return Err(plain_only());
}
aliases.push(quote!(pub type #alias = #inner;));
args.push(quote!((#ident channel #alias)));
call.push(quote!((arg channel #ident)));
rpc_call.push(quote!(c.sender(#key)?));
} else {
let ty = &pt.ty;
aliases.push(quote!(pub type #alias = #ty;));
args.push(quote!((#ident plain #alias)));
call.push(quote!((arg plain #ident)));
rpc_call.push(if defaulted {
quote!(c.arg::<::core::option::Option<#ty>>(#key)?.unwrap_or_default())
} else {
quote!(c.arg(#key)?)
});
}
}
let ret: Type = match &f.sig.output {
ReturnType::Default => syn::parse_quote!(()),
ReturnType::Type(_, t) => (**t).clone(),
};
let fallible = last_segment(&ret).is_some_and(|s| s.ident == "IdeResult");
// specta exports `fn f()` as `void` and `fn f() -> ()` as `null`: keep which one was written.
let ret_alias = match &f.sig.output {
ReturnType::Default => quote!(),
ReturnType::Type(..) => quote!(Ret),
};
let shape = if fallible { quote!(fallible [#ret_alias]) } else { quote!(infallible [#ret_alias]) };
let await_ = is_async.then(|| quote!(.await));
let invoke = quote!(super::#name(#(#rpc_call),*) #await_);
let invoke = if fallible { invoke } else { quote!(Ok(#invoke)) };
let plugins = needs_plugins.then(|| {
quote! {
let plugins = c.host.plugin_host()
.ok_or_else(|| crate::IdeError::unavailable("the plugin host has shut down"))?;
}
});
let docs: Vec<_> = f.attrs.iter().filter(|a| a.path().is_ident("doc")).collect();
let module = format_ident!("__cmd_{}", name);
let tokens = format_ident!("__catalogue_{}", name);
let name_str = name.unraw().to_string();
Ok(quote! {
#f
// Resolves only if this module's `domain!` lists the command.
const _: () = self::__listed::#name;
#[doc(hidden)]
#[allow(non_snake_case)]
pub mod #module {
#[allow(unused_imports)]
use super::*;
#(#aliases)*
pub type Ret = #ret;
pub const COMMAND: crate::catalogue::Command = crate::catalogue::Command {
name: #name_str,
trust: crate::catalogue::TrustClass::#trust,
placement: crate::catalogue::Placement::ProjectHost,
bindings: true,
mode: crate::catalogue::Mode::#mode,
};
/// The JSON-RPC handler.
pub async fn rpc(c: crate::rpc::Call) -> crate::IdeResult<impl ::serde::Serialize + use<>> {
#plugins
#invoke
}
}
/// The command's signature, handed to `$cb!` for `src-tauri` to derive its Tauri adapter.
#[doc(hidden)]
#[macro_export]
macro_rules! #tokens {
([$($cb:tt)*] { $($ctx:tt)* }) => {
$($cb)*! { { $($ctx)* } {
name: #name,
module: #module,
docs: [ #(#docs)* ],
run: #run,
result: #shape,
body: #body,
args: [ #(#args)* ],
call: [ #(#call)* ],
} }
};
}
})
}
/// `domain!(vcs: vcs_status, vcs_rename_branch, …)`: the commands one `ide-host` module
/// declares with `#[command]`, in any order. It goes once at the end of that module and gives it
/// the server's `register`; `domains!` names the domain.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A listed name that isn't a command:
///
/// ```compile_fail,E0433
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch, vcs_unwatch);
/// }
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domain(input: TokenStream) -> TokenStream {
let Domain { name, commands } = syn::parse_macro_input!(input as Domain);
let modules: Vec<_> = commands.iter().map(|c| format_ident!("__cmd_{}", c)).collect();
let tokens: Vec<_> = commands.iter().map(|c| format_ident!("__catalogue_{}", c)).collect();
let list = format_ident!("__domain_{}", name);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
// Resolves only from the `domains!` entry that names this domain.
#[doc(hidden)]
#[allow(non_upper_case_globals)]
pub(crate) const #list: () = ();
/// Adds this module's commands to the server.
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
#( d.add(#modules::COMMAND.name, #modules::COMMAND.trust, #modules::rpc); )*
}
/// `@each`: each command's signature, in list order. `@names`: the list.
#[doc(hidden)]
#[macro_export]
macro_rules! #list {
(@each [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#( #d crate::#tokens!{ [#d (#d cb)*] { #d (#d ctx)* } } )*
};
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
}
.into()
}
/// `domains!(vcs: crate::ops::vcs::commands, …)`, once in `ide-host`: every domain, by the name
/// its `domain!` gives it and the crate path of its module. It gives the server
/// `register_domains`, and hands `src-tauri` the list of domains through `__domains!`.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
/// # fn main() {}
/// ```
///
/// A domain under another name than its `domain!` gives it:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(git: crate::vcs);
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domains(input: TokenStream) -> TokenStream {
let entries = syn::parse_macro_input!(input with Punctuated::<DomainPath, Token![,]>::parse_terminated);
let mut names = Vec::new();
let mut paths = Vec::new();
let mut from_crate = Vec::new();
for DomainPath { name, path } in entries {
let mut segments = path.segments.iter();
if path.leading_colon.is_some() || segments.next().is_none_or(|s| s.ident != "crate") {
return error(&path, "a domain's path starts with `crate::`").to_compile_error().into();
}
let rest: Vec<_> = segments.map(|s| &s.ident).collect();
from_crate.push(quote!(#(#rest)::*));
names.push(name);
paths.push(path);
}
let lists: Vec<_> = names.iter().map(|n| format_ident!("__domain_{}", n)).collect();
let d = quote!($);
quote! {
#( const _: () = #paths::#lists; )*
/// Adds every domain's commands to the server.
pub(crate) fn register_domains(d: &mut crate::rpc::Dispatcher) {
#( #paths::register(d); )*
}
/// `@names`: each domain as `(name __domain_name { path })`.
#[doc(hidden)]
#[macro_export]
macro_rules! __domains {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #( (#names #lists { #d crate::#from_crate }) )* ] }
};
}
}
.into()
}
/// `#[desktop_command(trust = …)]` on a command only the desktop runs, above its
/// `#[tauri::command]` in `src-tauri`, whose `(async)` it reads. The fn is left as written.
///
/// Options: `trust` as for `#[command]` (required), and `bindings = none` for a command that is
/// registered outside tauri-specta; such a command isn't listed in `desktop_domain!`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
///
/// fn main() {
/// let text = clipboard::clipboard_text::COMMAND;
/// assert_eq!((text.name, text.placement), ("clipboard_text", catalogue::Placement::Desktop));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_html() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn desktop_command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_desktop_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_desktop_command(opts: Opts, f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "bindings"])?;
let trust = opts.trust()?;
let bindings = match opts.value("bindings") {
None => true,
Some(Some(v)) if v == "none" => false,
Some(v) => return Err(error(v.as_ref().unwrap_or(&f.sig.ident), "`bindings = none`")),
};
// `#[tauri::command(async)]` runs a sync fn off the invoking thread.
let spawned = f.attrs.iter().any(|a| {
let path = a.path();
path.segments.len() == 2
&& path.segments[0].ident == "tauri"
&& path.segments[1].ident == "command"
&& a.parse_args::<Ident>().is_ok_and(|i| i == "async")
});
let mode = if f.sig.asyncness.is_some() {
quote!(Async)
} else if spawned {
quote!(Spawn)
} else {
quote!(Sync)
};
let name = &f.sig.ident;
let name_str = name.unraw().to_string();
let listed = bindings.then(|| quote!(const _: () = self::__listed::#name;));
Ok(quote! {
#f
#listed
#[doc(hidden)]
pub mod #name {
pub const COMMAND: ::ide_host::catalogue::Command = ::ide_host::catalogue::Command {
name: #name_str,
trust: ::ide_host::catalogue::TrustClass::#trust,
placement: ::ide_host::catalogue::Placement::Desktop,
bindings: #bindings,
mode: ::ide_host::catalogue::Mode::#mode,
};
}
})
}
/// `desktop_domain!(clipboard_text, clipboard_write_text, …)`: the `#[desktop_command]`s of one
/// `src-tauri` module that are in the bindings, in any order. It goes once at the end of that
/// module and gives it `__desktop_domain!(@names …)`.
#[proc_macro]
pub fn desktop_domain(input: TokenStream) -> TokenStream {
let commands = syn::parse_macro_input!(input with Punctuated::<Ident, Token![,]>::parse_terminated);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
#[doc(hidden)]
macro_rules! __desktop_domain {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
#[allow(unused_imports)]
pub(crate) use __desktop_domain;
}
.into()
}
/// `sorted_catalogue!(bindings: a::x, b::y, …; raw: c::z, …)`, in `src-tauri`: every command,
/// sorted by name, as `(collect_commands![…bindings…], [COMMAND, …every command…])`. Each path
/// names a command fn and the module of the same name that holds its `COMMAND`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear;
/// raw:
/// );
/// assert_eq!(commands, ["clipboard :: clipboard_clear", "clipboard :: clipboard_text"]);
/// assert_eq!(rows.map(|c| c.name), ["clipboard_clear", "clipboard_text"]);
/// }
/// ```
///
/// Two commands with one name:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// pub mod editor {
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear, editor::clipboard_clear;
/// raw:
/// );
/// }
/// ```
#[proc_macro]
pub fn sorted_catalogue(input: TokenStream) -> TokenStream {
let Catalogue { bindings, raw } = syn::parse_macro_input!(input as Catalogue);
let key = |p: &syn::Path| p.segments.last().map(|s| s.ident.unraw().to_string()).unwrap_or_default();
let mut bindings: Vec<_> = bindings.into_iter().collect();
bindings.sort_by_cached_key(key);
let mut all: Vec<_> = bindings.iter().chain(&raw).collect();
all.sort_by_cached_key(|p| key(p));
for pair in all.windows(2) {
if key(pair[0]) == key(pair[1]) {
let (a, b) = (pair[0], pair[1]);
let message = format!(
"command `{}` is declared twice: `{}` and `{}`",
key(b),
a.to_token_stream(),
b.to_token_stream()
);
return syn::Error::new_spanned(b, message).to_compile_error().into();
}
}
quote! {
(
::tauri_specta::collect_commands![ #(#bindings),* ],
[ #( #all::COMMAND ),* ],
)
}
.into()
}
struct Catalogue {
bindings: Punctuated<syn::Path, Token![,]>,
raw: Punctuated<syn::Path, Token![,]>,
}
impl Parse for Catalogue {
fn parse(input: ParseStream) -> syn::Result<Self> {
let paths = |input: ParseStream, label: &str| -> syn::Result<Punctuated<syn::Path, Token![,]>> {
let ident: Ident = input.parse()?;
if ident != label {
return Err(error(&ident, &format!("expected `{label}:`")));
}
input.parse::<Token![:]>()?;
let mut out = Punctuated::new();
while !input.is_empty() && !input.peek(Token![;]) {
out.push_value(input.parse()?);
if !input.peek(Token![,]) {
break;
}
out.push_punct(input.parse()?);
}
Ok(out)
};
let bindings = paths(input, "bindings")?;
input.parse::<Token![;]>()?;
let raw = paths(input, "raw")?;
let _ = input.parse::<Option<Token![;]>>()?;
Ok(Self { bindings, raw })
}
}
enum Injected {
Host,
Window,
Plugins,
}
/// `&Host` or `&Arc<Host>` under any name, `window: &str`, `plugins: &Arc<PluginHost>`.
fn injected(ident: &Ident, ty: &Type) -> Option<Injected> {
let Type::Reference(r) = ty else { return None };
if r.mutability.is_some() {
return None;
}
let seg = last_segment(&r.elem)?;
let arc_of =
|name: &str| seg.ident == "Arc" && type_argument(seg).and_then(last_segment).is_some_and(|s| s.ident == name);
if seg.ident == "Host" || arc_of("Host") {
Some(Injected::Host)
} else if ident == "window" && seg.ident == "str" {
Some(Injected::Window)
} else if ident == "plugins" && arc_of("PluginHost") {
Some(Injected::Plugins)
} else {
None
}
}
fn last_segment(ty: &Type) -> Option<&syn::PathSegment> {
match ty {
Type::Path(p) if p.qself.is_none() => p.path.segments.last(),
_ => None,
}
}
fn type_argument(seg: &syn::PathSegment) -> Option<&Type> {
match &seg.arguments {
PathArguments::AngleBracketed(a) => a.args.iter().find_map(|g| match g {
GenericArgument::Type(t) => Some(t),
_ => None,
}),
_ => None,
}
}
fn error(span: impl ToTokens, message: &str) -> syn::Error {
syn::Error::new_spanned(span, message)
}
/// `name: a, b, …`
struct Domain {
name: Ident,
commands: Punctuated<Ident, Token![,]>,
}
impl Parse for Domain {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, commands: Punctuated::parse_terminated(input)? })
}
}
/// `name: crate::path`
struct DomainPath {
name: Ident,
path: syn::Path,
}
impl Parse for DomainPath {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, path: input.parse()? })
}
}
/// An attribute's options: `key = value` and bare `key`.
struct Opts(Vec<(Ident, Option<Ident>)>);
impl Parse for Opts {
fn parse(input: ParseStream) -> syn::Result<Self> {
let mut out = Vec::new();
while !input.is_empty() {
let key: Ident = input.parse()?;
let value = if input.peek(Token![=]) {
input.parse::<Token![=]>()?;
// `async` is a keyword.
Some(Ident::parse_any(input)?)
} else {
None
};
out.push((key, value));
if !input.is_empty() {
input.parse::<Token![,]>()?;
}
}
Ok(Self(out))
}
}
impl Opts {
fn value(&self, key: &str) -> Option<Option<Ident>> {
self.0.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
}
fn only(&self, known: &[&str]) -> syn::Result<()> {
match self.0.iter().map(|(k, _)| k).find(|k| !known.iter().any(|n| *k == n)) {
Some(k) => Err(error(k, &format!("unknown option; the options are {}", known.join(", ")))),
None => Ok(()),
}
}
fn trust(&self) -> syn::Result<T2> {
match self.value("trust").flatten().map(|t| t.to_string()).as_deref() {
Some("always") => Ok(quote!(Always)),
Some("outside_restricted") => Ok(quote!(OutsideRestricted)),
Some("trusted") => Ok(quote!(Trusted)),
_ => Err(syn::Error::new(
proc_macro2::Span::call_site(),
"every command declares its trust class: `trust = always | outside_restricted | trusted`",
)),
}
}
}
-13
Переглянути файл
@@ -147,19 +147,6 @@ pub enum IdeEvent {
server: ServerId,
kind: LspRefreshKind,
},
/// A language server asked the user to choose an action, e.g. Dart's
/// "Renamed field will be invisible in …" warning during a rename. Answered
/// with `lsp_message_request_answer`; the server cancels if we reply null.
LspMessageRequest {
id: u32,
server: String,
message: String,
actions: Vec<String>,
},
/// The request was answered or timed out; every window drops its dialog.
LspMessageRequestDone {
id: u32,
},
TerminalExited {
terminal: TerminalId,
code: Option<i32>,
+1 -33
Переглянути файл
@@ -24,16 +24,6 @@ pub enum DockerEndpoint {
Tcp { host: String, tls_cert_dir: Option<String> },
/// A named `docker context`.
Context { name: String },
/// A daemon on the host of an SSH configuration (Settings › Tools › SSH Configurations),
/// reached with the IDE's own SSH client and its saved credentials. The host resolves it to
/// a local [`DockerEndpoint::Tcp`] tunnel before running docker; unresolved, the CLI is
/// pointed at an address it rejects rather than at another daemon.
Ssh { config: String },
}
/// What an unresolved [`DockerEndpoint::Ssh`] gives the CLI: an error, never a fallback daemon.
fn unresolved_ssh(config: &str) -> String {
format!("ssh-configuration://{}", config.trim())
}
impl DockerEndpoint {
@@ -65,7 +55,6 @@ impl DockerEndpoint {
args
}
Self::Context { name } => vec!["--context".into(), name.trim().to_owned()],
Self::Ssh { config } => vec!["--host".into(), unresolved_ssh(config)],
}
}
@@ -112,11 +101,6 @@ impl DockerEndpoint {
set("DOCKER_HOST", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
Self::Ssh { config } => {
set("DOCKER_HOST", unresolved_ssh(config));
set("DOCKER_CONTEXT", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
}
env
}
@@ -127,13 +111,8 @@ impl DockerEndpoint {
Self::Socket { path } => path.trim().is_empty(),
Self::Tcp { host, .. } => host.trim().is_empty(),
Self::Context { name } => name.trim().is_empty() || name.trim().starts_with('-'),
Self::Ssh { config } => config.trim().is_empty(),
};
if empty {
Err(IdeError::invalid("the Docker connection needs a socket, host, context or SSH configuration"))
} else {
Ok(())
}
if empty { Err(IdeError::invalid("the Docker connection needs a socket, host or context")) } else { Ok(()) }
}
}
@@ -346,17 +325,6 @@ fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
mod tests {
use super::*;
#[test]
fn an_unresolved_ssh_endpoint_never_falls_back_to_another_daemon() {
let ssh = DockerEndpoint::Ssh { config: "box".into() };
assert_eq!(ssh.global_args(), ["--host", "ssh-configuration://box"]);
let env = ssh.env_vars();
assert_eq!((env["DOCKER_HOST"].as_str(), env["DOCKER_CONTEXT"].as_str()), ("ssh-configuration://box", ""));
assert!(ssh.validate().is_ok());
assert!(DockerEndpoint::Ssh { config: " ".into() }.validate().is_err());
assert!(!crate::endpoint_is_local(&ssh).unwrap());
}
#[test]
fn endpoint_args() {
assert!(DockerEndpoint::Default.global_args().is_empty());
-1
Переглянути файл
@@ -483,7 +483,6 @@ pub fn endpoint_is_local(ep: &DockerEndpoint) -> IdeResult<bool> {
|name| context_host(&DockerEndpoint::Default, name),
)?,
DockerEndpoint::Context { name } => context_host(&DockerEndpoint::Default, Some(name.trim()))?,
DockerEndpoint::Ssh { .. } => return Ok(false),
};
Ok(daemon_url_is_local(&url))
}
-1
Переглянути файл
@@ -11,7 +11,6 @@ path = "src/bin/server.rs"
[dependencies]
encoding_rs.workspace = true
ide-command.workspace = true
ide-core.workspace = true
ide-mcp.workspace = true
futures.workspace = true
+1 -2
Переглянути файл
@@ -1,7 +1,6 @@
//! `openidea-server --stdio`: the IDE backend for remote development, serving
//! one desktop client over stdin / stdout (started by the client over SSH).
use ide_host::catalogue::TrustClass;
use ide_host::plugins::remote::{RemotePluginLanguages, SYNC_COMMAND};
use ide_host::plugins::remote_host::RemotePlugins;
use ide_host::rpc::{self, Dispatcher};
@@ -103,7 +102,7 @@ async fn run(base: PathBuf) -> i32 {
if let Some(plugins) = &plugins {
plugins.register(&mut dispatcher);
}
dispatcher.add(SYNC_COMMAND, TrustClass::Trusted, move |c| {
dispatcher.add(SYNC_COMMAND, move |c| {
let remote = plugin_languages.clone();
async move {
let report = remote.sync(c.arg("languages")?);
-40
Переглянути файл
@@ -1,40 +0,0 @@
//! What every command declares: its trust class, where it runs, and how Tauri runs it.
//! `#[ide_command::command]` and `#[ide_command::desktop_command]` give each command a
//! [`Command`].
/// Where a command may run, from the trust decision of the window's project.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TrustClass {
/// Everywhere, including Restricted Mode.
Always,
/// With no project open, or in a trusted project.
OutsideRestricted,
/// Only in a trusted project.
Trusted,
}
/// Which backend runs a command for a remote window.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Placement {
Desktop,
ProjectHost,
}
/// How Tauri runs the command: on the invoking thread, as a future, or on its thread pool.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Mode {
Sync,
Async,
Spawn,
}
/// One command's declaration.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
/// In `bindings.ts`; a command registered outside tauri-specta isn't.
pub bindings: bool,
pub mode: Mode,
}
+1 -5
Переглянути файл
@@ -4,7 +4,6 @@
//! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
pub mod agent_secrets;
pub mod catalogue;
pub mod data_dirs;
pub mod diagnostics_store;
pub mod environment;
@@ -24,7 +23,7 @@ pub mod rpc;
pub mod shell_env;
pub mod trust;
pub use project::{Project, apply_git_executable, history_retention};
pub use project::{Project, apply_git_executable, apply_workspace_edit, history_retention};
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId, SharedSink};
use ide_language::{LanguageRegistry, Syntax};
@@ -92,8 +91,6 @@ pub struct Host {
pub ssh: Arc<ide_ssh::SshManager>,
/// SFTP deployment, remote file editing and runs on run targets.
pub remote: Arc<ide_remote::RemoteService>,
/// Tunnels of Docker connections made through an SSH configuration.
pub docker_tunnels: ops::docker::DockerTunnels,
/// What child processes get beyond this process's environment (Reload Environment, `remoteEnv`).
pub environment: environment::Environment,
/// The built-in web server (Open In › Browser, the editor's browser bar). On a remote host the
@@ -164,7 +161,6 @@ impl Host {
agent_secrets: Arc::new(agent_secrets::AgentSecrets::new(&data_dir)),
remote: Arc::new(ide_remote::RemoteService::new(ssh.clone(), data_dir.join("remote"))),
ssh,
docker_tunnels: Default::default(),
environment: environment::Environment::new(project_environment, local_data_dir.clone()),
web: ide_web::WebServer::new(),
global_settings,
+3 -3
Переглянути файл
@@ -873,15 +873,15 @@ async fn occurrences(
let host = call.host();
let request = crate::mcp::tool::request_id();
let files = Arc::new(Mutex::new(Vec::new()));
let emit = {
let emit: crate::ops::Emit<SearchEvent> = {
let files = files.clone();
crate::ops::Channel::new(move |event: SearchEvent| {
Arc::new(move |event| {
if let SearchEvent::File { file } = event {
files.lock().push(file);
}
})
};
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
tokio::pin!(search);
tokio::select! {
r = &mut search => r?,
+1 -1
Переглянути файл
@@ -57,7 +57,7 @@ The maximum accepted limit is 5000 lines.",
probe.size
)));
}
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
Ok(Output::text(render_slice(&text, offset as usize, limit as usize, window)?))
},
)
+2 -2
Переглянути файл
@@ -37,7 +37,7 @@ Returns each request's 0-based `index`, optional `name`, `method`, URL as writte
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::fs_read_text(&call.host(), call.window(), 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| {
@@ -139,7 +139,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
}
let index = index as u32;
let env = call.opt_str("env")?;
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path.clone()).await?;
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)))?;
+2 -4
Переглянути файл
@@ -9,7 +9,7 @@ pub use requests::Requests;
mod files;
mod http;
mod page;
pub mod reports;
mod reports;
mod scope;
mod search;
mod symbols;
@@ -19,9 +19,7 @@ mod util;
use crate::Host;
use ide_core::{CancellationToken, IdeError};
use ide_mcp::{ToolCallError, ToolRegistry};
pub use reports::{
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
};
pub use reports::{FileProblems, FocusedEditor, Reports};
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
use std::path::{Path, PathBuf};
use std::sync::Arc;
-39
Переглянути файл
@@ -1,5 +1,4 @@
//! Window-owned snapshots. A project close drops every report from that window.
use ide_command::command;
use ide_core::{Diagnostic, IpcPath, Range};
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
@@ -135,37 +134,6 @@ impl Reports {
}
}
#[command(trust = trusted)]
pub fn mcp_set_open_editors(host: &crate::Host, window: &str, paths: Vec<IpcPath>) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.set_open_editors(window, paths.into_iter().map(PathBuf::from).collect());
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_set_focused_editor(
host: &crate::Host,
window: &str,
editor: Option<FocusedEditor>,
focused: bool,
) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.set_focused_editor(window, editor, focused);
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_report_problems(
host: &crate::Host,
window: &str,
reset: bool,
files: Vec<FileProblems>,
) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.report_problems(window, reset, files);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
@@ -186,10 +154,3 @@ mod tests {
assert_eq!(windows, ["a", "b", "never", "c"]);
}
}
ide_command::domain!(
mcp_reports:
mcp_report_problems,
mcp_set_focused_editor,
mcp_set_open_editors,
);
+4 -4
Переглянути файл
@@ -418,10 +418,10 @@ input). Terminal keys (arrows, Escape, Backspace, Ctrl+Z…) are refused. To ans
host.processes.write_stdin(id, &std::mem::take(&mut data))?;
}
if key == Key::EndOfInput {
crate::ops::run::run_close_stdin(&host, id)?;
crate::ops::run::close_stdin(&host, id)?;
} else {
run.agent_stopping();
crate::ops::run::run_stop(&host, &run.window(), id)?;
crate::ops::run::stop(&host, &run.window(), id)?;
break;
}
}
@@ -455,10 +455,10 @@ keeps `stopping`: call again with `force`. The tab stays open with its output."
let deadline = deadline(&call, STOP_TIMEOUT_MS)?;
let host = call.host();
run.agent_stopping();
crate::ops::run::run_stop(&host, &run.window(), id)?;
crate::ops::run::stop(&host, &run.window(), id)?;
if force {
// A second Stop kills the tree.
crate::ops::run::run_stop(&host, &run.window(), id)?;
crate::ops::run::stop(&host, &run.window(), id)?;
}
let end = run.wait(deadline, None, run.log_len(), &call.cancel).await?;
let mut extra = Map::new();
+6 -6
Переглянути файл
@@ -283,7 +283,7 @@ fn run_exit(host: &crate::Host, id: RunId) -> Option<Option<i32>> {
match host.processes.exit_code(id) {
Ok(exit) => exit,
// Remote (SSH) runs, or a finished run already forgotten: the run list knows whether it runs.
Err(_) => match crate::ops::run::run_list(host).into_iter().find(|r| r.id == id) {
Err(_) => match crate::ops::run::list(host).into_iter().find(|r| r.id == id) {
Some(r) if r.running => None,
_ => Some(None),
},
@@ -304,7 +304,7 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
tokio::select! {
_ = tokio::time::sleep(Duration::from_millis(50)) => {}
_ = call.cancel.cancelled() => {
let _ = crate::ops::run::run_stop(&host, call.window(), id);
let _ = crate::ops::run::stop(&host, call.window(), id);
return Err(IdeError::cancelled());
}
}
@@ -313,9 +313,9 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
/// An output callback that skips the IDE's own lines (`Process finished…`), as JetBrains
/// skips `ProcessOutputType.SYSTEM`.
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Channel<OutputChunk> {
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Emit<OutputChunk> {
let f = Mutex::new(move |t: &str| f(t));
crate::ops::Channel::new(move |chunk: OutputChunk| match &chunk {
Arc::new(move |chunk: OutputChunk| match &chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } => (f.lock())(text),
OutputChunk::System { .. } => {}
})
@@ -356,7 +356,7 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
t.drain(..cut);
}
});
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await?;
let info = crate::ops::run::start(&call.host(), call.window(), config, emit).await?;
let exit = wait_exit(call, info.id, None).await?.flatten();
if exit == Some(0) {
return Ok(true);
@@ -612,7 +612,7 @@ one by one",
let output_path = collector.lock().path.clone();
let sink = collector.clone();
let emit = process_output(move |text| sink.lock().append(text));
let info = match crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await {
let info = match crate::ops::run::start(&call.host(), call.window(), config, emit).await {
Ok(info) => info,
Err(e) => {
let _ = std::fs::remove_file(&output_path);
+7 -7
Переглянути файл
@@ -317,7 +317,7 @@ async fn fill_lines(
for item in items {
let (Some(path), Some(line)) = (absolute(item), item.start_line) else { continue };
if current.as_ref().is_none_or(|(p, _)| p != &path) {
let text = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await.ok();
let text = crate::ops::fs::read_text(&host, call.window(), path.clone()).await.ok();
let lines = text.map(|t| t.split('\n').map(|l| l.strip_suffix('\r').unwrap_or(l).to_owned()).collect());
current = Some((path, lines));
}
@@ -595,7 +595,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
// such lines are matched again in the file's whole text.
let long = |m: &ide_search::LineMatch| m.text_offset > 0 || m.text.encode_utf16().count() + 1 >= LINE_WINDOW;
let whole = if file.matches.iter().any(long) {
crate::ops::fs::fs_read_text(&host, call.window(), file.path.0.clone())
crate::ops::fs::read_text(&host, call.window(), file.path.0.clone())
.await
.ok()
.and_then(|text| Some((ide_search::match_ranges(&text, &query).ok()?, text)))
@@ -678,7 +678,7 @@ async fn extend_spanning(call: &Call, query: &SearchQuery, hits: &mut [TextHit],
let mut current: Option<FileText> = None;
for (i, path) in spanning {
if current.as_ref().is_none_or(|(p, ..)| p != &path) {
let Ok(text) = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await else { continue };
let Ok(text) = crate::ops::fs::read_text(&host, call.window(), path.clone()).await else { continue };
let Ok(ranges) = ide_search::match_ranges(&text, query) else { continue };
let starts = std::iter::once(0).chain(text.match_indices('\n').map(|(i, _)| i + 1)).collect();
current = Some((path, text, starts, ranges));
@@ -714,14 +714,14 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
let request = crate::mcp::tool::request_id();
let files = Arc::new(Mutex::new(Vec::new()));
let done = Arc::new(Mutex::new(None));
let emit = {
let emit: crate::ops::Emit<SearchEvent> = {
let (files, done) = (files.clone(), done.clone());
crate::ops::Channel::new(move |event: SearchEvent| match event {
Arc::new(move |event| match event {
SearchEvent::File { file } => files.lock().push(file),
SearchEvent::Done { summary } => *done.lock() = Some(summary),
})
};
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
tokio::pin!(search);
let mut timed_out = false;
tokio::select! {
@@ -822,7 +822,7 @@ impl Walk {
/// Collects matching files under `dir` (inside the walked root `base`) depth first in
/// name order; true when it stopped early: more than `limit` match or the time ran out.
fn dir(&self, dir: &Path, base: &Path, found: &mut Vec<String>) -> bool {
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::fs_read_dir(
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::read_dir(
&self.host,
&self.window,
dir.to_path_buf(),
+142 -169
Переглянути файл
@@ -1,8 +1,9 @@
//! Agents tool window: coding agent tasks of the project (over ACP). In a remote
//! window they run on the host, next to the project they work on.
use super::Channel;
use super::{Channel, Emit};
use crate::Host;
use crate::agent_secrets::{AgentSecrets, Kept};
use crate::rpc::Dispatcher;
use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
@@ -10,7 +11,6 @@ use ide_agent::{
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
};
use ide_command::command;
use ide_core::error::ErrorKind;
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
use ide_tools::InstallEvent;
@@ -18,47 +18,38 @@ use std::collections::HashSet;
use std::sync::{LazyLock, Mutex};
/// Streams the project's agent events to this window; returns every task.
#[command(trust = always)]
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
let _ = on_event.send(e);
})))
pub fn subscribe(host: &Host, window: &str, on_event: Emit<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(on_event))
}
#[command(trust = trusted)]
pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
host.require_trust(window)?;
let mut providers = host.project(window)?.agents.providers();
ide_agent::registry::mark_updates(&registry_paths(host), &mut providers);
Ok(providers)
}
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
#[command(trust = trusted)]
pub fn agent_refresh_models(
/// Refreshes the selected agent's model catalog without sending a prompt.
pub fn refresh_models(
host: &Host,
window: &str,
provider: String,
force: bool,
model: Option<String>,
) -> IdeResult<AgentModelCatalog> {
// Refreshes the selected agent's model catalog without sending a prompt.
host.require_trust(window)?;
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
}
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
/// built-in's driver and arguments), or returns it to auto-detection with `None`.
#[command(trust = trusted)]
pub fn agent_set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
pub fn set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.set_builtin_command(&id, command)
}
/// Environment variables built-in agent `id` starts with (saved in its agent file);
/// an empty map clears them.
#[command(trust = trusted)]
pub fn agent_set_env(
/// Environment variables built-in agent `id` starts with; empty clears them.
pub fn set_env(
host: &Host,
window: &str,
id: String,
@@ -97,8 +88,7 @@ fn join_err(e: impl std::fmt::Display) -> IdeError {
/// Agents of the ACP Registry this machine can run, with what is installed; the list
/// saved earlier when the registry is unreachable. Cancel with `cancel_request(request)`.
#[command(trust = always)]
pub async fn agent_registry_list(host: &Host, request: RequestId) -> IdeResult<AgentRegistry> {
pub async fn registry_list(host: &Host, _window: &str, request: RequestId) -> IdeResult<AgentRegistry> {
let paths = registry_paths(host);
let cancel = host.begin_request(request);
let result =
@@ -140,15 +130,15 @@ impl Drop for Installing {
}
/// Installs the registry's current version of agent `id` (also to update it), streaming
/// progress through `on_event`. Cancel with `cancel_request(request)`.
#[command(trust = always)]
pub async fn agent_registry_install(
/// progress through `on_event`; the agent then shows in `agent_providers`. Cancel with
/// `cancel_request(request)`.
pub async fn registry_install(
host: &Host,
_window: &str,
id: String,
request: RequestId,
on_event: Channel<InstallEvent>,
) -> IdeResult<()> {
// The agent then shows in `agent_providers`.
let paths = registry_paths(host);
let installing = Installing::begin(&id)?;
let cancel = host.begin_request(request);
@@ -199,8 +189,7 @@ pub async fn agent_registry_install(
}
/// Removes a registry agent: its agent file and installed files.
#[command(trust = always)]
pub async fn agent_registry_remove(host: &Host, id: String) -> IdeResult<()> {
pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResult<()> {
let paths = registry_paths(host);
tokio::task::spawn_blocking(move || ide_agent::registry::remove(&paths, &id)).await.map_err(join_err)??;
for project in host.projects() {
@@ -211,8 +200,7 @@ pub async fn agent_registry_remove(host: &Host, id: String) -> IdeResult<()> {
/// Slash commands to complete for `provider` in `task`'s directory, or in the project
/// before a task exists (skills and custom commands on disk included).
#[command(trust = always)]
pub async fn agent_commands(
pub async fn commands(
host: &Host,
window: &str,
provider: String,
@@ -222,36 +210,26 @@ pub async fn agent_commands(
}
/// Entries of `task`'s conversation, or of its subagent `subagent`'s.
#[command(trust = always)]
pub fn agent_entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
pub fn entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
host.project(window)?.agents.entries(&task, subagent)
}
/// Sessions of the project on this machine that no task holds yet, newest first.
#[command(trust = trusted)]
pub async fn agent_external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
// Reads transcripts from disk on the blocking pool.
/// Sessions of the project on this machine that no task holds yet, newest first. Reads
/// transcripts from disk on the blocking pool.
pub async fn external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
let agents = host.project(window)?.agents.clone();
tokio::task::spawn_blocking(move || agents.external_sessions()).await.map_err(join_err)
}
/// Imports an external session as a task: its first turn loads and replays it.
#[command(trust = trusted)]
pub async fn agent_import_session(
host: &Host,
window: &str,
provider: String,
session_id: String,
) -> IdeResult<AgentTask> {
pub async fn import_session(host: &Host, window: &str, provider: String, session_id: String) -> IdeResult<AgentTask> {
host.require_trust(window)?;
let agents = host.project(window)?.agents.clone();
tokio::task::spawn_blocking(move || agents.import_session(&provider, &session_id)).await.map_err(join_err)?
}
#[command(trust = trusted)]
pub async fn agent_create(host: &Host, window: &str, request: NewAgentTask) -> IdeResult<AgentTask> {
pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> IdeResult<AgentTask> {
host.require_trust(window)?;
let mut request = request;
let project = host.project(window)?;
let root = project.root.clone();
let requested = request.project_root.take();
@@ -262,123 +240,98 @@ pub async fn agent_create(host: &Host, window: &str, request: NewAgentTask) -> I
}
/// Sends a message; while the agent works it is queued, or with `now` it interrupts the turn.
#[command(trust = trusted)]
pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
pub async fn prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.prompt(&task, prompt, now).await
}
/// Drops a queued message and returns it (to edit it).
#[command(trust = always)]
pub fn agent_unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
pub fn unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
host.project(window)?.agents.unqueue(&task, &queued)
}
/// Sends a queued message now, interrupting the current turn.
#[command(trust = trusted)]
pub async fn agent_send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
pub fn send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.send_queued_now(&task, &queued).await
host.project(window)?.agents.send_queued_now(&task, &queued)
}
/// Changes a session setting (model, mode, thinking effort…).
#[command(trust = trusted)]
pub async fn agent_set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
pub async fn set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.set_config(&task, &option, value).await
}
/// Copies the task's conversation into a new task, up to its first `turns` turns (all when `None`).
#[command(trust = trusted)]
pub async fn agent_fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
host.require_trust(window)?;
host.project(window)?.agents.fork(&task, turns).await
}
/// Drops the task's turns after its first `turns`; returns the message of the first dropped one.
#[command(trust = trusted)]
pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
pub async fn rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
host.require_trust(window)?;
host.project(window)?.agents.rollback(&task, turns).await
}
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
/// or sign-in run). Remembered until `refresh`.
#[command(trust = trusted)]
pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
/// What the agent reports about itself when it starts, without opening a session.
pub async fn probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
host.require_trust(window)?;
host.project(window)?.agents.probe(&provider, refresh).await
}
/// Stops the task's current turn, or with `subagent` only that subagent's work.
#[command(trust = always)]
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
pub fn cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
host.project(window)?.agents.cancel(&task, subagent)
}
/// Stops one of the task's background tasks.
#[command(trust = always)]
pub async fn agent_stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
pub async fn stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
host.project(window)?.agents.stop_background(&task, &background).await
}
/// Answers a permission request; `option: null` cancels it.
#[command(trust = trusted)]
pub fn agent_respond(
host: &Host,
window: &str,
task: String,
permission: u32,
option: Option<String>,
) -> IdeResult<()> {
/// Answers a permission request; `option: None` cancels it.
pub fn respond(host: &Host, window: &str, task: String, permission: u32, option: Option<String>) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.respond(&task, permission, option)
}
#[command(trust = always)]
pub fn agent_archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
pub fn archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
host.project(window)?.agents.archive(&task)
}
#[command(trust = always)]
pub fn agent_unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
pub fn unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
host.project(window)?.agents.unarchive(&task)
}
#[command(trust = trusted)]
pub fn agent_rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
pub fn rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
host.project(window)?.agents.rename(&task, &title)
}
#[command(trust = trusted)]
pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
pub async fn delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.delete(&task, remove_worktree).await
}
#[command(trust = trusted)]
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
pub async fn changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
host.require_trust(window)?;
host.project(window)?.agents.changes(&task).await
}
/// The task's uncommitted changes and the commits made since it started.
#[command(trust = trusted)]
pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
pub async fn grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
host.require_trust(window)?;
host.project(window)?.agents.grouped_changes(&task).await
}
/// Content of `path` when the task started (left side of its diff).
#[command(trust = trusted)]
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
pub async fn base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
host.require_trust(window)?;
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
}
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
#[command(trust = trusted)]
pub async fn agent_rollback_changes(
pub async fn rollback_changes(
host: &Host,
window: &str,
task: String,
@@ -391,8 +344,7 @@ pub async fn agent_rollback_changes(
/// Accept: copies a worktree task's changed files among `paths` (all without) into the
/// local checkout, uncommitted; files the checkout changed itself are left alone and reported.
#[command(trust = trusted)]
pub async fn agent_accept_changes(
pub async fn accept_changes(
host: &Host,
window: &str,
task: String,
@@ -596,18 +548,15 @@ pub(crate) fn session_mcp_servers(
out
}
/// Lists configured and discovered MCP servers across User, Workspace, Plugin, and Built-In scopes.
#[command(trust = always)]
pub fn agent_mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
// Configured servers of the User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
/// Lists configured MCP servers across User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
let (user, workspace, project) = mcp_maps(host, window);
Ok(listed(host, project.as_ref(), &user, workspace))
}
/// Creates or updates a User or Workspace MCP server and returns the updated list.
#[command(trust = always)]
pub fn agent_mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
// A Workspace server saved here is one the user turned on.
/// Creates or updates a User or Workspace MCP server and returns the updated list. A Workspace
/// server saved here is one the user turned on.
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
let approve: Vec<String> =
(input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned()).into_iter().collect();
update_mcp_maps(host, window, &approve, |user, workspace, project_root| {
@@ -616,9 +565,8 @@ pub fn agent_mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeRe
}
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
/// single server object).
#[command(trust = always)]
pub fn agent_mcp_save_json(
/// single server object). Workspace servers explicitly saved here by the user are approved.
pub fn mcp_save_json(
host: &Host,
window: &str,
scope: McpScope,
@@ -626,7 +574,6 @@ pub fn agent_mcp_save_json(
fallback_name: Option<String>,
agents: Vec<String>,
) -> IdeResult<Vec<McpServer>> {
// Workspace servers explicitly saved here by the user are approved.
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
let saved = ide_agent::mcp::apply_save_json(
user,
@@ -642,8 +589,7 @@ pub fn agent_mcp_save_json(
}
/// Enables or disables an MCP server and returns the updated list.
#[command(trust = always)]
pub fn agent_mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
.map(|(_, name)| name.to_owned())
@@ -655,17 +601,15 @@ pub fn agent_mcp_set_enabled(host: &Host, window: &str, id: String, enabled: boo
}
/// Removes a User or Workspace MCP server and returns the updated list.
#[command(trust = always)]
pub fn agent_mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| Vec::new())
})
}
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once.
#[command(trust = always)]
pub fn agent_mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
// They stay off until the user turns them on.
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once;
/// they stay off until the user turns them on.
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |_, workspace, project_root| {
let root = project_root.ok_or_else(|| "Open a project to import workspace MCP servers".to_string())?;
ide_agent::mcp::apply_import(workspace, root);
@@ -674,8 +618,7 @@ pub fn agent_mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>>
}
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
#[command(trust = always)]
pub async fn agent_mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
let project_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let home = dirs::home_dir();
tokio::task::spawn_blocking(move || {
@@ -686,15 +629,14 @@ pub async fn agent_mcp_discover_sources(host: &Host, window: &str) -> IdeResult<
}
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
#[command(trust = always)]
pub async fn agent_mcp_import_selected(
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
pub async fn mcp_import_selected(
host: &Host,
window: &str,
scope: McpScope,
selections: Vec<McpImportSelection>,
overwrite: bool,
) -> IdeResult<Vec<McpServer>> {
// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
let home = dirs::home_dir();
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
ide_agent::mcp::apply_import_selected(
@@ -711,8 +653,7 @@ pub async fn agent_mcp_import_selected(
}
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
#[command(trust = trusted)]
pub async fn agent_mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
host.require_trust(window)?;
let (user, workspace, project) = mcp_maps(host, window);
let (scope, name) = ide_agent::mcp::parse_server_id(&id)
@@ -892,9 +833,8 @@ fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
Err("Unexpected non-JSON MCP response".into())
}
/// Updates per-session MCP server enable/disable overrides on `task`.
#[command(trust = always)]
pub fn agent_set_mcp_overrides(
/// Updates per-session MCP server enable/disable overrides on task `task`.
pub fn set_mcp_overrides(
host: &Host,
window: &str,
task: String,
@@ -903,6 +843,85 @@ pub fn agent_set_mcp_overrides(
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
d.add("agent_refresh_models", |c| async move {
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?)
});
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
d.add("agent_registry_list", |c| async move { registry_list(&c.host, &c.window, c.arg("request")?).await });
d.add("agent_registry_install", |c| async move {
registry_install(&c.host, &c.window, c.arg("id")?, c.arg("request")?, c.sender("onEvent")?).await
});
d.add("agent_registry_remove", |c| async move { registry_remove(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_mcp_list", |c| async move { mcp_list(&c.host, &c.window) });
d.add("agent_mcp_save", |c| async move { mcp_save(&c.host, &c.window, c.arg("input")?) });
d.add("agent_mcp_save_json", |c| async move {
mcp_save_json(&c.host, &c.window, c.arg("scope")?, c.arg("rawJson")?, c.arg("fallbackName")?, c.arg("agents")?)
});
d.add(
"agent_mcp_set_enabled",
|c| async move { mcp_set_enabled(&c.host, &c.window, c.arg("id")?, c.arg("enabled")?) },
);
d.add("agent_mcp_remove", |c| async move { mcp_remove(&c.host, &c.window, c.arg("id")?) });
d.add("agent_mcp_import", |c| async move { mcp_import(&c.host, &c.window) });
d.add("agent_mcp_discover_sources", |c| async move { mcp_discover_sources(&c.host, &c.window).await });
d.add("agent_mcp_import_selected", |c| async move {
mcp_import_selected(&c.host, &c.window, c.arg("scope")?, c.arg("selections")?, c.arg("overwrite")?).await
});
d.add("agent_mcp_test", |c| async move { mcp_test(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_set_mcp_overrides", |c| async move {
set_mcp_overrides(&c.host, &c.window, c.arg("task")?, c.arg("overrides")?)
});
d.add("agent_commands", |c| async move { commands(&c.host, &c.window, c.arg("provider")?, c.arg("task")?).await });
d.add("agent_entries", |c| async move { entries(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_create", |c| async move { create(&c.host, &c.window, c.arg("request")?).await });
d.add("agent_external_sessions", |c| async move { external_sessions(&c.host, &c.window).await });
d.add("agent_import_session", |c| async move {
import_session(&c.host, &c.window, c.arg("provider")?, c.arg("sessionId")?).await
});
d.add("agent_prompt", |c| async move {
prompt(&c.host, &c.window, c.arg("task")?, c.arg("prompt")?, c.arg("now")?).await
});
d.add("agent_unqueue", |c| async move { unqueue(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) });
d.add(
"agent_send_queued_now",
|c| async move { send_queued_now(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) },
);
d.add("agent_set_config", |c| async move {
set_config(&c.host, &c.window, c.arg("task")?, c.arg("option")?, c.arg("value")?).await
});
d.add("agent_fork", |c| async move { fork(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
d.add("agent_rollback", |c| async move { rollback(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
d.add("agent_probe", |c| async move { probe(&c.host, &c.window, c.arg("provider")?, c.arg("refresh")?).await });
d.add("agent_cancel", |c| async move { cancel(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_stop_background", |call| async move {
stop_background(&call.host, &call.window, call.arg("task")?, call.arg("background")?).await
});
d.add("agent_respond", |c| async move {
respond(&c.host, &c.window, c.arg("task")?, c.arg("permission")?, c.arg("option")?)
});
d.add("agent_unarchive", |c| async move { unarchive(&c.host, &c.window, c.arg("task")?) });
d.add("agent_rename", |c| async move { rename(&c.host, &c.window, c.arg("task")?, c.arg("title")?) });
d.add("agent_archive", |c| async move { archive(&c.host, &c.window, c.arg("task")?) });
d.add(
"agent_delete",
|c| async move { delete(&c.host, &c.window, c.arg("task")?, c.arg("removeWorktree")?).await },
);
d.add("agent_changes", |c| async move { changes(&c.host, &c.window, c.arg("task")?).await });
d.add("agent_grouped_changes", |c| async move { grouped_changes(&c.host, &c.window, c.arg("task")?).await });
d.add("agent_base_text", |c| async move { base_text(&c.host, &c.window, c.arg("task")?, c.arg("path")?).await });
d.add("agent_rollback_changes", |c| async move {
rollback_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?, c.arg("view")?).await
});
d.add("agent_accept_changes", |c| async move {
accept_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?).await
});
}
fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::Path>) -> IdeResult<std::path::PathBuf> {
let Some(requested) = requested else {
return Ok(root.to_path_buf());
@@ -1011,49 +1030,3 @@ mod tests {
assert!(!reloaded.approved(&tmp.path().join("other"), "extra", &extra));
}
}
ide_command::domain!(
agent:
agent_accept_changes,
agent_archive,
agent_base_text,
agent_cancel,
agent_changes,
agent_commands,
agent_create,
agent_delete,
agent_entries,
agent_external_sessions,
agent_fork,
agent_grouped_changes,
agent_import_session,
agent_mcp_discover_sources,
agent_mcp_import,
agent_mcp_import_selected,
agent_mcp_list,
agent_mcp_remove,
agent_mcp_save,
agent_mcp_save_json,
agent_mcp_set_enabled,
agent_mcp_test,
agent_probe,
agent_prompt,
agent_providers,
agent_refresh_models,
agent_registry_install,
agent_registry_list,
agent_registry_remove,
agent_rename,
agent_respond,
agent_rollback,
agent_rollback_changes,
agent_send_queued_now,
agent_set_command,
agent_set_config,
agent_set_env,
agent_set_mcp_overrides,
agent_stop_background,
agent_subscribe,
agent_unarchive,
agent_unqueue,
);
+18 -16
Переглянути файл
@@ -6,7 +6,7 @@
use crate::Host;
use crate::Project;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use super::doc::blocking;
use ide_analysis::{
@@ -122,7 +122,6 @@ pub struct StructuralLanguage {
/// Inspect Code: diagnostics of every file in `scope` that a language server
/// serves. Files stream through `on_event` as they finish; ends with `Done`.
#[command(trust = trusted)]
pub async fn inspect_code(
host: &Host,
window: &str,
@@ -196,7 +195,6 @@ pub async fn inspect_code(
}
/// Locate Duplicates over the files of `scope`.
#[command(trust = always)]
pub async fn analysis_locate_duplicates(
host: &Host,
window: &str,
@@ -219,8 +217,7 @@ pub async fn analysis_locate_duplicates(
}
/// Languages Search Structurally supports (those with a bundled grammar).
#[command(trust = always)]
pub async fn structural_languages(host: &Host) -> IdeResult<Vec<StructuralLanguage>> {
pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<StructuralLanguage>> {
let syntax = host.syntax();
let mut out: Vec<StructuralLanguage> = host
.languages
@@ -234,8 +231,7 @@ pub async fn structural_languages(host: &Host) -> IdeResult<Vec<StructuralLangua
}
/// Checks a structural search template (and language) while the user types.
#[command(trust = always)]
pub async fn structural_validate(host: &Host, query: StructuralQuery) -> IdeResult<()> {
pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQuery) -> IdeResult<()> {
let syntax = host.syntax();
blocking(move || ide_analysis::validate_structural(&syntax, &query)).await
}
@@ -243,7 +239,6 @@ pub async fn structural_validate(host: &Host, query: StructuralQuery) -> IdeResu
/// Search Structurally over `scope`; files with matches stream through
/// `on_event`, ending with `Done`. With a replacement, matches carry their
/// replacement text (applied by the UI as a workspace edit).
#[command(trust = always)]
pub async fn structural_search(
host: &Host,
window: &str,
@@ -270,11 +265,18 @@ pub async fn structural_search(
Ok(())
}
ide_command::domain!(
analysis:
analysis_locate_duplicates,
inspect_code,
structural_languages,
structural_search,
structural_validate,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("inspect_code", |c| async move {
inspect_code(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.sender("onEvent")?).await
});
d.add("analysis_locate_duplicates", |c| async move {
analysis_locate_duplicates(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("options")?).await
});
d.add("structural_languages", |c| async move { structural_languages(&c.host, &c.window).await });
d.add("structural_validate", |c| async move { structural_validate(&c.host, &c.window, c.arg("query")?).await });
d.add("structural_search", |c| async move {
structural_search(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("query")?, c.sender("onEvent")?)
.await
});
}
+91 -62
Переглянути файл
@@ -4,8 +4,8 @@ mod workspace;
use super::dependencies::{MavenCentralArtifacts, MavenCentralGroups, MavenCentralVersions};
use crate::ops::Channel;
use crate::{Host, Project};
use ide_command::command;
use crate::rpc::Dispatcher;
use crate::{Host, Project, apply_workspace_edit};
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
use ide_build::maven::PomGoto;
@@ -126,7 +126,6 @@ fn with_profiles(mut model: BuildModel, cache: &Path) -> BuildModel {
}
/// Maven and Gradle projects of the window's project, from the build files plus the last sync.
#[command(trust = trusted)]
pub async fn build_model(host: &Host, window: &str) -> IdeResult<BuildModel> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -203,15 +202,13 @@ async fn set_gradle_projects(host: &Host, window: &str, paths: Vec<String>, link
.map_err(join_err)?
}
#[command(trust = trusted)]
/// Links independent builds without changing their Gradle scripts.
pub async fn gradle_link_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
// Links independent builds without changing their Gradle scripts.
set_gradle_projects(host, window, paths, true).await
}
#[command(trust = trusted)]
/// Stops importing the selected independent builds; files and saved run configurations stay intact.
pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
// Stops importing the selected independent builds; files and saved run configurations stay intact.
set_gradle_projects(host, window, paths, false).await
}
@@ -219,7 +216,6 @@ pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String
/// background, reporting progress on `on_progress`; cancellable with `cancel_request(request)`.
/// Returns the refreshed model; a failed build is reported in its `syncError`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn build_sync(
host: &Host,
window: &str,
@@ -423,8 +419,7 @@ fn declaring_pom(
}
/// The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
/// build has downloaded it.
#[command(trust = trusted)]
/// build has downloaded it (`ide_sdk::libraries::published_version_catalog`).
pub async fn gradle_published_catalog(
host: &Host,
window: &str,
@@ -439,8 +434,8 @@ pub async fn gradle_published_catalog(
.map_err(join_err)
}
/// The resolved dependency tree of a Gradle project for one configuration (Dependency Analyzer).
#[command(trust = trusted)]
/// The resolved dependency tree of the Gradle project `gradle_path` (`:`, `:app`) for
/// `configuration`, from Gradle's `dependencies` report; cancellable with `cancel_request(request)`.
pub async fn gradle_dependencies(
host: &Host,
window: &str,
@@ -450,7 +445,6 @@ pub async fn gradle_dependencies(
request: RequestId,
build_dir: Option<String>,
) -> IdeResult<Vec<ide_build::GradleDependency>> {
// `gradle_path` is `:`, `:app`…; the tree comes from Gradle's `dependencies` report.
host.require_trust(window)?;
let project = host.project(window)?;
let config = host.config_dir.clone();
@@ -524,7 +518,6 @@ pub(crate) fn analyzed_dependencies(
}
/// Where the direct dependency `dependency` of the Maven module `pom` is declared.
#[command(trust = trusted)]
pub async fn maven_dependency_declaration(
host: &Host,
window: &str,
@@ -541,15 +534,14 @@ pub async fn maven_dependency_declaration(
.map_err(join_err)?
}
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
/// The go-to-declaration target at `pos` of the Maven POM `pom` (project-relative, or
/// absolute for a parent POM opened from the local repository): the definition of the
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
/// entry providing the dependency's / plugin's version, along the parent chain.
#[command(trust = trusted)]
/// entry providing the dependency's / plugin's version, along the parent chain (into
/// the local repository when a parent is not in the project), else the artifact's own
/// POM (a project module's, or the local repository's). `None` when nothing
/// resolvable is under the caret.
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
// The parent chain reaches into the local repository when a parent is not in the project;
// without a managed version the target is the artifact's own POM (a project module's, or the
// local repository's). `None` when nothing resolvable is under the caret.
let project = host.project(window)?;
tokio::task::spawn_blocking(move || {
let given = Path::new(&pom);
@@ -580,8 +572,12 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
/// Completion of the `<dependency>` coordinate the caret (`offset`, UTF-16) sits
/// in the value of in the POM `doc`, from the local repository and Maven Central.
#[command(trust = trusted)]
/// in the value of in the POM `doc`: the coordinates installed in the local
/// repository (Settings › Maven's, else `~/.m2/repository`) — group ids,
/// the chosen group's artifacts, the chosen artifact's versions — topped up
/// with Maven Central's (the search endpoint's popular coordinates, the
/// published version metadata), which the shared version cache keeps for the
/// session. `None` when the caret is not in a `<dependency>` coordinate element.
pub async fn maven_dependency_completion(
host: &Host,
window: &str,
@@ -589,10 +585,6 @@ pub async fn maven_dependency_completion(
offset: u32,
request: RequestId,
) -> IdeResult<Option<PomCompletion>> {
// The local repository is Settings › Maven's, else `~/.m2/repository` (group ids, the chosen
// group's artifacts, the chosen artifact's versions), topped up with Maven Central's (the search
// endpoint's popular coordinates, the published version metadata), which the shared version
// cache keeps for the session. `None` when the caret is not in a `<dependency>` coordinate element.
use ide_build::maven::completion::{PomCompletionKind, local_options};
let project = host.project(window)?;
let cache = host.dependency_versions.clone();
@@ -662,7 +654,6 @@ pub async fn maven_dependency_completion(
/// Adds an `<exclusion>` of `exclusion` to the declaration of the direct dependency
/// `dependency` of the Maven module `pom`, through the open document when there is one
/// (saved). Returns the declaration; nothing changes when it already excludes it.
#[command(trust = trusted)]
pub async fn maven_exclude_dependency(
host: &Host,
window: &str,
@@ -680,7 +671,7 @@ pub async fn maven_exclude_dependency(
files: vec![FileEdit::Edit { path: path.clone().into(), edits: vec![edit], version: None }],
..Default::default()
};
project.documents.apply_workspace_edit(&edit)?;
apply_workspace_edit(&project.documents, &edit)?;
}
Some(Exclusion::Present) => {}
None => return Err(IdeError::not_found(format!("{dependency} is not declared in {}", path.display()))),
@@ -787,7 +778,6 @@ fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id:
/// with `cancel_request(request)`. Diagnostics of `clear` (the files of the previous build)
/// are cleared first; the new messages are published as `build` diagnostics.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn build_run(
host: &Host,
window: &str,
@@ -886,19 +876,12 @@ pub async fn build_run(
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
}
Ok::<_, IdeError>(result)
Ok(result)
})
.await
.map_err(join_err);
host.end_request(request);
let outcome = result??;
// Maven generated sources (protobuf, gRPC) stay invisible to jdtls until the
// folders the build wrote are attached. An up-to-date build skips Maven and
// still needs this: the classes can already be on disk.
if outcome.system == ide_build::compile::BuildSystem::Maven {
project.lsp.sync_maven_generated_sources(&project.root).await;
}
Ok(outcome)
result?
}
/// Build › Compile File: compiles one Java source of a linked Maven module with
@@ -906,7 +889,6 @@ pub async fn build_run(
/// `cancel_request(request)`. Diagnostics of `clear` (the files of the previous
/// build) are cleared first; the new messages are published as `build`
/// diagnostics.
#[command(trust = trusted)]
pub async fn build_compile_file(
host: &Host,
window: &str,
@@ -935,16 +917,79 @@ pub async fn build_compile_file(
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
}
Ok::<_, IdeError>(result)
Ok(result)
})
.await
.map_err(join_err);
host.end_request(request);
let outcome = result??;
if outcome.system == ide_build::compile::BuildSystem::Maven {
project.lsp.sync_maven_generated_sources(&project.root).await;
}
Ok(outcome)
result?
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("build_model", |c| async move { build_model(&c.host, &c.window).await });
d.add("gradle_link_projects", |c| async move { gradle_link_projects(&c.host, &c.window, c.arg("paths")?).await });
d.add(
"gradle_unlink_projects",
|c| async move { gradle_unlink_projects(&c.host, &c.window, c.arg("paths")?).await },
);
d.add("build_sync", |c| async move {
build_sync(
&c.host,
&c.window,
c.arg("tool")?,
c.arg("request")?,
c.arg("offline")?,
c.arg("profiles")?,
c.arg("buildDir")?,
c.sender("onProgress")?,
)
.await
});
d.add("gradle_published_catalog", |c| async move {
gradle_published_catalog(&c.host, &c.window, c.arg("coordinates")?).await
});
d.add("gradle_dependencies", |c| async move {
gradle_dependencies(
&c.host,
&c.window,
c.arg("gradlePath")?,
c.arg("configuration")?,
c.arg("offline")?,
c.arg("request")?,
c.arg("buildDir")?,
)
.await
});
d.add("maven_dependency_declaration", |c| async move {
maven_dependency_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?).await
});
d.add("maven_goto_declaration", |c| async move {
maven_goto_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("pos")?).await
});
d.add("maven_dependency_completion", |c| async move {
maven_dependency_completion(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
});
d.add("maven_exclude_dependency", |c| async move {
maven_exclude_dependency(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?, c.arg("exclusion")?).await
});
d.add("build_run", |c| async move {
build_run(
&c.host,
&c.window,
c.arg("kind")?,
c.arg("file")?,
c.arg("cmake")?,
c.arg("request")?,
c.arg("clear")?,
c.sender("onEvent")?,
)
.await
});
d.add("build_compile_file", |c| async move {
build_compile_file(&c.host, &c.window, c.arg("file")?, c.arg("request")?, c.arg("clear")?, c.sender("onEvent")?)
.await
});
}
#[cfg(test)]
@@ -1271,19 +1316,3 @@ mod maven_completion_tests {
host.close_project("main");
}
}
ide_command::domain!(
build:
build_compile_file,
build_model,
build_run,
build_sync,
gradle_dependencies,
gradle_link_projects,
gradle_published_catalog,
gradle_unlink_projects,
maven_dependency_completion,
maven_dependency_declaration,
maven_exclude_dependency,
maven_goto_declaration,
);
+14 -11
Переглянути файл
@@ -1,6 +1,6 @@
//! Raw file bytes for the image viewer and hex view (see `ide_vfs::bytes`).
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use crate::ops::doc::blocking;
use ide_core::IdeResult;
@@ -8,24 +8,27 @@ use ide_vfs::{ByteRange, FileProbe};
use std::path::PathBuf;
/// Size and text/binary classification, from the file's head only.
#[command(trust = always)]
pub async fn fs_probe(path: PathBuf) -> IdeResult<FileProbe> {
pub async fn fs_probe(_host: &Host, _window: &str, path: PathBuf) -> IdeResult<FileProbe> {
blocking(move || ide_vfs::probe(&path)).await
}
/// Up to `len` bytes from `offset` (capped per call), base64-encoded.
#[command(trust = always)]
pub async fn fs_read_range(path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
pub async fn fs_read_range(_host: &Host, _window: &str, path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
blocking(move || ide_vfs::read_range(&path, offset, len)).await
}
/// An image file as a `data:` URL.
#[command(trust = always)]
pub async fn fs_read_image(host: &Host, path: PathBuf) -> IdeResult<String> {
// A network path is read only from a share an open project is on: the path may come from
// Markdown, and opening a share signs in to its server.
/// An image file as a `data:` URL. A network path is read only from a share an open project is
/// on: the path may come from Markdown, and opening a share signs in to its server.
pub async fn fs_read_image(host: &Host, _window: &str, path: PathBuf) -> IdeResult<String> {
let opened: Vec<PathBuf> = host.projects().iter().map(|project| project.root.clone()).collect();
blocking(move || ide_vfs::read_data_url(&path, &opened)).await
}
ide_command::domain!(bytes: fs_probe, fs_read_image, fs_read_range);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("fs_probe", |c| async move { fs_probe(&c.host, &c.window, c.arg("path")?).await });
d.add("fs_read_range", |c| async move {
fs_read_range(&c.host, &c.window, c.arg("path")?, c.arg("offset")?, c.arg("len")?).await
});
d.add("fs_read_image", |c| async move { fs_read_image(&c.host, &c.window, c.arg("path")?).await });
}
+8 -7
Переглянути файл
@@ -1,6 +1,6 @@
//! Run with Coverage: launch plans and coverage reports.
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, IpcPath};
use ide_coverage::{CoveragePrepared, CoverageReportSpec, CoverageSuite};
@@ -15,7 +15,6 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
/// How to run `config` with coverage: the command to launch and where its report will be,
/// or which tool is missing.
#[command(trust = trusted)]
pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> IdeResult<CoveragePrepared> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -28,19 +27,21 @@ pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> I
}
/// Reads the report a coverage run left behind.
#[command(trust = trusted)]
pub async fn coverage_collect(host: &Host, window: &str, report: CoverageReportSpec) -> IdeResult<CoverageSuite> {
host.require_trust(window)?;
blocking(move || ide_coverage::collect(&report)).await
}
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile or JaCoCo XML,
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile, JaCoCo XML or a SimpleCov resultset,
/// with paths mapped into this project.
#[command(trust = always)]
pub async fn coverage_import(host: &Host, window: &str, path: IpcPath) -> IdeResult<CoverageSuite> {
// Also reads a SimpleCov resultset.
let root = host.project(window)?.root.clone();
blocking(move || ide_coverage::import(&path, &root)).await
}
ide_command::domain!(coverage: coverage_collect, coverage_import, coverage_prepare);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("coverage_prepare", |c| async move { coverage_prepare(&c.host, &c.window, c.arg("config")?).await });
d.add("coverage_collect", |c| async move { coverage_collect(&c.host, &c.window, c.arg("report")?).await });
d.add("coverage_import", |c| async move { coverage_import(&c.host, &c.window, c.arg("path")?).await });
}
+293 -235
Переглянути файл
@@ -3,7 +3,7 @@
//! shell: its path comes from a local save dialog, so the export must land
//! on the user's machine, not the side the project runs on.
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_db::split::SqlStatement;
use ide_db::{
@@ -24,15 +24,172 @@ pub struct StatementOutcome {
pub error: Option<String>,
}
#[command(trust = trusted)]
pub fn db_sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
// The data sources configured for the project (the tree's roots).
pub(crate) fn register(d: &mut Dispatcher) {
d.add("db_sources", |c| async move { sources(&c.host, &c.window) });
d.add("db_save_sources", |c| async move {
let sources = c.arg("sources")?;
save_sources(&c.host, &c.window, sources).await
});
d.add("db_set_password", |c| async move {
let (id, password, save) =
(c.arg::<String>("id")?, c.arg::<Option<String>>("password")?, c.arg::<bool>("save")?);
set_password(&c.host, &c.window, &id, password, save).await
});
d.add("db_test", |c| async move {
let (source, password, ssh_secret) = (
c.arg::<DataSource>("source")?,
c.arg::<Option<String>>("password")?,
c.arg::<Option<String>>("sshSecret")?,
);
test(&c.host, &c.window, source, password, ssh_secret).await
});
d.add("db_test_tunnel", |c| async move {
let (source, ssh_secret) = (c.arg::<DataSource>("source")?, c.arg::<Option<String>>("sshSecret")?);
test_tunnel(&c.host, &c.window, source, ssh_secret).await
});
d.add("db_set_ssh_secret", |c| async move {
let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
set_ssh_secret(&c.host, &c.window, &id, secret, save).await
});
d.add("db_trust_ssh_host", |c| async move {
let id = c.arg::<String>("id")?;
trust_ssh_host(&c.host, &c.window, &id).await
});
d.add("db_connected", |c| async move { connected(&c.host, &c.window) });
d.add("db_connect", |c| async move {
let id = c.arg::<String>("id")?;
connect(&c.host, &c.window, &id).await
});
d.add("db_set_manual_commit", |c| async move {
let (id, manual) = (c.arg::<String>("id")?, c.arg::<bool>("manual")?);
set_manual_commit(&c.host, &c.window, &id, manual).await
});
d.add("db_finish_transaction", |c| async move {
let (id, commit) = (c.arg::<String>("id")?, c.arg::<bool>("commit")?);
finish_transaction(&c.host, &c.window, &id, commit).await
});
d.add("db_disconnect", |c| async move {
let id = c.arg::<String>("id")?;
disconnect(&c.host, &c.window, &id).await
});
d.add("db_databases", |c| async move {
let id = c.arg::<String>("id")?;
databases(&c.host, &c.window, &id).await
});
d.add("db_database_catalog", |c| async move {
let (id, database) = (c.arg::<String>("id")?, c.arg::<String>("database")?);
database_catalog(&c.host, &c.window, &id, &database).await
});
d.add("db_saved_catalog", |c| async move {
let id = c.arg::<String>("id")?;
saved_catalog(&c.host, &c.window, &id).await
});
d.add("db_retain_catalog", |c| async move {
let (id, databases) = (c.arg::<String>("id")?, c.arg::<Vec<String>>("databases")?);
retain_catalog(&c.host, &c.window, &id, databases).await
});
d.add("db_session_context", |c| async move {
let id = c.arg::<String>("id")?;
session_context(&c.host, &c.window, &id).await
});
d.add("db_schemas", |c| async move {
let id = c.arg::<String>("id")?;
schemas(&c.host, &c.window, &id).await
});
d.add("db_tables", |c| async move {
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
tables(&c.host, &c.window, &id, &schema).await
});
d.add("db_table_details", |c| async move {
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
table_details(&c.host, &c.window, &id, &schema, &table).await
});
d.add("db_ddl", |c| async move {
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
ddl(&c.host, &c.window, &id, &schema, &table).await
});
d.add("db_schema_objects", |c| async move {
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
schema_objects(&c.host, &c.window, &id, &schema).await
});
d.add("db_object_ddl", |c| async move {
let (id, schema, kind, name) = (
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<DbObjectKind>("kind")?,
c.arg::<String>("name")?,
);
object_ddl(&c.host, &c.window, &id, &schema, kind, &name).await
});
d.add("db_explain", |c| async move {
let (request, id, statement) =
(c.arg::<RequestId>("request")?, c.arg::<String>("id")?, c.arg::<String>("statement")?);
let schema = c.arg::<Option<String>>("schema")?;
explain(&c.host, &c.window, request, &id, &statement, schema.as_deref()).await
});
d.add("db_history", |c| async move {
let id = c.arg::<String>("id")?;
history(&c.host, &c.window, &id).await
});
d.add("db_remove_history", |c| async move {
let (id, texts) = (c.arg::<String>("id")?, c.arg::<Option<Vec<String>>>("texts")?);
remove_history(&c.host, &c.window, &id, texts).await
});
d.add("db_completion", |c| async move {
let id = c.arg::<String>("id")?;
completion(&c.host, &c.window, &id).await
});
d.add("db_statements", |c| async move {
let (id, text, from, to) =
(c.arg::<String>("id")?, c.arg::<String>("text")?, c.arg::<u32>("from")?, c.arg::<u32>("to")?);
statements(&c.host, &c.window, &id, &text, from, to)
});
d.add("db_execute", |c| async move {
let (request, id, statements, skip, max_rows) = (
c.arg::<RequestId>("request")?,
c.arg::<String>("id")?,
c.arg::<Vec<SqlStatement>>("statements")?,
c.arg::<Option<u32>>("skip")?.unwrap_or(0),
c.arg::<u32>("maxRows")?,
);
let schema = c.arg::<Option<String>>("schema")?;
execute(&c.host, &c.window, request, &id, statements, skip, max_rows, schema.as_deref()).await
});
d.add("db_table_page", |c| async move {
let (request, id, schema, table) = (
c.arg::<RequestId>("request")?,
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<String>("table")?,
);
let (filter, sort, offset, limit) = (
c.arg::<Option<String>>("filter")?,
c.arg::<Vec<SortKey>>("sort")?,
c.arg::<u32>("offset")?,
c.arg::<u32>("limit")?,
);
table_page(&c.host, &c.window, request, &id, &schema, &table, filter, sort, offset, limit).await
});
d.add("db_apply_edits", |c| async move {
let (id, schema, table, edits) = (
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<String>("table")?,
c.arg::<Vec<DbRowEdit>>("edits")?,
);
apply_edits(&c.host, &c.window, &id, &schema, &table, edits).await
});
d.add("db_console_path", |c| async move { console_path(&c.host, &c.arg::<String>("id")?) });
d.add("db_consoles", |c| async move { consoles(&c.host, &c.arg::<String>("id")?, c.arg("create")?) });
}
/// The data sources configured for the project (the tree's roots).
pub fn sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
host.project(window)?.db.sources()
}
#[command(trust = trusted)]
pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
// Replaces the project's data sources with `sources`.
/// Replaces the project's data sources with `sources`.
pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.save_sources(sources).await?;
let root = host.project(window)?.root.clone();
@@ -42,279 +199,222 @@ pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>
Ok(())
}
#[command(trust = trusted)]
pub async fn db_set_password(
host: &Host,
window: &str,
id: String,
password: Option<String>,
save: bool,
) -> IdeResult<()> {
// Remembers the password of data source `id` for the session, and in the OS
// saved passwords when `save` (`None` forgets it).
/// Remembers the password of data source `id` for the session, and in the OS
/// saved passwords when `save` (`None` forgets it).
pub async fn set_password(host: &Host, window: &str, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.set_password(&id, password, save).await
db.set_password(id, password, save).await
}
#[command(trust = trusted)]
pub async fn db_test(
/// Test Connection: connects with unsaved settings and returns the server version.
pub async fn test(
host: &Host,
window: &str,
source: DataSource,
password: Option<String>,
ssh_secret: Option<String>,
) -> IdeResult<String> {
// Test Connection: connects with unsaved settings and returns the server version.
let db = host.project(window)?.db.clone();
db.test(&source, password, ssh_secret).await
}
/// Data Source › SSH/SSL › Test SSH Tunnel.
#[command(trust = trusted)]
pub async fn db_test_tunnel(
/// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
pub async fn test_tunnel(
host: &Host,
window: &str,
source: DataSource,
ssh_secret: Option<String>,
) -> IdeResult<String> {
// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
let db = host.project(window)?.db.clone();
db.test_tunnel(&source, ssh_secret).await
}
#[command(trust = trusted)]
pub async fn db_set_ssh_secret(
host: &Host,
window: &str,
id: String,
secret: Option<String>,
save: bool,
) -> IdeResult<()> {
// Remembers the SSH password / key passphrase of a data source (see `db_set_password`).
/// Remembers the SSH password / key passphrase of a data source (see `set_password`).
pub async fn set_ssh_secret(host: &Host, window: &str, id: &str, secret: Option<String>, save: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.set_ssh_secret(&id, secret, save).await
db.set_ssh_secret(id, secret, save).await
}
#[command(trust = trusted)]
pub async fn db_trust_ssh_host(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Trusts the SSH host key that made the last connection of `id` fail with
// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
/// Trusts the SSH host key that made the last connection of `id` fail with
/// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
pub async fn trust_ssh_host(host: &Host, window: &str, id: &str) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.trust_ssh_host(&id).await
db.trust_ssh_host(id).await
}
#[command(trust = trusted)]
pub fn db_connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
// The data sources with an open connection.
/// The data sources with an open connection.
pub fn connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
Ok(host.project(window)?.db.connected())
}
#[command(trust = trusted)]
pub async fn db_connect(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Connects (fails with `permissionDenied` when the password is missing or wrong).
/// Connects (fails with `permissionDenied` when the password is missing or wrong).
pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.pool(&id).await.map(|_| ())
db.pool(id).await.map(|_| ())
}
#[command(trust = trusted)]
pub async fn db_set_manual_commit(host: &Host, window: &str, id: String, manual: bool) -> IdeResult<()> {
// Switches a data source between auto-commit and manual commit (leaving
// manual mode rolls back what was not committed).
/// Switches a data source between auto-commit and manual commit (leaving
/// manual mode rolls back what was not committed).
pub async fn set_manual_commit(host: &Host, window: &str, id: &str, manual: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.set_manual_commit(&id, manual).await
db.set_manual_commit(id, manual).await
}
#[command(trust = trusted)]
pub async fn db_finish_transaction(host: &Host, window: &str, id: String, commit: bool) -> IdeResult<()> {
// Commits or rolls back the open transaction of a manual-commit data source.
/// Commits or rolls back the open transaction of a manual-commit data source.
pub async fn finish_transaction(host: &Host, window: &str, id: &str, commit: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.finish_transaction(&id, commit).await
db.finish_transaction(id, commit).await
}
#[command(trust = trusted)]
pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Closes the connection of data source `id`.
/// Closes the connection of data source `id`.
pub async fn disconnect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.disconnect(&id).await;
db.disconnect(id).await;
Ok(())
}
#[command(trust = trusted)]
pub async fn db_databases(host: &Host, window: &str, id: String) -> IdeResult<Databases> {
// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
/// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
pub async fn databases(host: &Host, window: &str, id: &str) -> IdeResult<Databases> {
let db = host.project(window)?.db.clone();
db.databases(&id).await
db.databases(id).await
}
#[command(trust = trusted)]
pub async fn db_database_catalog(
/// The schemas of `database` of Snowflake data source `id` with their tables and views.
pub async fn database_catalog(
host: &Host,
window: &str,
id: String,
database: String,
id: &str,
database: &str,
) -> IdeResult<Vec<ide_db::CatalogSchema>> {
// The schemas of `database` of Snowflake data source `id` with their tables and views.
let db = host.project(window)?.db.clone();
db.database_catalog(&id, &database).await
db.database_catalog(id, database).await
}
#[command(trust = trusted)]
pub async fn db_saved_catalog(host: &Host, window: &str, id: String) -> IdeResult<Option<ide_db::SourceCatalog>> {
// What earlier introspection of data source `id` saved; the data source is not connected to.
/// What earlier introspection of data source `id` saved; the data source is not connected to.
pub async fn saved_catalog(host: &Host, window: &str, id: &str) -> IdeResult<Option<ide_db::SourceCatalog>> {
let db = host.project(window)?.db.clone();
db.saved_catalog(&id).await
db.saved_catalog(id).await
}
#[command(trust = trusted)]
pub async fn db_retain_catalog(host: &Host, window: &str, id: String, databases: Vec<String>) -> IdeResult<()> {
// Drops the saved databases of data source `id` that are not in `databases` any more.
/// Drops the saved databases of data source `id` that are not in `databases` any more.
pub async fn retain_catalog(host: &Host, window: &str, id: &str, databases: Vec<String>) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.retain_catalog(&id, databases).await
db.retain_catalog(id, databases).await
}
#[command(trust = trusted)]
pub async fn db_session_context(host: &Host, window: &str, id: String) -> IdeResult<ide_db::SessionContext> {
// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
/// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
pub async fn session_context(host: &Host, window: &str, id: &str) -> IdeResult<ide_db::SessionContext> {
let db = host.project(window)?.db.clone();
db.session_context(&id).await
db.session_context(id).await
}
#[command(trust = trusted)]
pub async fn db_schemas(host: &Host, window: &str, id: String) -> IdeResult<Vec<String>> {
// The schemas of data source `id`.
/// The schemas of data source `id`.
pub async fn schemas(host: &Host, window: &str, id: &str) -> IdeResult<Vec<String>> {
let db = host.project(window)?.db.clone();
db.schemas(&id).await
db.schemas(id).await
}
#[command(trust = trusted)]
pub async fn db_tables(host: &Host, window: &str, id: String, schema: String) -> IdeResult<Vec<TableInfo>> {
// The tables and views of `schema`.
/// The tables and views of `schema`.
pub async fn tables(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<Vec<TableInfo>> {
let db = host.project(window)?.db.clone();
db.tables(&id, &schema).await
db.tables(id, schema).await
}
#[command(trust = trusted)]
pub async fn db_table_details(
/// Columns, keys and indexes of `table`.
pub async fn table_details(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<TableDetails> {
let db = host.project(window)?.db.clone();
db.table_details(id, schema, table).await
}
/// The DDL of table or view `table` (Go to DDL, Generate DDL).
pub async fn ddl(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<String> {
let db = host.project(window)?.db.clone();
db.ddl(id, schema, table).await
}
/// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
pub async fn schema_objects(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<SchemaObjects> {
let db = host.project(window)?.db.clone();
db.schema_objects(id, schema).await
}
/// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
pub async fn object_ddl(
host: &Host,
window: &str,
id: String,
schema: String,
table: String,
) -> IdeResult<TableDetails> {
// Columns, keys and indexes of `table`.
let db = host.project(window)?.db.clone();
db.table_details(&id, &schema, &table).await
}
#[command(trust = trusted)]
pub async fn db_ddl(host: &Host, window: &str, id: String, schema: String, table: String) -> IdeResult<String> {
// The DDL of table or view `table` (Go to DDL, Generate DDL).
let db = host.project(window)?.db.clone();
db.ddl(&id, &schema, &table).await
}
#[command(trust = trusted)]
pub async fn db_schema_objects(host: &Host, window: &str, id: String, schema: String) -> IdeResult<SchemaObjects> {
// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
let db = host.project(window)?.db.clone();
db.schema_objects(&id, &schema).await
}
#[command(trust = trusted)]
pub async fn db_object_ddl(
host: &Host,
window: &str,
id: String,
schema: String,
id: &str,
schema: &str,
kind: DbObjectKind,
name: String,
name: &str,
) -> IdeResult<String> {
// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
let db = host.project(window)?.db.clone();
db.object_ddl(&id, &schema, kind, &name).await
db.object_ddl(id, schema, kind, name).await
}
#[command(trust = trusted)]
pub async fn db_explain(
/// Explain Plan: the execution plan of `statement` on `id`, without running it.
pub async fn explain(
host: &Host,
window: &str,
request: RequestId,
id: String,
statement: String,
schema: Option<String>,
id: &str,
statement: &str,
schema: Option<&str>,
) -> IdeResult<Vec<PlanNode>> {
// Explain Plan: the execution plan of `statement` on `id`, without running it.
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db.explain(&id, &statement, &cancel, schema.as_deref()).await;
let result = db.explain(id, statement, &cancel, schema).await;
host.end_request(request);
result
}
#[command(trust = trusted)]
pub async fn db_history(host: &Host, window: &str, id: String) -> IdeResult<Vec<HistoryEntry>> {
// The statements data source `id` ran, newest first (Browse Query History).
/// The statements data source `id` ran, newest first (Browse Query History).
pub async fn history(host: &Host, window: &str, id: &str) -> IdeResult<Vec<HistoryEntry>> {
let db = host.project(window)?.db.clone();
db.history(&id).await
db.history(id).await
}
#[command(trust = trusted)]
pub async fn db_remove_history(host: &Host, window: &str, id: String, texts: Option<Vec<String>>) -> IdeResult<()> {
// Removes statements from the query history of `id` (`None`: all of them).
/// Removes statements from the query history of `id` (`None`: all of them).
pub async fn remove_history(host: &Host, window: &str, id: &str, texts: Option<Vec<String>>) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.remove_history(&id, texts).await
db.remove_history(id, texts).await
}
#[command(trust = trusted)]
pub async fn db_completion(host: &Host, window: &str, id: String) -> IdeResult<CompletionModel> {
// Tables, columns and foreign keys for SQL completion.
/// Tables, columns and foreign keys for SQL completion.
pub async fn completion(host: &Host, window: &str, id: &str) -> IdeResult<CompletionModel> {
let db = host.project(window)?.db.clone();
db.completion(&id).await
db.completion(id).await
}
#[command(trust = trusted)]
pub fn db_statements(
host: &Host,
window: &str,
id: String,
text: String,
from: u32,
to: u32,
) -> IdeResult<Vec<SqlStatement>> {
// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
let driver = host.project(window)?.db.source(&id)?.driver;
/// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
pub fn statements(host: &Host, window: &str, id: &str, text: &str, from: u32, to: u32) -> IdeResult<Vec<SqlStatement>> {
let driver = host.project(window)?.db.source(id)?.driver;
Ok(if from < to {
ide_db::split::statements_in(&text, from, to, driver)
ide_db::split::statements_in(text, from, to, driver)
} else {
ide_db::split::statement_at(&text, from, driver).into_iter().collect()
ide_db::split::statement_at(text, from, driver).into_iter().collect()
})
}
/// Runs `statements` in order on data source `id`, stopping at the first
/// error. Each result reads past its first `skip` rows (a later page) and keeps
/// `max_rows`. `schema` is the console's active context: the connection running
/// each statement is put in it first. Cancel with `cancel_request(request)`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn db_execute(
pub async fn execute(
host: &Host,
window: &str,
request: RequestId,
id: String,
id: &str,
statements: Vec<SqlStatement>,
// Clients before pagination send no `skip`.
#[default] skip: u32,
skip: u32,
max_rows: u32,
schema: Option<String>,
schema: Option<&str>,
) -> IdeResult<Vec<StatementOutcome>> {
// Runs `statements` in order on data source `id`, stopping at the first
// error. Each result reads past its first `skip` rows (a later page) and keeps
// `max_rows`. `schema` is the console's active context: the connection running
// each statement is put in it first. Cancel with `cancel_request(request)`.
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let mut out = Vec::new();
for statement in statements {
match db
.execute_from(&id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema.as_deref())
.await
{
match db.execute_from(id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema).await {
Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
host.end_request(request);
@@ -335,62 +435,57 @@ pub async fn db_execute(
Ok(out)
}
/// One page of the rows of `table` (the table editor).
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn db_table_page(
pub async fn table_page(
host: &Host,
window: &str,
request: RequestId,
id: String,
schema: String,
table: String,
id: &str,
schema: &str,
table: &str,
filter: Option<String>,
sort: Vec<SortKey>,
offset: u32,
limit: u32,
) -> IdeResult<TablePage> {
// One page of the rows of `table` (the table editor).
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db
.table_page(&id, &schema, &table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel)
.await;
let result =
db.table_page(id, schema, table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel).await;
host.end_request(request);
result
}
#[command(trust = trusted)]
pub async fn db_apply_edits(
/// Submits the table editor's changes in one transaction; returns the rows changed.
pub async fn apply_edits(
host: &Host,
window: &str,
id: String,
schema: String,
table: String,
id: &str,
schema: &str,
table: &str,
edits: Vec<DbRowEdit>,
) -> IdeResult<f64> {
// Submits the table editor's changes in one transaction; returns the rows changed.
let db = host.project(window)?.db.clone();
Ok(db.apply_edits(&id, &schema, &table, &edits).await? as f64)
Ok(db.apply_edits(id, schema, table, &edits).await? as f64)
}
#[command(trust = always)]
pub fn db_console_path(host: &Host, id: String) -> IdeResult<IpcPath> {
// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
// created on first use. Consoles are files of the project, so a remote
// window resolves it on the host the project runs on.
let file = console_dir(host, &id)?.join("console.sql");
/// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
/// created on first use. Consoles are files of the project, so a remote
/// window resolves it on the host the project runs on.
pub fn console_path(host: &Host, id: &str) -> IdeResult<IpcPath> {
let file = console_dir(host, id)?.join("console.sql");
if !file.exists() {
std::fs::write(&file, "")?;
}
Ok(file.into())
}
/// The query consoles of data source `id`; `create` adds the next one first.
#[command(trust = always)]
pub fn db_consoles(host: &Host, id: String, create: bool) -> IdeResult<Vec<IpcPath>> {
// The default `console.sql`, then `console_1.sql`, `console_2.sql`… in order
// (`create`: DataGrip's New › Query Console).
let dir = console_dir(host, &id)?;
/// The query consoles of data source `id`: the default `console.sql`, then
/// `console_1.sql`, `console_2.sql`… in order. `create` adds the next one first
/// (DataGrip's New › Query Console).
pub fn consoles(host: &Host, id: &str, create: bool) -> IdeResult<Vec<IpcPath>> {
let dir = console_dir(host, id)?;
let default = dir.join("console.sql");
let mut numbered: Vec<(u32, PathBuf)> = std::fs::read_dir(&dir)?
.filter_map(|e| {
@@ -469,40 +564,3 @@ pub fn tool_preview(
pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult<u32> {
host.project(window)?.db.server_version(id).await
}
ide_command::domain!(
db:
db_apply_edits,
db_completion,
db_connect,
db_connected,
db_console_path,
db_consoles,
db_database_catalog,
db_databases,
db_ddl,
db_disconnect,
db_execute,
db_explain,
db_finish_transaction,
db_history,
db_object_ddl,
db_remove_history,
db_retain_catalog,
db_save_sources,
db_saved_catalog,
db_schema_objects,
db_schemas,
db_session_context,
db_set_manual_commit,
db_set_password,
db_set_ssh_secret,
db_sources,
db_statements,
db_table_details,
db_table_page,
db_tables,
db_test,
db_test_tunnel,
db_trust_ssh_host,
);
+232 -126
Переглянути файл
@@ -4,13 +4,12 @@ mod kotlin_tests;
mod output;
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{DebugSessionId, IdeResult};
use ide_dap::*;
use std::path::PathBuf;
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
#[command(trust = trusted)]
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
host.require_trust(window)?;
let unity_pid = if config.adapter == "unity" {
@@ -273,38 +272,44 @@ fn match_java_debug_encoding(mut config: LaunchConfig, windows: bool) -> LaunchC
config
}
#[command(trust = trusted)]
pub async fn debug_set_breakpoints(
host: &Host,
_window: &str,
path: PathBuf,
breakpoints: Vec<Breakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_breakpoints(path, breakpoints).await
}
#[command(trust = trusted)]
pub async fn debug_threads(host: &Host, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
pub async fn debug_threads(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
host.debugger.threads(session).await
}
#[command(trust = trusted)]
pub async fn debug_stack_trace(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<Vec<StackFrame>> {
pub async fn debug_stack_trace(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
) -> IdeResult<Vec<StackFrame>> {
host.debugger.stack_trace(session, thread_id).await
}
#[command(trust = trusted)]
pub async fn debug_scopes(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
pub async fn debug_scopes(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
host.debugger.scopes(session, frame_id).await
}
#[command(trust = trusted)]
pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
pub async fn debug_variables(
host: &Host,
_window: &str,
session: DebugSessionId,
reference: i64,
) -> IdeResult<Vec<Variable>> {
host.debugger.variables(session, reference).await
}
#[command(trust = trusted)]
pub async fn debug_evaluate(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
expression: String,
@@ -312,38 +317,40 @@ pub async fn debug_evaluate(
host.debugger.evaluate(session, frame_id, expression).await
}
#[command(trust = trusted)]
pub async fn debug_resume(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
pub async fn debug_resume(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
host.debugger.resume(session, thread_id).await
}
#[command(trust = trusted)]
pub async fn debug_pause(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
pub async fn debug_pause(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
host.debugger.pause(session, thread_id).await
}
/// Types `text` into the session's program (a `runInTerminal` program).
#[command(trust = trusted)]
pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String) -> IdeResult<()> {
pub async fn debug_send_input(host: &Host, _window: &str, session: DebugSessionId, text: String) -> IdeResult<()> {
host.debugger.send_input(session, &text)
}
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_hot_reload(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_reload(session).await
}
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_hot_restart(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_restart(session).await
}
#[command(trust = trusted)]
pub async fn debug_step(host: &Host, session: DebugSessionId, thread_id: i64, kind: StepKind) -> IdeResult<()> {
pub async fn debug_step(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
kind: StepKind,
) -> IdeResult<()> {
host.debugger.step(session, thread_id, kind).await
}
#[command(trust = trusted)]
pub async fn debug_run_to(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
path: PathBuf,
@@ -353,15 +360,14 @@ pub async fn debug_run_to(
host.debugger.run_to(session, thread_id, path, line, force).await
}
#[command(trust = always)]
pub async fn debug_stop(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_stop(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.stop(session).await
}
/// Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16).
#[command(trust = trusted)]
/// The adapter's completions for an expression being typed in the frame `frame_id`.
pub async fn debug_completions(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
text: String,
@@ -372,9 +378,9 @@ pub async fn debug_completions(
}
/// Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`.
#[command(trust = trusted)]
pub async fn debug_evaluate_in(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
expression: String,
@@ -384,34 +390,31 @@ pub async fn debug_evaluate_in(
}
/// Last known verification states of a file's breakpoints (refetch on `breakpointsChanged`).
#[command(trust = trusted)]
pub fn debug_breakpoint_states(host: &Host, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
pub fn debug_breakpoint_states(host: &Host, _window: &str, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
Ok(host.debugger.breakpoint_states(&path))
}
/// This window's live sessions, including adapter-started child sessions.
#[command(trust = always)]
pub fn debug_sessions(host: &Host, window: &str) -> IdeResult<Vec<SessionInfo>> {
Ok(host.debugger.sessions(Some(host.owner_window(window))))
}
#[command(trust = trusted)]
pub fn debug_exception_filters(host: &Host, window: &str) -> IdeResult<Vec<SessionExceptionFilters>> {
Ok(host.debugger.exception_filters(Some(host.owner_window(window))))
}
#[command(trust = trusted)]
pub async fn debug_set_exception_breakpoints(
host: &Host,
_window: &str,
choices: std::collections::BTreeMap<String, bool>,
) -> IdeResult<()> {
host.debugger.set_exception_breakpoints(choices).await
}
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn debug_set_variable(
host: &Host,
_window: &str,
session: DebugSessionId,
container: i64,
name: String,
@@ -423,24 +426,28 @@ pub async fn debug_set_variable(
}
/// Force Step Over: step over with every breakpoint suspended until the step ends.
#[command(trust = trusted)]
pub async fn debug_force_step_over(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
pub async fn debug_force_step_over(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
) -> IdeResult<()> {
host.debugger.force_step_over(session, thread_id).await
}
/// Smart Step Into: the calls on the current line of `frame_id`.
#[command(trust = trusted)]
pub async fn debug_step_in_targets(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: i64,
) -> IdeResult<Vec<StepInTarget>> {
host.debugger.step_in_targets(session, frame_id).await
}
#[command(trust = trusted)]
pub async fn debug_step_in_target(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
target_id: i64,
@@ -449,15 +456,13 @@ pub async fn debug_step_in_target(
}
/// Reset Frame (Drop Frame).
#[command(trust = trusted)]
pub async fn debug_restart_frame(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
pub async fn debug_restart_frame(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
host.debugger.restart_frame(session, frame_id).await
}
/// Breakpoints of a debugged page on DOM events and on requests (js-debug).
#[command(trust = trusted)]
pub async fn debug_js_custom_breakpoints(
host: &Host,
_window: &str,
session: DebugSessionId,
ids: Vec<String>,
xhr: Vec<String>,
@@ -465,65 +470,61 @@ pub async fn debug_js_custom_breakpoints(
host.debugger.js_set_custom_breakpoints(session, ids, xhr).await
}
/// The responses a debugged page gets in place of the server's, by a part of the URL; none
/// switches the replacing off.
#[command(trust = trusted)]
pub async fn debug_js_response_overrides(
host: &Host,
_window: &str,
session: DebugSessionId,
rules: Vec<ide_dap::JsResponseRule>,
) -> IdeResult<()> {
host.debugger.js_set_response_overrides(session, rules).await
}
/// The body of a response a debugged page received.
#[command(trust = trusted)]
pub async fn debug_js_response_body(
host: &Host,
_window: &str,
session: DebugSessionId,
request_id: String,
) -> IdeResult<ide_dap::JsResponseBody> {
host.debugger.js_response_body(session, request_id).await
}
/// Starts recording a debugged page's CPU profile.
#[command(trust = trusted)]
pub async fn debug_js_start_profile(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_js_start_profile(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.js_start_profile(session).await
}
/// Ends the recording: a directory holding the profile as `page.cpuprofile`.
#[command(trust = trusted)]
pub async fn debug_js_stop_profile(host: &Host, session: DebugSessionId) -> IdeResult<ide_core::IpcPath> {
pub async fn debug_js_stop_profile(
host: &Host,
_window: &str,
session: DebugSessionId,
) -> IdeResult<ide_core::IpcPath> {
host.debugger.js_stop_profile(session).await.map(Into::into)
}
#[command(trust = trusted)]
pub fn debug_capabilities(host: &Host, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
pub fn debug_capabilities(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
host.debugger.capabilities(session)
}
/// Method breakpoints (all files); states aligned with `breakpoints`.
#[command(trust = trusted)]
pub async fn debug_set_function_breakpoints(
host: &Host,
_window: &str,
breakpoints: Vec<FunctionBreakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_function_breakpoints(breakpoints).await
}
/// Field watchpoints; states aligned with `breakpoints`.
#[command(trust = trusted)]
pub async fn debug_set_data_breakpoints(
host: &Host,
_window: &str,
breakpoints: Vec<DataBreakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_data_breakpoints(breakpoints).await
}
#[command(trust = trusted)]
pub async fn debug_data_breakpoint_info(
host: &Host,
_window: &str,
session: DebugSessionId,
container: i64,
name: String,
@@ -533,23 +534,20 @@ pub async fn debug_data_breakpoint_info(
}
/// Attach to Process: the user's processes a debugger can attach to.
#[command(trust = always)]
pub async fn debug_attachable_processes() -> IdeResult<Vec<attach::AttachableProcess>> {
pub async fn debug_attachable_processes(_host: &Host, _window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
tokio::task::spawn_blocking(attach::attachable_processes)
.await
.map_err(|e| ide_core::IdeError::internal(format!("listing processes failed: {e}")))?
}
/// A loopback port that is free right now, for a debug agent the launch line starts.
#[command(trust = trusted)]
/// A loopback port that is free right now, for a debug agent the launch line starts
/// (`address=127.0.0.1:<port>`) — used when its "Listening for transport" line never reaches
/// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
// `address=127.0.0.1:<port>` — used when its "Listening for transport" line never reaches
// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
host.require_trust(window)?;
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
}
#[command(trust = trusted)]
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -563,29 +561,26 @@ pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<a
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
#[command(trust = trusted)]
pub async fn debug_listen_for_jvm(
ide: &Host,
host: &Host,
window: &str,
request: ide_core::RequestId,
host: String,
jvm_host: String,
port: u16,
) -> IdeResult<u16> {
ide.require_trust(window)?;
let token = ide.begin_request(request);
let result = jdwp::listen_for_jvm(&host, port, token).await;
ide.end_request(request);
host.require_trust(window)?;
let token = host.begin_request(request);
let result = jdwp::listen_for_jvm(&jvm_host, port, token).await;
host.end_request(request);
result
}
/// HotSwap (Reload Changed Classes) in a java-debug session.
#[command(trust = trusted)]
pub async fn debug_redefine_classes(host: &Host, session: DebugSessionId) -> IdeResult<HotSwapResult> {
pub async fn debug_redefine_classes(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<HotSwapResult> {
host.debugger.redefine_classes(session).await
}
/// The debuggee JVM's loaded classes (instances and shallow bytes), or why they cannot be read.
#[command(trust = trusted)]
/// The debuggee JVM's loaded classes, or why they cannot be read.
pub async fn debug_jvm_memory_classes(
host: &Host,
window: &str,
@@ -596,7 +591,6 @@ pub async fn debug_jvm_memory_classes(
}
/// Up to `limit` live instances of the class in the stopped JVM.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_instances(
host: &Host,
window: &str,
@@ -608,8 +602,7 @@ pub async fn debug_jvm_memory_instances(
host.debugger.jvm_memory_instances(session, class_name, limit).await
}
/// The fields (or array elements) of an instance in the stopped JVM.
#[command(trust = trusted)]
/// The fields (or array elements) of an instance listed by [`debug_jvm_memory_instances`].
pub async fn debug_jvm_memory_fields(
host: &Host,
window: &str,
@@ -621,7 +614,6 @@ pub async fn debug_jvm_memory_fields(
}
/// The objects that hold a reference to `object`; `limit` 0 selects the default.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_referrers(
host: &Host,
window: &str,
@@ -633,6 +625,166 @@ pub async fn debug_jvm_memory_referrers(
host.debugger.jvm_memory_referrers(session, object, limit).await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_start", |c| async move { debug_start(&c.host, &c.window, c.arg("config")?).await });
d.add("debug_set_breakpoints", |c| async move {
debug_set_breakpoints(&c.host, &c.window, c.arg("path")?, c.arg("breakpoints")?).await
});
d.add("debug_threads", |c| async move { debug_threads(&c.host, &c.window, c.arg("session")?).await });
d.add("debug_stack_trace", |c| async move {
debug_stack_trace(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
});
d.add(
"debug_scopes",
|c| async move { debug_scopes(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await },
);
d.add("debug_variables", |c| async move {
debug_variables(&c.host, &c.window, c.arg("session")?, c.arg("reference")?).await
});
d.add("debug_evaluate", |c| async move {
debug_evaluate(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?, c.arg("expression")?).await
});
d.add(
"debug_resume",
|c| async move { debug_resume(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
);
d.add(
"debug_pause",
|c| async move { debug_pause(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
);
d.add("debug_send_input", |c| async move {
debug_send_input(&c.host, &c.window, c.arg("session")?, c.arg("text")?).await
});
d.add("debug_step", |c| async move {
debug_step(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("kind")?).await
});
d.add("debug_run_to", |c| async move {
debug_run_to(
&c.host,
&c.window,
c.arg("session")?,
c.arg("threadId")?,
c.arg("path")?,
c.arg("line")?,
c.arg("force")?,
)
.await
});
d.add("debug_stop", |c| async move { debug_stop(&c.host, &c.window, c.arg("session")?).await });
d.add("debug_completions", |c| async move {
debug_completions(
&c.host,
&c.window,
c.arg("session")?,
c.arg("frameId")?,
c.arg("text")?,
c.arg("line")?,
c.arg("column")?,
)
.await
});
d.add("debug_evaluate_in", |c| async move {
debug_evaluate_in(
&c.host,
&c.window,
c.arg("session")?,
c.arg("frameId")?,
c.arg("expression")?,
c.arg("context")?,
)
.await
});
d.add("debug_breakpoint_states", |c| async move { debug_breakpoint_states(&c.host, &c.window, c.arg("path")?) });
d.add("debug_sessions", |c| async move { debug_sessions(&c.host, &c.window) });
d.add("debug_exception_filters", |c| async move { debug_exception_filters(&c.host, &c.window) });
d.add("debug_set_exception_breakpoints", |c| async move {
debug_set_exception_breakpoints(&c.host, &c.window, c.arg("choices")?).await
});
d.add("debug_set_variable", |c| async move {
debug_set_variable(
&c.host,
&c.window,
c.arg("session")?,
c.arg("container")?,
c.arg("name")?,
c.arg("evaluateName")?,
c.arg("frameId")?,
c.arg("value")?,
)
.await
});
d.add("debug_force_step_over", |c| async move {
debug_force_step_over(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
});
d.add("debug_step_in_targets", |c| async move {
debug_step_in_targets(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
});
d.add("debug_step_in_target", |c| async move {
debug_step_in_target(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("targetId")?).await
});
d.add("debug_restart_frame", |c| async move {
debug_restart_frame(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
});
d.add("debug_capabilities", |c| async move { debug_capabilities(&c.host, &c.window, c.arg("session")?) });
d.add("debug_js_response_overrides", |c| async move {
debug_js_response_overrides(&c.host, &c.window, c.arg("session")?, c.arg("rules")?).await
});
d.add("debug_js_response_body", |c| async move {
debug_js_response_body(&c.host, &c.window, c.arg("session")?, c.arg("requestId")?).await
});
d.add("debug_js_custom_breakpoints", |c| async move {
debug_js_custom_breakpoints(&c.host, &c.window, c.arg("session")?, c.arg("ids")?, c.arg("xhr")?).await
});
d.add(
"debug_js_start_profile",
|c| async move { debug_js_start_profile(&c.host, &c.window, c.arg("session")?).await },
);
d.add(
"debug_js_stop_profile",
|c| async move { debug_js_stop_profile(&c.host, &c.window, c.arg("session")?).await },
);
d.add("debug_set_function_breakpoints", |c| async move {
debug_set_function_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
});
d.add("debug_set_data_breakpoints", |c| async move {
debug_set_data_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
});
d.add("debug_data_breakpoint_info", |c| async move {
debug_data_breakpoint_info(
&c.host,
&c.window,
c.arg("session")?,
c.arg("container")?,
c.arg("name")?,
c.arg("frameId")?,
)
.await
});
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
d.add("debug_listen_for_jvm", |c| async move {
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
});
d.add(
"debug_redefine_classes",
|c| async move { debug_redefine_classes(&c.host, &c.window, c.arg("session")?).await },
);
d.add("debug_jvm_memory_classes", |c| async move {
debug_jvm_memory_classes(&c.host, &c.window, c.arg("session")?).await
});
d.add("debug_jvm_memory_instances", |c| async move {
debug_jvm_memory_instances(&c.host, &c.window, c.arg("session")?, c.arg("className")?, c.arg("limit")?).await
});
d.add("debug_jvm_memory_fields", |c| async move {
debug_jvm_memory_fields(&c.host, &c.window, c.arg("session")?, c.arg("object")?).await
});
d.add("debug_jvm_memory_referrers", |c| async move {
debug_jvm_memory_referrers(&c.host, &c.window, c.arg("session")?, c.arg("object")?, c.arg("limit")?).await
});
}
#[cfg(test)]
mod tests {
use super::*;
@@ -766,49 +918,3 @@ mod tests {
}
}
}
ide_command::domain!(
debug:
debug_attachable_processes,
debug_breakpoint_states,
debug_capabilities,
debug_completions,
debug_data_breakpoint_info,
debug_evaluate,
debug_evaluate_in,
debug_exception_filters,
debug_force_step_over,
debug_free_port,
debug_js_custom_breakpoints,
debug_js_response_body,
debug_js_response_overrides,
debug_js_start_profile,
debug_js_stop_profile,
debug_jvm_memory_classes,
debug_jvm_memory_fields,
debug_jvm_memory_instances,
debug_jvm_memory_referrers,
debug_listen_for_jvm,
debug_pause,
debug_redefine_classes,
debug_restart_frame,
debug_resume,
debug_run_to,
debug_scopes,
debug_send_input,
debug_sessions,
debug_set_breakpoints,
debug_set_data_breakpoints,
debug_set_exception_breakpoints,
debug_set_function_breakpoints,
debug_set_variable,
debug_stack_trace,
debug_start,
debug_step,
debug_step_in_target,
debug_step_in_targets,
debug_stop,
debug_threads,
debug_unity_processes,
debug_variables,
);
+8 -6
Переглянути файл
@@ -1,6 +1,5 @@
//! Repository version lookups for manifest inspections and completion.
use crate::Host;
use ide_command::command;
use crate::{Host, rpc::Dispatcher};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo, go, maven, npm};
use std::collections::BTreeMap;
@@ -194,7 +193,7 @@ fn go_source(project: &crate::Project, config_dir: &Path, path: &Path) -> IdeRes
Ok(GoModules { root, env })
}
#[command(trust = trusted)]
/// `offset` limits a completion request to its version string; inspections omit it.
pub async fn dependency_versions(
host: &Host,
window: &str,
@@ -202,7 +201,6 @@ pub async fn dependency_versions(
offset: Option<u32>,
request: RequestId,
) -> IdeResult<Vec<DependencyVersions>> {
// `offset` limits a completion request to its version string; inspections omit it.
let project = host.project(window)?;
let cache = host.dependency_versions.clone();
let config_dir = host.config_dir.clone();
@@ -251,6 +249,12 @@ pub async fn dependency_versions(
result
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add("dependency_versions", |c| async move {
dependency_versions(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
});
}
#[cfg(test)]
mod tests {
use super::*;
@@ -357,5 +361,3 @@ mod tests {
host.close_project("main");
}
}
ide_command::domain!(dependencies: dependency_versions);
+108 -101
Переглянути файл
@@ -1,5 +1,4 @@
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
use ide_remote::{DeployedPath, DeploymentCoverage, DeploymentRoot, SyncEntry, SyncStep, TransferReport};
use ide_ssh::{FsConnection, RemoteEntry};
@@ -32,204 +31,212 @@ fn local(paths: Vec<IpcPath>) -> Vec<PathBuf> {
paths.into_iter().map(|p| p.to_path_buf()).collect()
}
#[command(trust = always)]
pub async fn deploy_coverage(window: &str, host: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
// Eligible paths per server, without contacting any deployment host.
let project = host.project(window)?;
/// Eligible paths per server, without contacting any deployment host.
pub async fn deploy_coverage(window: &str, state: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
let project = state.project(window)?;
Ok(ide_remote::coverage(&project.settings.effective(), &project.root, &local(paths)))
}
#[command(trust = trusted)]
/// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
pub async fn deploy_upload(
window: &str,
host: &Host,
state: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Uploading", token.clone());
let r = host
let r = state
.remote
.upload(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
.await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Download from…: the remote counterparts of files and folders.
pub async fn deploy_download(
window: &str,
host: &Host,
state: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
// Download from…: the remote counterparts of files and folders.
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
let r = host
let r = state
.remote
.download(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
.await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Deletes the remote counterparts of files and folders.
pub async fn deploy_delete_remote(
window: &str,
host: &Host,
state: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
) -> IdeResult<TransferReport> {
// Deletes the remote counterparts of files and folders.
let project = host.project(window)?;
host.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
let project = state.project(window)?;
state.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
}
#[command(trust = trusted)]
/// Sync with Deployed: local and remote files under `path`, side by side.
pub async fn deploy_compare(
window: &str,
host: &Host,
state: &Host,
path: IpcPath,
server: Option<String>,
request: RequestId,
) -> IdeResult<Vec<SyncEntry>> {
// Sync with Deployed: local and remote files under `path`, side by side.
let project = host.project(window)?;
let token = host.begin_request(request);
let r = host.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
host.end_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let r = state.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Applies the Sync with Deployed choices.
pub async fn deploy_sync(
window: &str,
host: &Host,
state: &Host,
steps: Vec<SyncStep>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
// Applies the Sync with Deployed choices.
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Synchronizing", token.clone());
let r = host
let r = state
.remote
.sync(&project.settings.effective(), &project.root, server.as_deref(), &steps, token, &mut report)
.await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Where `path` is deployed (remote path, web URL); `None` when not mapped.
pub async fn deploy_info(
window: &str,
host: &Host,
state: &Host,
path: IpcPath,
server: Option<String>,
) -> IdeResult<Option<DeployedPath>> {
// Where `path` is deployed (remote path, web URL); `None` when not mapped.
let project = host.project(window)?;
host.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
let project = state.project(window)?;
state.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
}
#[command(trust = trusted)]
pub async fn deploy_server_root(window: &str, host: &Host, server: String) -> IdeResult<DeploymentRoot> {
// Remote Host tool window: the resolved server root and project mappings.
let project = host.project(window).ok();
let settings = project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| host.global_settings.effective());
host.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
/// Remote Host tool window: the resolved server root and project mappings.
pub async fn deploy_server_root(window: &str, state: &Host, server: String) -> IdeResult<DeploymentRoot> {
let project = state.project(window).ok();
let settings =
project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| state.global_settings.effective());
state.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
}
#[command(trust = always)]
pub async fn remote_list(host: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
// Entries of a folder on the selected filesystem (`~`: its home directory).
host.remote.list(&connection, &path).await
/// Entries of a folder on the selected filesystem (`~`: its home directory).
pub async fn remote_list(state: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
state.remote.list(&connection, &path).await
}
#[command(trust = always)]
pub async fn remote_open(host: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
// Opens a remote file for editing: a local copy, uploaded back on save.
Ok(host.remote.open_remote(&connection, &path).await?.into())
/// Opens a remote file for editing: a local copy, uploaded back on save.
pub async fn remote_open(state: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
Ok(state.remote.open_remote(&connection, &path).await?.into())
}
#[command(trust = always)]
pub fn remote_of(host: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
// The filesystem connection and path a cached editing copy stands for.
host.remote.remote_of(&path)
/// The filesystem connection and path a cached editing copy stands for.
pub fn remote_of(state: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
state.remote.remote_of(&path)
}
#[command(trust = trusted)]
pub async fn remote_delete(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
host.remote.remote_delete(&connection, &path).await
pub async fn remote_delete(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
state.remote.remote_delete(&connection, &path).await
}
#[command(trust = trusted)]
pub async fn remote_mkdir(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
host.remote.remote_mkdir(&connection, &path).await
pub async fn remote_mkdir(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
state.remote.remote_mkdir(&connection, &path).await
}
#[command(trust = trusted)]
pub async fn remote_rename(host: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
host.remote.remote_rename(&connection, &from, &to).await
pub async fn remote_rename(state: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
state.remote.remote_rename(&connection, &from, &to).await
}
#[command(trust = trusted)]
/// Remote Host › Download to…: remote files and folders into a local folder, each under its
/// own name.
pub async fn remote_download_into(
window: &str,
host: &Host,
state: &Host,
connection: FsConnection,
paths: Vec<String>,
target: IpcPath,
request: RequestId,
) -> IdeResult<TransferReport> {
// Remote Host › Download to…: remote files and folders into a local folder, each under its
// own name.
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
let r = host.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
let r = state.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = always)]
/// `password`: an FTP password typed in the settings but not applied yet.
pub async fn deploy_test_connection(
host: &Host,
state: &Host,
connection: FsConnection,
path: String,
password: Option<String>,
) -> IdeResult<()> {
// `password`: an FTP password typed in the settings but not applied yet.
host.remote.test_connection_with(&connection, &path, password).await
state.remote.test_connection_with(&connection, &path, password).await
}
ide_command::domain!(
deploy:
deploy_compare,
deploy_coverage,
deploy_delete_remote,
deploy_download,
deploy_info,
deploy_server_root,
deploy_sync,
deploy_test_connection,
deploy_upload,
remote_delete,
remote_download_into,
remote_list,
remote_mkdir,
remote_of,
remote_open,
remote_rename,
);
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
d.add("deploy_coverage", |c| async move { deploy_coverage(&c.window, &c.host, c.arg("paths")?).await });
d.add("deploy_upload", |c| async move {
deploy_upload(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_download", |c| async move {
deploy_download(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_delete_remote", |c| async move {
deploy_delete_remote(&c.window, &c.host, c.arg("paths")?, c.arg("server")?).await
});
d.add("deploy_compare", |c| async move {
deploy_compare(&c.window, &c.host, c.arg("path")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_sync", |c| async move {
deploy_sync(&c.window, &c.host, c.arg("steps")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_info", |c| async move { deploy_info(&c.window, &c.host, c.arg("path")?, c.arg("server")?).await });
d.add("deploy_server_root", |c| async move { deploy_server_root(&c.window, &c.host, c.arg("server")?).await });
d.add("remote_list", |c| async move { remote_list(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_open", |c| async move { remote_open(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_of", |c| async move { Ok(remote_of(&c.host, c.arg("path")?)) });
d.add("remote_delete", |c| async move { remote_delete(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_mkdir", |c| async move { remote_mkdir(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_download_into", |c| async move {
remote_download_into(
&c.window,
&c.host,
c.arg("connection")?,
c.arg("paths")?,
c.arg("target")?,
c.arg("request")?,
)
.await
});
d.add("remote_rename", |c| async move {
remote_rename(&c.host, c.arg("connection")?, c.arg("from")?, c.arg("to")?).await
});
d.add("deploy_test_connection", |c| async move {
deploy_test_connection(&c.host, c.arg("connection")?, c.arg("path")?, c.arg("password")?).await
});
}
+19 -51
Переглянути файл
@@ -1,13 +1,9 @@
use crate::Host;
use ide_command::command;
use ide_core::{ChangeSet, DocId, IdeResult};
use ide_workspace::DocumentInfo;
use std::path::PathBuf;
/// Opens a document. Async: reading and decoding a large file must not block
/// the main thread (synchronous commands run on it).
#[command(trust = always)]
pub async fn doc_open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || {
let info = project.documents.open(&path)?;
@@ -20,30 +16,22 @@ pub async fn doc_open(host: &Host, window: &str, path: PathBuf) -> IdeResult<Doc
.await
}
#[command(trust = always)]
pub async fn doc_close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || {
project.documents.close(doc);
Ok(())
})
.await
pub fn close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
host.project(window)?.documents.close(doc);
Ok(())
}
/// Opens an editable untitled buffer (a new-file tab); it reaches the disk
/// through `doc_save_as`, which turns it into a regular file document.
#[command(trust = always)]
pub async fn doc_open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
// `name` re-references an already minted buffer instead of creating one.
/// through [`save_as`], which turns it into a regular file document. `name`
/// re-references an already minted buffer instead of creating one.
pub async fn open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || project.documents.open_untitled(name.as_deref())).await
}
/// Save As for an untitled buffer: writes it to `path` and re-keys the buffer
/// (undo history and version are kept; the language is re-detected).
#[command(trust = always)]
pub async fn doc_save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
// LightEdit windows start watching the saved file's folder.
/// Save As for an untitled buffer ([`Documents::save_as`]); LightEdit windows
/// start watching the saved file's folder.
pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || {
let info = project.documents.save_as(doc, &path)?;
@@ -55,31 +43,25 @@ pub async fn doc_save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -
.await
}
/// Applies a CodeMirror change set; returns the new version. Rejects with
/// `outOfSync` when `base_version` is stale; the UI then calls `doc_snapshot`.
#[command(trust = always, desktop_body = async)]
pub async fn doc_edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
let project = host.project(window)?;
blocking(move || project.documents.edit(doc, base_version, changes)).await
/// Applies a CodeMirror change set; returns the new version (`outOfSync` when `base_version` is stale).
pub fn edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
host.project(window)?.documents.edit(doc, base_version, changes)
}
#[command(trust = always)]
pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
pub async fn save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.save(doc)).await?;
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
#[command(trust = always)]
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
pub async fn save_all(host: &Host, window: &str) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.save_all()).await?;
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
#[command(trust = always)]
pub async fn doc_sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
// Recovers external changes missed by the project's file watchers.
/// Recovers external changes missed by the project's file watchers.
pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || {
if project.settings.effective().files.sync_on_focus {
@@ -90,27 +72,13 @@ pub async fn doc_sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
.await
}
#[command(trust = always)]
pub async fn doc_snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
pub async fn snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || project.documents.snapshot(doc)).await
}
pub mod commands;
mod commands;
pub use commands::*;
#[cfg(test)]
mod tests;
ide_command::domain!(
doc:
doc_close,
doc_edit,
doc_open,
doc_open_untitled,
doc_save,
doc_save_all,
doc_save_as,
doc_snapshot,
doc_sync_from_disk,
);
+38 -42
Переглянути файл
@@ -1,5 +1,7 @@
#[allow(unused_imports)]
use super::*;
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
use ide_language::{FoldRange, SyntaxHighlights};
use ide_text::LineEnding;
@@ -14,7 +16,6 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
/// Opens a read-only virtual document (see `lsp_virtual_document`) as an
/// editor buffer, so syntax features and language-server requests work in it.
#[command(trust = always)]
pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
let vd = crate::ops::lsp::lsp_virtual_document(host, window, uri).await?;
@@ -34,7 +35,6 @@ pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResu
/// The language and CodeMirror mode `path` is shown with in an editor, without opening
/// it: previews of closed files and diffs. `first_line` is the shown text's (a revision's)
/// for hashbang detection; without it the file's on disk counts.
#[command(trust = always)]
pub async fn doc_language(
host: &Host,
window: &str,
@@ -46,7 +46,8 @@ pub async fn doc_language(
}
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
#[command(trust = always)]
/// Virtual documents re-read their origin (archive, language server, Git blob)
/// instead of a disk file; converting them would write to it, so it stays refused.
pub async fn doc_set_encoding(
host: &Host,
window: &str,
@@ -54,8 +55,6 @@ pub async fn doc_set_encoding(
encoding: String,
reload: bool,
) -> IdeResult<DocumentEncoding> {
// Virtual documents re-read their origin (archive, language server, Git blob)
// instead of a disk file; converting them would write to it, so it stays refused.
let project = host.project(window)?;
if reload
&& !project.documents.is_untitled(doc)?
@@ -71,24 +70,20 @@ pub async fn doc_set_encoding(
host.blocking(move || project.documents.set_encoding(doc, &encoding, reload)).await
}
#[command(trust = always)]
/// Adds or removes the BOM on a UTF-8 document; the change is written on save.
pub async fn doc_set_bom(host: &Host, window: &str, doc: DocId, has_bom: bool) -> IdeResult<DocumentEncoding> {
// Adds or removes the BOM on a UTF-8 document; the change is written on save.
let project = host.project(window)?;
host.blocking(move || project.documents.set_bom(doc, has_bom)).await
}
#[command(trust = always)]
pub async fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_ending: LineEnding) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || project.documents.set_line_ending(doc, line_ending)).await
pub fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_ending: LineEnding) -> IdeResult<()> {
host.project(window)?.documents.set_line_ending(doc, line_ending)
}
/// Structure view: LSP document symbols when available (with tree-sitter
/// visibility), tree-sitter otherwise.
/// Tree-sitter answers come from the per-document tree cache (incremental
/// re-parse); large documents get no syntax structure.
#[command(trust = always)]
pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<OutlineItem>> {
let project = host.project(window)?;
let lsp = project.lsp.document_symbols(doc).await.ok().flatten();
@@ -127,7 +122,6 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
.await
}
#[command(trust = always)]
pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FoldRange>> {
let project = host.project(window)?;
blocking(move || {
@@ -162,7 +156,6 @@ pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
/// Tree-sitter highlighting for languages the UI has no CodeMirror mode for;
/// empty when the grammar has no highlights query or the document is large.
#[command(trust = always)]
pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<SyntaxHighlights> {
let project = host.project(window)?;
blocking(move || {
@@ -175,10 +168,9 @@ pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<
.await
}
/// Python class facts for the inheritance inspections: tree-sitter, no language server.
#[command(trust = always)]
/// Python class facts the inheritance inspections read: base names as written, a method's
/// parameters, decorator semantics and its body shape. Tree-sitter answers; no LSP.
pub async fn doc_python_facts(host: &Host, window: &str, doc: DocId) -> IdeResult<ide_language::PythonFacts> {
// Base names as written, a method's parameters, decorator semantics and its body shape.
let project = host.project(window)?;
let syntax = host.syntax();
let snap = project.documents.text_snapshot(doc)?;
@@ -187,7 +179,6 @@ pub async fn doc_python_facts(host: &Host, window: &str, doc: DocId) -> IdeResul
/// Extend Selection (⌥↑): syntax ranges around `offset`, innermost first.
/// Large documents fall back to word / line / document ranges.
#[command(trust = always)]
pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset: u32) -> IdeResult<Vec<Range>> {
let project = host.project(window)?;
blocking(move || {
@@ -213,30 +204,35 @@ pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset:
.await
}
#[command(trust = always)]
pub async fn history_list(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<HistoryEntry>> {
let project = host.project(window)?;
blocking(move || project.history.list(&path)).await
pub fn history_list(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<HistoryEntry>> {
host.project(window)?.history.list(&path)
}
#[command(trust = always)]
pub async fn history_content(host: &Host, window: &str, id: String) -> IdeResult<String> {
let project = host.project(window)?;
blocking(move || project.history.content(&id)).await
pub fn history_content(host: &Host, window: &str, id: String) -> IdeResult<String> {
host.project(window)?.history.content(&id)
}
ide_command::domain!(
doc_commands:
doc_folding,
doc_highlights,
doc_language,
doc_open_virtual,
doc_outline,
doc_python_facts,
doc_selection_ranges,
doc_set_bom,
doc_set_encoding,
doc_set_line_ending,
history_content,
history_list,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("doc_open_virtual", |c| async move { doc_open_virtual(&c.host, &c.window, c.arg("uri")?).await });
d.add(
"doc_language",
|c| async move { doc_language(&c.host, &c.window, c.arg("path")?, c.arg("firstLine")?).await },
);
d.add("doc_set_encoding", |c| async move {
doc_set_encoding(&c.host, &c.window, c.arg("doc")?, c.arg("encoding")?, c.arg("reload")?).await
});
d.add("doc_set_bom", |c| async move { doc_set_bom(&c.host, &c.window, c.arg("doc")?, c.arg("hasBom")?).await });
d.add("doc_set_line_ending", |c| async move {
blocking(move || doc_set_line_ending(&c.host, &c.window, c.arg("doc")?, c.arg("lineEnding")?)).await
});
d.add("doc_outline", |c| async move { doc_outline(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_folding", |c| async move { doc_folding(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_highlights", |c| async move { doc_highlights(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_python_facts", |c| async move { doc_python_facts(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_selection_ranges", |c| async move {
doc_selection_ranges(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?).await
});
d.add("history_list", |c| async move { history_list(&c.host, &c.window, c.arg("path")?) });
d.add("history_content", |c| async move { history_content(&c.host, &c.window, c.arg("id")?) });
}
+4 -5
Переглянути файл
@@ -46,11 +46,11 @@ impl Fixture {
}
async fn open(&self, path: &Path) -> DocumentInfo {
doc_open(&self.host, "main", path.to_path_buf()).await.unwrap()
open(&self.host, "main", path.to_path_buf()).await.unwrap()
}
async fn sync(&self) {
doc_sync_from_disk(&self.host, "main").await.unwrap();
sync_from_disk(&self.host, "main").await.unwrap();
}
fn document_events(&self) -> Vec<IdeEvent> {
@@ -95,14 +95,13 @@ async fn unchanged_document_has_no_patch_or_event() {
async fn dirty_document_keeps_edits_and_warns_once() {
let f = Fixture::new();
let original = f.open(&f.path).await;
doc_edit(
edit(
&f.host,
"main",
original.id,
original.version,
ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: "local ".into() }] },
)
.await
.unwrap();
f.events.lock().clear();
std::fs::write(&f.path, "external replacement\n").unwrap();
@@ -197,7 +196,7 @@ async fn synchronization_only_changes_the_calling_windows_documents() {
let other_root = f.outside.parent().unwrap().join("other-project");
std::fs::create_dir(&other_root).unwrap();
let other = f.host.open_project("other", &other_root).unwrap();
let other_doc = doc_open(&f.host, "other", f.outside.clone()).await.unwrap();
let other_doc = open(&f.host, "other", f.outside.clone()).await.unwrap();
std::fs::write(&f.outside, "external change in shared file\n").unwrap();
f.sync().await;
assert_eq!(f.project.documents.snapshot(original.id).unwrap().text, "external change in shared file\n");
+10 -49
Переглянути файл
@@ -1,56 +1,17 @@
//! Docker run configurations: the environment their `docker` command line runs with; and Docker
//! connections through an SSH configuration, tunnelled with the IDE's own SSH client.
//! Docker run configurations: the environment their `docker` command line runs with.
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult};
use crate::rpc::Dispatcher;
use ide_core::IdeResult;
use ide_docker::DockerEndpoint;
use ide_ssh::Tunnel;
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
use std::collections::BTreeMap;
/// What each tunnelled connection runs on the SSH host, as the Docker CLI's `ssh://` does.
const DIAL: &str = "docker system dial-stdio";
/// Open tunnels of [`DockerEndpoint::Ssh`] connections, by SSH configuration id.
#[derive(Default)]
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Arc<Tunnel>>>);
/// `endpoint` as docker can use it: an SSH configuration becomes the local end of a tunnel to its
/// host's daemon (opened on first use, reopened when the SSH connection dropped).
pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerEndpoint> {
let DockerEndpoint::Ssh { config } = endpoint else { return Ok(endpoint) };
let id = config.trim().to_owned();
let mut tunnels = host.docker_tunnels.0.lock().await;
let tunnel = match tunnels.get(&id).filter(|t| !t.is_closed()) {
Some(t) => t.clone(),
None => {
let session = host.ssh.session(&id).await?;
// Fail with the reason here: a missing docker only shows as a dropped connection later.
let probe = session.exec("docker version --format {{.Client.Version}}", None).await?;
if !probe.success() {
let why = String::from_utf8_lossy(&probe.stderr).trim().to_owned();
return Err(IdeError::unavailable(format!(
"docker could not be run on {} over SSH{}",
session.label(),
if why.is_empty() { String::new() } else { format!(": {why}") }
)));
}
let t = Arc::new(Tunnel::command(session, DIAL).await?);
tunnels.insert(id, t.clone());
t
}
};
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{}", tunnel.port()), tls_cert_dir: None })
}
/// Environment for a Docker run configuration's command line: selects `endpoint`'s
/// daemon and puts the docker executable on `PATH`.
#[command(trust = always)]
pub async fn docker_run_env(host: &Host, endpoint: DockerEndpoint) -> IdeResult<BTreeMap<String, String>> {
// A remote project gets them from the server, since its run configurations start on the remote host.
/// The endpoint's variables plus a `PATH` that finds this host's `docker`. A remote project
/// gets them from the server, since its run configurations start on the remote host.
pub async fn run_env(host: &Host, endpoint: DockerEndpoint) -> IdeResult<BTreeMap<String, String>> {
endpoint.validate()?;
let endpoint = resolve(host, endpoint).await?;
host.blocking(move || Ok(ide_docker::run_env(&endpoint))).await
}
ide_command::domain!(docker: docker_run_env);
pub(crate) fn register(d: &mut Dispatcher) {
d.add("docker_run_env", |c| async move { run_env(&c.host, c.arg("endpoint")?).await });
}
+7 -8
Переглянути файл
@@ -2,20 +2,19 @@
//! (and, on the remote server, the project's `remoteEnv`) without a restart.
use crate::Host;
use crate::environment::EnvReloaded;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::IdeResult;
use std::sync::Arc;
/// Reload Environment: new child processes get the login shell's current environment
/// (and the project's `remoteEnv` on a remote host); running ones keep theirs.
#[command(trust = always)]
pub async fn env_reload(host: &Arc<Host>, window: &str) -> IdeResult<EnvReloaded> {
// Re-reads the login shell (and the window's project `remoteEnv` where it applies);
// running terminals and processes keep their environment.
/// Re-reads the login shell (and the window's project `remoteEnv` where it applies);
/// running terminals and processes keep their environment.
pub async fn reload(host: &Arc<Host>, window: &str) -> IdeResult<EnvReloaded> {
let root = host.project(window).ok().filter(|p| !p.light && p.is_trusted()).map(|p| p.root.clone());
let sink = host.window_sink(window);
let h = host.clone();
host.blocking(move || h.environment.reload(root.as_deref(), &sink)).await
}
ide_command::domain!(env: env_reload);
pub(crate) fn register(d: &mut Dispatcher) {
d.add("env_reload", |c| async move { reload(&c.host, &c.window).await });
}
+14 -49
Переглянути файл
@@ -1,12 +1,10 @@
use super::Channel;
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_vfs::FileEntry;
use std::path::{Path, PathBuf};
#[command(trust = always)]
pub async fn fs_entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {
pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {
host.blocking(move || {
let meta = std::fs::metadata(path)?;
Ok(if meta.is_dir() { ide_vfs::EntryKind::Dir } else { ide_vfs::EntryKind::File })
@@ -14,8 +12,7 @@ pub async fn fs_entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::Ent
.await
}
#[command(trust = always)]
pub async fn fs_compare_directories(
pub async fn compare_directories(
host: &Host,
window: &str,
left: PathBuf,
@@ -41,8 +38,7 @@ pub async fn fs_compare_directories(
result
}
#[command(trust = always)]
pub async fn fs_copy_merge(
pub async fn copy_merge(
host: &Host,
window: &str,
source_root: PathBuf,
@@ -77,9 +73,8 @@ pub async fn fs_copy_merge(
/// Files of a deleted folder snapshotted in Local History.
const DELETE_SNAPSHOT_LIMIT: usize = 2000;
#[command(trust = always)]
pub async fn fs_read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<FileEntry>> {
// Runs on the blocking pool: on a network share (`\\wsl.localhost`) every stat is slow.
/// Runs on the blocking pool: on a network share (`\\wsl.localhost`) every stat is slow.
pub async fn read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<FileEntry>> {
let project = host.project(window);
host.blocking(move || {
let excludes = project
@@ -104,8 +99,7 @@ pub async fn fs_read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<
/// Creates an empty file; inside a project, honours the EditorConfig
/// `charset` (writes the BOM for `utf-8-bom` / UTF-16).
#[command(trust = always)]
pub fn fs_create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
pub fn create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
match host.project(window) {
Ok(p) => {
let defaults = p.documents.file_defaults();
@@ -130,8 +124,7 @@ pub fn fs_create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()>
}
}
#[command(trust = always)]
pub async fn fs_create_file_bytes(host: &Host, window: &str, path: PathBuf, data: Vec<u8>) -> IdeResult<()> {
pub async fn create_file_bytes(host: &Host, window: &str, path: PathBuf, data: Vec<u8>) -> IdeResult<()> {
let project = host.project(window).ok();
host.blocking(move || {
ide_vfs::create_file_bytes(&path, &data)?;
@@ -145,25 +138,17 @@ pub async fn fs_create_file_bytes(host: &Host, window: &str, path: PathBuf, data
.await
}
#[command(trust = always)]
pub fn fs_create_dir(path: PathBuf) -> IdeResult<()> {
ide_vfs::create_dir(&path)
}
/// Toggle Read-only Attribute: sets the writable bit (and the open document's
/// state). Returns whether the file is read-only now.
#[command(trust = always)]
pub fn fs_set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) -> IdeResult<bool> {
pub fn set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) -> IdeResult<bool> {
match host.project(window) {
Ok(p) => p.documents.set_writable(&path, writable),
Err(_) => ide_vfs::set_writable(&path, writable).map(|()| !writable),
}
}
/// Moving to the trash can take a while (large trees): kept off the main thread.
#[command(trust = always)]
pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
// Local History keeps the contents so deleted files can be restored.
/// Moves to the trash; Local History keeps the contents so deleted files can be restored.
pub async fn delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
let project = host.project(window).ok();
let history = project.as_ref().map(|p| p.history.clone());
host.blocking(move || {
@@ -183,8 +168,7 @@ pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()
.await
}
#[command(trust = always)]
pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
pub async fn copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
let project = host.project(window).ok();
host.blocking(move || {
ide_workspace::file_ops::copy(&from, &to)?;
@@ -199,8 +183,7 @@ pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> I
.await
}
#[command(trust = always)]
pub async fn fs_rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
pub async fn rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
let project = host.project(window).ok();
host.blocking(move || {
ide_workspace::file_ops::rename(&from, &to)?;
@@ -216,10 +199,8 @@ pub async fn fs_rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) ->
.await
}
/// Reads a text file without opening it as a document (previews, quick
/// definition). Prefers the unsaved buffer when the file is open.
#[command(trust = always)]
pub async fn fs_read_text(host: &Host, window: &str, path: PathBuf) -> IdeResult<String> {
/// Reads a text file without opening it as a document; prefers the unsaved buffer.
pub async fn read_text(host: &Host, window: &str, path: PathBuf) -> IdeResult<String> {
let project = host.project(window).ok();
host.blocking(move || match project {
Some(p) => p.text_of(&path),
@@ -270,19 +251,3 @@ mod tests {
assert!(!inside_any_root(Path::new("/work/spec.pdf"), &[]));
}
}
ide_command::domain!(
fs:
fs_compare_directories,
fs_copy,
fs_copy_merge,
fs_create_dir,
fs_create_file,
fs_create_file_bytes,
fs_delete,
fs_entry_kind,
fs_read_dir,
fs_read_text,
fs_rename,
fs_set_writable,
);
+45 -31
Переглянути файл
@@ -4,7 +4,7 @@
use crate::Host;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, IpcPath, RequestId};
use ide_dap::{JvmHeapOutcome, JvmHeapUnavailable};
use ide_heap::{AnalyzeOptions, HeapError, HeapOrigin, OpenSnapshot};
@@ -55,8 +55,8 @@ pub enum HeapOpenResult {
Cancelled,
}
/// Dumps the session's JVM and analyzes the dump; cancel with `request`.
#[command(trust = trusted)]
/// Dumps the session's JVM into a new snapshot directory and analyzes the dump there; cancel with
/// `request`. Anything but `Ready` leaves no directory behind.
pub async fn debug_heap_capture(
host: &Host,
window: &str,
@@ -64,7 +64,6 @@ pub async fn debug_heap_capture(
request: RequestId,
on_progress: Channel<HeapProgress>,
) -> IdeResult<HeapCaptureResult> {
// Dumps into a new snapshot directory; anything but `Ready` leaves no directory behind.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let running = Running::begin(host, request, &cancel);
@@ -120,8 +119,8 @@ async fn capture(
})
}
/// Analyzes an `.hprof` file; cancel with `request`.
#[command(trust = trusted)]
/// Analyzes the `.hprof` at `path` into a new snapshot directory; the file itself is never
/// changed or deleted. Cancel with `request`.
pub async fn debug_heap_open(
host: &Host,
window: &str,
@@ -129,7 +128,6 @@ pub async fn debug_heap_open(
request: RequestId,
on_progress: Channel<HeapProgress>,
) -> IdeResult<HeapOpenResult> {
// Analyzes into a new snapshot directory; the file itself is never changed or deleted.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let running = Running::begin(host, request, &cancel);
@@ -299,14 +297,14 @@ fn reporter<'a>(
}
}
#[command(trust = trusted)]
/// The class table of a snapshot.
pub async fn debug_heap_classes(host: &Host, window: &str, snapshot: HeapSnapshotId) -> IdeResult<Vec<HeapClassRow>> {
let snapshot = open_snapshot(host, window, snapshot)?;
host.blocking(move || Ok(snapshot.index().class_rows())).await
}
/// A page of the dominator tree: under `parent`, of type `classIndex`, or both.
#[command(trust = trusted)]
/// A page of the dominator tree; see [`ide_heap::HeapIndex::dominated`] for what `parent` and
/// `class_index` select.
pub async fn debug_heap_dominators(
host: &Host,
window: &str,
@@ -316,13 +314,11 @@ pub async fn debug_heap_dominators(
offset: u32,
limit: u32,
) -> IdeResult<HeapObjectPage> {
// See `ide_heap::HeapIndex::dominated` for what `parent` and `class_index` select.
let snapshot = open_snapshot(host, window, snapshot)?;
host.blocking(move || Ok(snapshot.index().dominated(parent, class_index, offset, limit))).await
}
/// The shortest path from `object` to a GC root; `null` when it is unreachable.
#[command(trust = trusted)]
/// The shortest path from `object` to a GC root; `None` when it is unreachable.
pub async fn debug_heap_path(
host: &Host,
window: &str,
@@ -333,30 +329,27 @@ pub async fn debug_heap_path(
host.blocking(move || Ok(snapshot.index().path_to_root(object))).await
}
#[command(trust = trusted)]
/// Class-by-class differences from `base` to `current`.
pub async fn debug_heap_compare(
host: &Host,
window: &str,
base: HeapSnapshotId,
current: HeapSnapshotId,
) -> IdeResult<Vec<HeapClassDiff>> {
// Class-by-class differences from `base` to `current`.
let base = open_snapshot(host, window, base)?;
let current = open_snapshot(host, window, current)?;
host.blocking(move || Ok(ide_heap::compare(base.index(), current.index()))).await
}
/// Copies the snapshot's dump to `path`, replacing a file there.
#[command(trust = trusted)]
/// Copies the snapshot's dump to `path`, replacing a file there (the UI has asked).
pub async fn debug_heap_save(host: &Host, window: &str, snapshot: HeapSnapshotId, path: IpcPath) -> IdeResult<()> {
let snapshot = open_snapshot(host, window, snapshot)?;
let target = path.into_path_buf();
host.blocking(move || copy_replacing(&snapshot.dump, &target)).await
}
#[command(trust = trusted)]
/// Forgets the snapshot and deletes its directory once no query is using it.
pub async fn debug_heap_close(host: &Host, window: &str, snapshot: HeapSnapshotId) -> IdeResult<()> {
// Forgets the snapshot and deletes its directory once no query is using it.
open_snapshot(host, window, snapshot)?;
close(host, snapshot).await
}
@@ -490,17 +483,38 @@ fn now_ms() -> u64 {
.map_or(0, |d| u64::try_from(d.as_millis()).unwrap_or(u64::MAX))
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_heap_capture", |c| async move {
debug_heap_capture(&c.host, &c.window, c.arg("session")?, c.arg("request")?, c.sender("onProgress")?).await
});
d.add("debug_heap_open", |c| async move {
debug_heap_open(&c.host, &c.window, c.arg("path")?, c.arg("request")?, c.sender("onProgress")?).await
});
d.add("debug_heap_classes", |c| async move { debug_heap_classes(&c.host, &c.window, c.arg("snapshot")?).await });
d.add("debug_heap_dominators", |c| async move {
debug_heap_dominators(
&c.host,
&c.window,
c.arg("snapshot")?,
c.arg("parent")?,
c.arg("classIndex")?,
c.arg("offset")?,
c.arg("limit")?,
)
.await
});
d.add("debug_heap_path", |c| async move {
debug_heap_path(&c.host, &c.window, c.arg("snapshot")?, c.arg("object")?).await
});
d.add("debug_heap_compare", |c| async move {
debug_heap_compare(&c.host, &c.window, c.arg("base")?, c.arg("current")?).await
});
d.add("debug_heap_save", |c| async move {
debug_heap_save(&c.host, &c.window, c.arg("snapshot")?, c.arg("path")?).await
});
d.add("debug_heap_close", |c| async move { debug_heap_close(&c.host, &c.window, c.arg("snapshot")?).await });
}
#[cfg(test)]
mod tests;
ide_command::domain!(
heap:
debug_heap_capture,
debug_heap_classes,
debug_heap_close,
debug_heap_compare,
debug_heap_dominators,
debug_heap_open,
debug_heap_path,
debug_heap_save,
);
+10 -5
Переглянути файл
@@ -1,6 +1,6 @@
//! Local History beyond single files: folders, labels, restoring deleted files.
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::IdeResult;
use ide_workspace::DirectoryHistory;
@@ -9,14 +9,12 @@ use std::path::PathBuf;
use super::doc::blocking;
/// Show History on a folder: snapshots of the files under it (deleted ones included) and labels.
#[command(trust = always)]
pub async fn history_list_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<DirectoryHistory> {
let project = host.project(window)?;
blocking(move || project.history.list_dir(&path)).await
}
/// Local History › Put Label…: a named point in the history of every file.
#[command(trust = always)]
pub fn history_put_label(host: &Host, window: &str, label: String) -> IdeResult<()> {
let project = host.project(window)?;
project.history.put_label(&project.root, &label)
@@ -24,7 +22,6 @@ pub fn history_put_label(host: &Host, window: &str, label: String) -> IdeResult<
/// Revert to a snapshot: writes its content to `path` (re-creating a deleted
/// file and its folders); an open editor updates in place.
#[command(trust = always)]
pub async fn history_restore(host: &Host, window: &str, path: PathBuf, id: String) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || {
@@ -47,4 +44,12 @@ pub async fn history_restore(host: &Host, window: &str, path: PathBuf, id: Strin
.await
}
ide_command::domain!(history: history_list_dir, history_put_label, history_restore);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("history_list_dir", |c| async move { history_list_dir(&c.host, &c.window, c.arg("path")?).await });
d.add("history_put_label", |c| async move { history_put_label(&c.host, &c.window, c.arg("label")?) });
d.add(
"history_restore",
|c| async move { history_restore(&c.host, &c.window, c.arg("path")?, c.arg("id")?).await },
);
}
+15 -9
Переглянути файл
@@ -2,7 +2,7 @@
pub(crate) mod cache;
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use super::build::load;
use ide_build::compile;
@@ -13,10 +13,10 @@ use ide_run::BuildPolicy;
use std::path::PathBuf;
/// Cancellable with `cancel_request(request)`.
/// Builds according to `policy`, then resolves the runtime (or test)
/// Builds the workspace (when `build`), then resolves the runtime (or test)
/// classpath and the JDK of the module at `module` (absolute, or relative to the project root).
/// A module with Kotlin / Groovy / Scala sources is built by its build system, whose class directories come first.
#[command(trust = trusted)]
/// Resources a Gradle build filters or renames are processed by Gradle, replacing the language server's plain copies.
pub async fn java_resolve_launch(
host: &Host,
window: &str,
@@ -25,8 +25,6 @@ pub async fn java_resolve_launch(
policy: BuildPolicy,
request: RequestId,
) -> IdeResult<JavaLaunchInfo> {
// Resources a Gradle build filters or renames are processed by Gradle, replacing the language
// server's plain copies.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let result = resolve_launch(host, window, module, test, policy, &cancel).await;
@@ -375,7 +373,6 @@ fn use_snapshot_on(
}
/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).
#[command(trust = trusted)]
pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> IdeResult<u16> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -384,7 +381,6 @@ pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> Id
}
/// Incremental build of the jdtls workspace serving `module` (e.g. before HotSwap).
#[command(trust = trusted)]
pub async fn java_build_workspace(
host: &Host,
window: &str,
@@ -403,6 +399,18 @@ pub async fn java_build_workspace(
result
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("java_resolve_launch", |c| async move {
java_resolve_launch(&c.host, &c.window, c.arg("module")?, c.arg("test")?, c.arg("policy")?, c.arg("request")?)
.await
});
d.add("java_debug_server", |c| async move { java_debug_server(&c.host, &c.window, c.arg("module")?).await });
d.add("java_build_workspace", |c| async move {
java_build_workspace(&c.host, &c.window, c.arg("module")?, c.arg("request")?).await
});
}
/// An annotation processor's error for writing a file this build already wrote (JDT's
/// `IdeFilerImpl`: "Source file already created", javac's Filer: "Attempt to recreate a file").
fn processor_recreated_a_file(message: &str) -> bool {
@@ -670,5 +678,3 @@ mod tests {
}
}
}
ide_command::domain!(java: java_build_workspace, java_debug_server, java_resolve_launch);
-4
Переглянути файл
@@ -1,6 +1,5 @@
//! Bounded, read-only JVM presentation for visible files, also served remotely.
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, IdeError, IdeResult, LanguageId};
use ide_syntax::{JvmPresentation, Snapshot, StructureService, jvm_type_header};
use serde::{Deserialize, Serialize};
@@ -60,7 +59,6 @@ fn read_presentation(
Ok(presentation)
}
#[command(trust = always)]
pub async fn jvm_file_presentations(
host: &Host,
window: &str,
@@ -134,5 +132,3 @@ mod tests {
assert_eq!(presentation.kind, Some(ide_syntax::JvmTypeKind::Class));
}
}
ide_command::domain!(jvm_icons: jvm_file_presentations);
+257 -152
Переглянути файл
@@ -1,7 +1,8 @@
use super::doc::blocking;
use crate::Host;
use crate::apply_workspace_edit as apply_edit;
use crate::plugins::{ProviderKind, editor_providers_for as editor_providers};
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::error::ErrorKind;
use ide_core::{DocId, IdeError, IdeResult, Location, Pos, Range, RequestId, ServerId, TextEdit, WorkspaceEdit};
use ide_lsp::types::*;
@@ -59,7 +60,6 @@ async fn prepare_actions(
.await
}
#[command(trust = trusted)]
pub async fn lsp_completion(
host: &Host,
window: &str,
@@ -224,7 +224,6 @@ fn plugin_completion(item: ide_plugin::CompletionItem) -> CompletionItem {
}
/// Inline (ghost text) suggestions at `pos`; `automatic` when triggered by typing.
#[command(trust = trusted)]
pub async fn lsp_inline_completion(
host: &Host,
window: &str,
@@ -257,7 +256,6 @@ pub async fn lsp_inline_completion(
}
}
#[command(trust = trusted)]
pub async fn lsp_resolve_completion(
host: &Host,
window: &str,
@@ -267,7 +265,6 @@ pub async fn lsp_resolve_completion(
host.project(window)?.lsp.resolve_completion(doc, item).await
}
#[command(trust = trusted)]
pub async fn lsp_hover(
host: &Host,
window: &str,
@@ -297,7 +294,6 @@ pub async fn lsp_hover(
Ok(crate::plugins::merge_hover(server, hovers))
}
#[command(trust = trusted)]
pub async fn lsp_signature_help(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Option<SignatureHelp>> {
let target = position_document(host, window, doc, pos).await?;
let server = host.project(window)?.lsp.signature_help(target, pos).await;
@@ -317,7 +313,6 @@ pub async fn lsp_signature_help(host: &Host, window: &str, doc: DocId, pos: Pos)
}
}
#[command(trust = trusted)]
pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: GotoKind) -> IdeResult<Vec<Location>> {
let target = position_document(host, window, doc, pos).await?;
// ⌘B on a declaration shows its usages, also when a plugin's index links the name elsewhere
@@ -464,8 +459,7 @@ fn without_generated_helpers(locations: Vec<Location>) -> Vec<Location> {
locations.into_iter().filter(|l| !generated(l)).collect()
}
/// Gutter markers of plugin `line-markers` providers for an open document.
#[command(trust = trusted)]
/// Gutter markers from plugins (`line-markers` providers) for `doc`.
pub async fn plugin_line_markers(
host: &Host,
window: &str,
@@ -490,7 +484,6 @@ pub async fn plugin_line_markers(
/// Implementations of the symbols at `positions`, one list per position (the
/// editor's "is implemented / overridden" gutter markers). Cancel with
/// `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn lsp_implementations(
host: &Host,
window: &str,
@@ -560,7 +553,6 @@ pub async fn lsp_implementations(
/// Refines the implementations `targets` of the method at `pos` to their declarations (Java
/// dependencies' class files point at the start of the class). Cancel with
/// `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn lsp_implementation_locations(
host: &Host,
window: &str,
@@ -576,10 +568,9 @@ pub async fn lsp_implementation_locations(
result
}
/// Go to Implementation of the symbol at `pos`. Implementations found before a
/// slower search for the rest arrive on `on_partial`; the result has them all.
/// Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
/// Go to Implementation of the symbol at `pos`. Implementations found before a slower
/// search for the rest (Java: the project's, before the dependencies') arrive on
/// `on_partial`; the result has them all. Cancel with `cancel_request(request)`.
pub async fn lsp_goto_implementation(
host: &Host,
window: &str,
@@ -588,7 +579,6 @@ pub async fn lsp_goto_implementation(
pos: Pos,
on_partial: super::Channel<Vec<Location>>,
) -> IdeResult<Vec<Location>> {
// Java: the project's implementations arrive before the dependencies'.
let lsp = host.project(window)?.lsp.clone();
let (target, cancel) = begin_position_request(host, window, request, doc, pos).await?;
let result = lsp
@@ -606,7 +596,6 @@ pub async fn lsp_goto_implementation(
/// Contents of a read-only language-server document, including JDT library
/// classes and disk class files. Cached per project.
#[command(trust = trusted)]
pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> IdeResult<VirtualDocument> {
if uri.starts_with("git-revision:") {
return crate::ops::vcs::revision_virtual_document(host, window, &uri, None).await;
@@ -614,9 +603,8 @@ pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> Ide
host.project(window)?.lsp.virtual_document(&uri).await
}
#[command(trust = trusted)]
/// Whether this class belongs to the project's Maven local repository.
pub async fn lsp_can_download_sources(host: &Host, window: &str, uri: String) -> IdeResult<bool> {
// Whether this class belongs to the project's Maven local repository.
let project = host.project(window)?;
if !project.is_trusted() {
return Ok(false);
@@ -632,7 +620,7 @@ pub async fn lsp_can_download_sources(host: &Host, window: &str, uri: String) ->
.await
}
#[command(trust = trusted)]
/// Download with the project's Maven configuration, or attach an archive selected by the user.
pub async fn lsp_library_sources(
host: &Host,
window: &str,
@@ -641,7 +629,6 @@ pub async fn lsp_library_sources(
pos: Pos,
sources: Option<std::path::PathBuf>,
) -> IdeResult<Option<Location>> {
// Download with the project's Maven configuration, or attach an archive selected by the user.
host.require_trust(window)?;
let project = host.project(window)?;
let cancel = host.begin_project_request(window, request);
@@ -692,21 +679,19 @@ pub async fn lsp_library_sources(
result
}
#[command(trust = trusted)]
/// Opens compiled classes through JDT, with project source taking priority on disk.
pub async fn lsp_resolve_class_file(host: &Host, window: &str, path: std::path::PathBuf) -> IdeResult<String> {
// Opens compiled classes through JDT, with project source taking priority on disk.
let archive = ide_vfs::split_archive_path(&path);
host.project(window)?.lsp.java_class_file(&path, archive).await
}
/// References of the symbol at `pos`. `project_wide` also searches project files
/// outside the language server's analysis scope; bulk scans over many symbols
/// leave it off. Java, `project_wide`: without `libraries`, the dependencies and the JDK
/// are not searched; with it, those found in the sources arrive on `on_partial` before
/// leave it off. Java: without `libraries`, the dependencies and the JDK are not
/// searched; with it and `project_wide`, those found in the sources arrive on `on_partial` before
/// the slower search for the rest, and the result has them all. Cancel with
/// `cancel_request(request)`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_references(
host: &Host,
window: &str,
@@ -718,7 +703,6 @@ pub async fn lsp_references(
libraries: bool,
on_partial: super::Channel<References>,
) -> IdeResult<References> {
// Java: without `libraries`, the dependencies and the JDK are not searched.
let project = host.project(window)?;
let lsp = project.lsp.clone();
let (target, cancel) = begin_position_request(host, window, request, doc, pos).await?;
@@ -858,7 +842,6 @@ fn merge_indexed_references(mut server: References, symbol: &crate::plugins::nav
server
}
#[command(trust = trusted)]
pub async fn lsp_document_highlights(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Vec<Highlight>> {
let target = position_document(host, window, doc, pos).await?;
let server = host.project(window)?.lsp.document_highlights(target, pos).await;
@@ -869,7 +852,6 @@ pub async fn lsp_document_highlights(host: &Host, window: &str, doc: DocId, pos:
Ok(merge_language_highlights(provider_server(server)?, items))
}
#[command(trust = trusted)]
pub async fn lsp_workspace_symbols(
host: &Host,
window: &str,
@@ -883,7 +865,6 @@ pub async fn lsp_workspace_symbols(
result
}
#[command(trust = trusted)]
pub async fn lsp_code_actions(
host: &Host,
window: &str,
@@ -1037,7 +1018,6 @@ async fn resolve_action(host: &Host, window: &str, doc: DocId, action: CodeActio
}
/// Cancellable code actions with the kinds the servers advertise (Refactor This, refactoring availability).
#[command(trust = trusted)]
pub async fn lsp_code_action_query(
host: &Host,
window: &str,
@@ -1058,8 +1038,7 @@ pub async fn lsp_code_action_query(
Ok(result)
}
/// Resolves a code action's edit without applying it (intention preview).
#[command(trust = trusted)]
/// Resolves a code action's edit without applying it.
pub async fn lsp_resolve_code_action(
host: &Host,
window: &str,
@@ -1077,7 +1056,6 @@ pub async fn lsp_resolve_code_action(
}
/// Resolves (if needed), applies the edit, then runs the command of a code action.
#[command(trust = trusted)]
pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action: CodeAction) -> IdeResult<()> {
let project = host.project(window)?;
let action = if action.edit.is_none() && action.command.is_none() {
@@ -1094,7 +1072,7 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
if let Some(edit) = &action.edit {
let documents = project.documents.clone();
let edit = edit.clone();
blocking(move || documents.apply_workspace_edit(&edit)).await?;
blocking(move || apply_edit(&documents, &edit)).await?;
}
open_plugin_action_target(&action, window);
if let Some(command) = &action.command
@@ -1144,7 +1122,6 @@ async fn is_client_follow_up(
!provided
}
#[command(trust = trusted)]
pub async fn lsp_prepare_rename(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Option<Range>> {
if let Some(symbol) = indexed_symbol(host, window, doc, pos).await? {
let project = host.project(window)?;
@@ -1163,8 +1140,8 @@ pub async fn lsp_prepare_rename(host: &Host, window: &str, doc: DocId, pos: Pos)
host.project(window)?.lsp.prepare_rename(doc, pos).await
}
/// The class at `pos` and the members Pull Members Up / Push Members Down can move.
#[command(trust = trusted)]
/// Computes the rename edit without applying it, so the UI can preview conflicts.
/// The class at `pos` and the members a class-hierarchy refactoring can move.
pub async fn lsp_hierarchy_members(
host: &Host,
window: &str,
@@ -1180,9 +1157,8 @@ pub async fn lsp_hierarchy_members(
result
}
/// Checks Pull Members Up / Push Members Down and computes the edit without applying it.
/// Checks a class-hierarchy refactoring and computes its edit without applying it.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_hierarchy_refactor(
host: &Host,
window: &str,
@@ -1215,7 +1191,7 @@ pub async fn lsp_hierarchy_refactor(
.await
}
#[command(trust = trusted)]
/// The signature of the method at `pos`, for Change Signature.
pub async fn lsp_signature_info(
host: &Host,
window: &str,
@@ -1223,7 +1199,6 @@ pub async fn lsp_signature_info(
doc: DocId,
pos: Pos,
) -> IdeResult<MethodSignature> {
// The signature of the method at `pos`, for Change Signature.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature_info(doc, pos, cancel).await;
@@ -1231,8 +1206,8 @@ pub async fn lsp_signature_info(
result
}
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_change_signature(
host: &Host,
window: &str,
@@ -1243,7 +1218,6 @@ pub async fn lsp_change_signature(
delegate: bool,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
let project = host.project(window)?;
let documents = project.documents.clone();
let version = blocking(move || documents.version(doc)).await?;
@@ -1274,7 +1248,8 @@ fn json_strings(values: Vec<serde_json::Value>) -> Vec<String> {
values.iter().map(serde_json::Value::to_string).collect()
}
#[command(trust = trusted)]
/// Where a Java Move code action of `kind` can go; `args` (JSON) carries the code action's own
/// arguments back unchanged, and each destination comes back as JSON.
pub async fn lsp_java_move_destinations(
host: &Host,
window: &str,
@@ -1283,8 +1258,6 @@ pub async fn lsp_java_move_destinations(
kind: String,
args: String,
) -> IdeResult<Vec<String>> {
// Where a Java Move code action of `kind` can go; `args` (JSON) carries the code action's own
// arguments back unchanged, and each destination comes back as JSON.
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
@@ -1293,7 +1266,7 @@ pub async fn lsp_java_move_destinations(
result.map(json_strings)
}
#[command(trust = trusted)]
/// The project's Java source types, for moving a member or type into a class.
pub async fn lsp_java_source_types(
host: &Host,
window: &str,
@@ -1301,7 +1274,6 @@ pub async fn lsp_java_source_types(
doc: DocId,
project_name: Option<String>,
) -> IdeResult<Vec<String>> {
// The project's Java source types, for moving a member or type into a class.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_source_types(doc, project_name, cancel).await;
@@ -1309,8 +1281,8 @@ pub async fn lsp_java_source_types(
result.map(json_strings)
}
/// Checks a Java move and computes its edit without applying it.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_java_move(
host: &Host,
window: &str,
@@ -1320,7 +1292,6 @@ pub async fn lsp_java_move(
args: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
// Checks a Java move and computes its edit without applying it.
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
@@ -1336,7 +1307,7 @@ pub async fn lsp_java_move(
.await
}
#[command(trust = trusted)]
/// The Java class to extract an interface from: its members and the packages for the interface.
pub async fn lsp_extract_interface_info(
host: &Host,
window: &str,
@@ -1344,7 +1315,6 @@ pub async fn lsp_extract_interface_info(
doc: DocId,
pos: Pos,
) -> IdeResult<ExtractInterfaceInfo> {
// The Java class to extract an interface from: its members and the packages for the interface.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.extract_interface_info(doc, pos, cancel).await;
@@ -1352,8 +1322,9 @@ pub async fn lsp_extract_interface_info(
result
}
/// Checks extracting a Java interface and computes its edit without applying it; `destination`
/// is one of the info's packages.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_extract_interface(
host: &Host,
window: &str,
@@ -1365,8 +1336,6 @@ pub async fn lsp_extract_interface(
destination: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
// Checks extracting a Java interface and computes its edit without applying it; `destination`
// is one of the info's packages.
let destination = json_argument(&destination)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
@@ -1382,8 +1351,6 @@ pub async fn lsp_extract_interface(
.await
}
/// Computes the rename edit without applying it, so the UI can preview conflicts.
#[command(trust = trusted)]
pub async fn lsp_rename(
host: &Host,
window: &str,
@@ -1566,7 +1533,6 @@ fn merge_indexed_rename(
renamed.edit.deduplicate();
}
#[command(trust = trusted)]
pub async fn lsp_format(
host: &Host,
window: &str,
@@ -1577,7 +1543,6 @@ pub async fn lsp_format(
crate::formatter::format(host, window, doc, range, options).await
}
#[command(trust = trusted)]
pub async fn lsp_inlay_hints(host: &Host, window: &str, doc: DocId, range: Range) -> IdeResult<Vec<InlayHint>> {
let lsp = host.project(window)?.lsp.clone();
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::InlayHints) else {
@@ -1597,7 +1562,6 @@ pub async fn lsp_inlay_hints(host: &Host, window: &str, doc: DocId, range: Range
Ok(crate::plugins::merge_inlay_hints(server, hints, range))
}
#[command(trust = trusted)]
pub async fn lsp_semantic_tokens(host: &Host, window: &str, doc: DocId) -> IdeResult<Option<SemanticTokens>> {
let lsp = host.project(window)?.lsp.clone();
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::SemanticTokens) else {
@@ -1617,7 +1581,6 @@ pub async fn lsp_semantic_tokens(host: &Host, window: &str, doc: DocId) -> IdeRe
Ok(Some(crate::plugins::merge_semantic_tokens(server, tokens)))
}
#[command(trust = trusted)]
pub async fn lsp_code_lens(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<CodeLens>> {
let server = host.project(window)?.lsp.code_lens(doc).await;
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::CodeLenses) else {
@@ -1637,7 +1600,6 @@ pub async fn lsp_code_lens(host: &Host, window: &str, doc: DocId) -> IdeResult<V
}
/// Links in a document (`href`s, Markdown links, `#include`s…) from its language servers.
#[command(trust = trusted)]
pub async fn lsp_document_links(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<DocumentLink>> {
let server = host.project(window)?.lsp.document_links(doc).await;
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::DocumentLinks) else {
@@ -1668,7 +1630,6 @@ pub async fn lsp_document_links(host: &Host, window: &str, doc: DocId) -> IdeRes
Ok(out)
}
#[command(trust = trusted)]
pub async fn lsp_call_hierarchy(
host: &Host,
window: &str,
@@ -1684,7 +1645,6 @@ pub async fn lsp_call_hierarchy(
result
}
#[command(trust = trusted)]
pub async fn lsp_type_hierarchy(
host: &Host,
window: &str,
@@ -1695,7 +1655,6 @@ pub async fn lsp_type_hierarchy(
host.project(window)?.lsp.type_hierarchy(doc, pos, direction).await
}
#[command(trust = trusted)]
pub async fn lsp_prepare_type_hierarchy(
host: &Host,
window: &str,
@@ -1705,27 +1664,15 @@ pub async fn lsp_prepare_type_hierarchy(
host.project(window)?.lsp.prepare_type_hierarchy(doc, pos).await
}
#[command(trust = always)]
pub fn lsp_servers(host: &Host, window: &str) -> IdeResult<Vec<ServerInfo>> {
Ok(host.project(window)?.lsp.servers())
}
/// Answers a server's `window/showMessageRequest` question (`null`: dismissed). It runs where the
/// language server runs: the question waits in that process, a remote project's server included.
#[command(trust = trusted)]
pub fn lsp_message_request_answer(id: u32, choice: Option<String>) -> IdeResult<()> {
ide_lsp::answer_message_request(id, choice);
Ok(())
}
/// Re-emits the language servers' current diagnostics (the UI loaded after they arrived).
#[command(trust = always)]
pub fn lsp_resend_diagnostics(host: &Host, window: &str) -> IdeResult<()> {
host.project(window)?.lsp.resend_diagnostics();
Ok(())
}
#[command(trust = trusted)]
pub async fn lsp_restart(host: &Host, window: &str, server: ServerId) -> IdeResult<()> {
let project = host.project(window)?;
let java = project.lsp.servers().iter().any(|s| s.id == server && s.name == "jdtls");
@@ -1759,12 +1706,11 @@ pub async fn lsp_restart_named(host: &Host, name: &str) -> IdeResult<()> {
}
/// Applies a (previewed) workspace edit, e.g. after rename confirmation.
#[command(trust = always)]
pub async fn apply_workspace_edit(host: &Host, window: &str, edit: WorkspaceEdit) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || {
record_before_multi_file_edit(&project, &edit);
project.documents.apply_workspace_edit(&edit)
apply_edit(&project.documents, &edit)
})
.await
}
@@ -1795,7 +1741,6 @@ fn record_before_multi_file_edit(project: &crate::Project, edit: &WorkspaceEdit)
}
}
#[command(trust = always)]
pub async fn prepare_workspace_edit(host: &Host, window: &str, mut edit: WorkspaceEdit) -> IdeResult<WorkspaceEdit> {
let project = host.project(window)?;
blocking(move || {
@@ -1805,13 +1750,11 @@ pub async fn prepare_workspace_edit(host: &Host, window: &str, mut edit: Workspa
.await
}
#[command(trust = always)]
pub async fn undo_workspace_edit(host: &Host, window: &str, id: u32) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || project.documents.undo_workspace_edit(id)).await
}
#[command(trust = always)]
pub async fn redo_workspace_edit(host: &Host, window: &str, id: u32) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || project.documents.redo_workspace_edit(id)).await
@@ -1819,7 +1762,6 @@ pub async fn redo_workspace_edit(host: &Host, window: &str, id: u32) -> IdeResul
/// Runs a server command (`workspace/executeCommand`), e.g. a completion item's
/// follow-up command. Edits the server requests arrive via `workspace/applyEdit`.
#[command(trust = trusted)]
pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command: Command) -> IdeResult<()> {
if let Some(rest) = command.command.strip_prefix("openidea.plugin-language:") {
let (plugin, command_id) =
@@ -1890,7 +1832,7 @@ async fn run_plugin_server_command(
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
}
#[command(trust = trusted)]
/// Resolves an interactive command without applying edits or executing it.
pub async fn lsp_resolve_command(
host: &Host,
window: &str,
@@ -1900,7 +1842,6 @@ pub async fn lsp_resolve_command(
command: Command,
answers: Vec<FormAnswer>,
) -> IdeResult<Option<CommandForm>> {
// Resolves an interactive command without applying edits or executing it.
let lsp = host.project(window)?.lsp.clone();
let cancel = host.begin_request(request);
let result = lsp.resolve_command(doc, server, command, answers, cancel).await;
@@ -1908,7 +1849,7 @@ pub async fn lsp_resolve_command(
result
}
#[command(trust = trusted)]
/// Applies an explicitly invoked action after the interactive answers have been validated.
pub async fn lsp_execute_code_action(
host: &Host,
window: &str,
@@ -1917,7 +1858,6 @@ pub async fn lsp_execute_code_action(
action: CodeAction,
answers: Vec<FormAnswer>,
) -> IdeResult<Vec<ide_core::IpcPath>> {
// Applies an explicitly invoked action after the interactive answers have been validated.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = async {
@@ -1929,7 +1869,7 @@ pub async fn lsp_execute_code_action(
let open = plugin_action_open(&action).map(|(_, path)| path);
if let Some(edit) = action.edit {
let documents = project.documents.clone();
tokio::task::spawn_blocking(move || documents.apply_workspace_edit(&edit))
tokio::task::spawn_blocking(move || apply_edit(&documents, &edit))
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
}
@@ -1965,7 +1905,6 @@ pub struct PluginLanguageVisuals {
pub colors: Vec<(String, ide_plugin::language_features::ColorInfo)>,
pub gutter_actions: Vec<(String, ide_plugin::language_features::GutterAction)>,
}
#[command(trust = trusted)]
pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> IdeResult<PluginLanguageVisuals> {
let project = host.project(window)?;
let snap = project.documents.snapshot(doc)?;
@@ -2002,7 +1941,6 @@ pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> I
})
.await
}
#[command(trust = trusted)]
pub async fn plugin_color_presentations(
host: &Host,
window: &str,
@@ -2027,9 +1965,234 @@ pub async fn plugin_color_presentations(
})
.await
}
#[command(trust = trusted)]
pub fn plugin_formatters() -> IdeResult<Vec<crate::plugins::language_features::FormatterChoice>> {
Ok(crate::plugins::editor_plugin_host().map(|p| p.formatter_choices()).unwrap_or_default())
pub fn plugin_formatters() -> Vec<crate::plugins::language_features::FormatterChoice> {
crate::plugins::editor_plugin_host().map(|p| p.formatter_choices()).unwrap_or_default()
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add(
"plugin_language_visuals",
|c| async move { plugin_language_visuals(&c.host, &c.window, c.arg("doc")?).await },
);
d.add("plugin_color_presentations", |c| async move {
plugin_color_presentations(&c.host, &c.window, c.arg("doc")?, c.arg("plugin")?, c.arg("color")?).await
});
d.add("plugin_formatters", |_c| async move { Ok(plugin_formatters()) });
d.add("lsp_completion", |c| async move {
lsp_completion(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("trigger")?).await
});
d.add("lsp_inline_completion", |c| async move {
lsp_inline_completion(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("automatic")?)
.await
});
d.add("lsp_resolve_completion", |c| async move {
lsp_resolve_completion(&c.host, &c.window, c.arg("doc")?, c.arg("item")?).await
});
d.add("lsp_hover", |c| async move {
lsp_hover(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_signature_help", |c| async move {
lsp_signature_help(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add(
"lsp_goto",
|c| async move { lsp_goto(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("kind")?).await },
);
d.add("lsp_implementations", |c| async move {
lsp_implementations(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("positions")?).await
});
d.add("lsp_goto_implementation", |c| async move {
let on_partial = c.sender("onPartial")?;
lsp_goto_implementation(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, on_partial).await
});
d.add("lsp_implementation_locations", |c| async move {
lsp_implementation_locations(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("targets")?,
)
.await
});
d.add(
"lsp_resolve_class_file",
|c| async move { lsp_resolve_class_file(&c.host, &c.window, c.arg("path")?).await },
);
d.add("lsp_virtual_document", |c| async move { lsp_virtual_document(&c.host, &c.window, c.arg("uri")?).await });
d.add(
"lsp_can_download_sources",
|c| async move { lsp_can_download_sources(&c.host, &c.window, c.arg("uri")?).await },
);
d.add("lsp_library_sources", |c| async move {
lsp_library_sources(&c.host, &c.window, c.arg("request")?, c.arg("uri")?, c.arg("pos")?, c.arg("sources")?)
.await
});
d.add("lsp_references", |c| async move {
let on_partial = c.sender("onPartial")?;
lsp_references(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("includeDeclaration")?,
c.arg("projectWide")?,
c.arg("libraries")?,
on_partial,
)
.await
});
d.add("lsp_document_highlights", |c| async move {
lsp_document_highlights(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_workspace_symbols", |c| async move {
lsp_workspace_symbols(&c.host, &c.window, c.arg("request")?, c.arg("query")?).await
});
d.add("lsp_code_actions", |c| async move {
lsp_code_actions(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("only")?).await
});
d.add("lsp_code_action_query", |c| async move {
lsp_code_action_query(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("range")?, c.arg("only")?)
.await
});
d.add("lsp_resolve_code_action", |c| async move {
lsp_resolve_code_action(&c.host, &c.window, c.arg("doc")?, c.arg("action")?).await
});
d.add("lsp_apply_code_action", |c| async move {
lsp_apply_code_action(&c.host, &c.window, c.arg("doc")?, c.arg("action")?).await
});
d.add("lsp_prepare_rename", |c| async move {
lsp_prepare_rename(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_rename", |c| async move {
lsp_rename(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("newName")?).await
});
d.add("lsp_hierarchy_members", |c| async move {
lsp_hierarchy_members(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("kind")?).await
});
d.add("lsp_hierarchy_refactor", |c| async move {
lsp_hierarchy_refactor(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("kind")?,
c.arg("target")?,
c.arg("choices")?,
)
.await
});
d.add("lsp_signature_info", |c| async move {
lsp_signature_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_change_signature", |c| async move {
lsp_change_signature(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("signature")?,
c.arg("delegate")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_extract_interface_info", |c| async move {
lsp_extract_interface_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_extract_interface", |c| async move {
lsp_extract_interface(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("members")?,
c.arg("name")?,
c.arg("destination")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_java_move_destinations", |c| async move {
lsp_java_move_destinations(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("kind")?, c.arg("args")?)
.await
});
d.add("lsp_java_source_types", |c| async move {
lsp_java_source_types(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("projectName")?).await
});
d.add("lsp_java_move", |c| async move {
lsp_java_move(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("kind")?,
c.arg("args")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_format", |c| async move {
lsp_format(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("options")?).await
});
d.add(
"lsp_inlay_hints",
|c| async move { lsp_inlay_hints(&c.host, &c.window, c.arg("doc")?, c.arg("range")?).await },
);
d.add("lsp_semantic_tokens", |c| async move { lsp_semantic_tokens(&c.host, &c.window, c.arg("doc")?).await });
d.add("lsp_code_lens", |c| async move { lsp_code_lens(&c.host, &c.window, c.arg("doc")?).await });
d.add("lsp_document_links", |c| async move { lsp_document_links(&c.host, &c.window, c.arg("doc")?).await });
d.add("lsp_call_hierarchy", |c| async move {
lsp_call_hierarchy(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("direction")?)
.await
});
d.add("lsp_type_hierarchy", |c| async move {
lsp_type_hierarchy(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("direction")?).await
});
d.add("lsp_prepare_type_hierarchy", |c| async move {
lsp_prepare_type_hierarchy(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_servers", |c| async move { lsp_servers(&c.host, &c.window) });
d.add("lsp_resend_diagnostics", |c| async move { lsp_resend_diagnostics(&c.host, &c.window) });
d.add("lsp_restart", |c| async move { lsp_restart(&c.host, &c.window, c.arg("server")?).await });
d.add("apply_workspace_edit", |c| async move { apply_workspace_edit(&c.host, &c.window, c.arg("edit")?).await });
d.add("lsp_resolve_command", |c| async move {
lsp_resolve_command(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("server")?,
c.arg("command")?,
c.arg("answers")?,
)
.await
});
d.add("lsp_execute_code_action", |c| async move {
lsp_execute_code_action(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("action")?,
c.arg("answers")?,
)
.await
});
d.add(
"prepare_workspace_edit",
|c| async move { prepare_workspace_edit(&c.host, &c.window, c.arg("edit")?).await },
);
d.add("redo_workspace_edit", |c| async move { redo_workspace_edit(&c.host, &c.window, c.arg("id")?).await });
d.add("undo_workspace_edit", |c| async move { undo_workspace_edit(&c.host, &c.window, c.arg("id")?).await });
d.add("lsp_execute_command", |c| async move {
lsp_execute_command(&c.host, &c.window, c.arg("doc")?, c.arg("command")?).await
});
}
#[cfg(test)]
@@ -2752,61 +2915,3 @@ mod tests {
assert_eq!(plugin_completion_kind("nonsense"), None);
}
}
ide_command::domain!(
lsp:
apply_workspace_edit,
lsp_apply_code_action,
lsp_call_hierarchy,
lsp_can_download_sources,
lsp_change_signature,
lsp_code_action_query,
lsp_code_actions,
lsp_code_lens,
lsp_completion,
lsp_document_highlights,
lsp_document_links,
lsp_execute_code_action,
lsp_execute_command,
lsp_extract_interface,
lsp_extract_interface_info,
lsp_format,
lsp_goto,
lsp_goto_implementation,
lsp_hierarchy_members,
lsp_hierarchy_refactor,
lsp_hover,
lsp_implementation_locations,
lsp_implementations,
lsp_inlay_hints,
lsp_inline_completion,
lsp_java_move,
lsp_java_move_destinations,
lsp_java_source_types,
lsp_library_sources,
lsp_message_request_answer,
lsp_prepare_rename,
lsp_prepare_type_hierarchy,
lsp_references,
lsp_rename,
lsp_resend_diagnostics,
lsp_resolve_class_file,
lsp_resolve_code_action,
lsp_resolve_command,
lsp_resolve_completion,
lsp_restart,
lsp_semantic_tokens,
lsp_servers,
lsp_signature_help,
lsp_signature_info,
lsp_type_hierarchy,
lsp_virtual_document,
lsp_workspace_symbols,
plugin_color_presentations,
plugin_formatters,
plugin_language_visuals,
plugin_line_markers,
prepare_workspace_edit,
redo_workspace_edit,
undo_workspace_edit,
);
+33 -49
Переглянути файл
@@ -32,7 +32,7 @@ pub mod scaffold;
pub mod sdk;
pub mod search;
pub mod spell;
pub mod ssh;
mod ssh;
pub mod stream_trace;
pub mod syntax;
pub mod term;
@@ -69,54 +69,38 @@ impl<T> Clone for Channel<T> {
}
}
// Every module that declares `#[command]`s, by domain name.
ide_command::domains!(
agent: crate::ops::agent,
analysis: crate::ops::analysis,
build: crate::ops::build,
bytes: crate::ops::bytes,
coverage: crate::ops::coverage,
db: crate::ops::db,
debug: crate::ops::debug,
dependencies: crate::ops::dependencies,
deploy: crate::ops::deploy,
doc: crate::ops::doc,
doc_commands: crate::ops::doc::commands,
docker: crate::ops::docker,
env: crate::ops::env,
fs: crate::ops::fs,
heap: crate::ops::heap,
history: crate::ops::history,
java: crate::ops::java,
jvm_icons: crate::ops::jvm_icons,
lsp: crate::ops::lsp,
mcp_reports: crate::mcp::reports,
nav: crate::ops::nav,
notebook: crate::ops::notebook,
plugins_commands: crate::plugins::commands,
plugins_commit: crate::plugins::commit,
plugins_index_ops: crate::plugins::index_ops,
plugins_run_targets: crate::plugins::run_targets,
plugins_views: crate::plugins::views,
project: crate::ops::project,
refactor: crate::ops::refactor,
run: crate::ops::run,
run_commands: crate::ops::run::commands,
scaffold: crate::ops::scaffold,
sdk: crate::ops::sdk,
sdk_container_python: crate::ops::sdk::container_python,
search: crate::ops::search,
search_commands: crate::ops::search::commands,
spell: crate::ops::spell,
ssh: crate::ops::ssh,
stream_trace: crate::ops::stream_trace,
syntax: crate::ops::syntax,
term: crate::ops::term,
tools: crate::ops::tools,
vcs: crate::ops::vcs,
vcs_commands: crate::ops::vcs::commands,
web: crate::ops::web,
);
/// Registers the commands of every module with the remote server.
pub fn register_all(d: &mut crate::rpc::Dispatcher) {
agent::register(d);
lsp::register(d);
notebook::register(d);
nav::register(d);
refactor::register(d);
analysis::register(d);
syntax::register(d);
spell::register(d);
dependencies::register(d);
history::register(d);
coverage::register(d);
build::register(d);
tools::register(d);
scaffold::register(d);
sdk::register(d);
java::register(d);
debug::register(d);
heap::register(d);
stream_trace::register(d);
bytes::register(d);
vcs::register(d);
doc::register(d);
search::register(d);
run::register(d);
env::register(d);
deploy::register(d);
docker::register(d);
db::register(d);
ssh::register(d);
}
impl Host {
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool.
+52 -58
Переглянути файл
@@ -1,7 +1,7 @@
use super::doc::blocking;
use crate::Host;
use crate::Project;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{DocId, IdeResult, IpcPath, LanguageId, Location, Pos};
use ide_index::{ExtensionCount, FileMatch, IndexStatus, SymbolFilter, SymbolMatch};
use ide_language::{FileReference, WebReference};
@@ -45,37 +45,30 @@ fn reference_roots(project: &Project) -> (PathBuf, Vec<PathBuf>) {
(project.root.clone(), resources)
}
#[command(trust = always)]
pub fn index_status(host: &Host, window: &str) -> IdeResult<IndexStatus> {
Ok(host.project(window)?.index.status())
}
#[command(trust = always)]
/// The project's file extensions, most common first.
pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<ExtensionCount>> {
// Most common first.
Ok(host.project(window)?.index.file_extensions())
}
#[command(trust = always)]
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
}
#[command(trust = always)]
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
/// Folders holding indexed files, for `@` references.
#[command(trust = always)]
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
}
#[command(trust = always)]
pub async fn find_symbols(
host: &Host,
window: &str,
@@ -87,40 +80,35 @@ pub async fn find_symbols(
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).
#[command(trust = always)]
/// 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>> {
// At most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
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
}
#[command(trust = always)]
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
host.project(window)?.index.mark_recent(&path);
Ok(())
}
#[command(trust = always)]
pub fn remove_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
host.project(window)?.index.remove_recent(&path);
Ok(())
}
/// Recently opened files, most recent first (⌘E).
#[command(trust = always)]
pub fn recent_files(host: &Host, window: &str) -> IdeResult<Vec<ide_core::IpcPath>> {
Ok(host.project(window)?.index.recent_files().into_iter().map(Into::into).collect())
}
/// The web reference at `pos` of `doc` and its targets; `None` when there is no reference.
#[command(trust = always)]
pub async fn web_goto(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Option<WebGoto>> {
let project = host.project(window)?;
let syntax = host.syntax();
@@ -157,14 +145,12 @@ pub async fn web_goto(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeRes
.await
}
/// The file a Python import path (`a.b.c`, or `.x` relative to `from`) names; `None` when
/// no project or content root has it.
#[command(trust = always)]
/// The file a Python import path names: `a.b.c` is `a/b/c.py(i)` or `a/b/c/__init__.py(i)`
/// in the project or one of its content roots (an attached dependency project included);
/// `.x` names it relative to `from`'s directory. Neither the language server (it analyses a
/// single root) nor the definition index resolves a package segment, so ⌘B on the `a.b` of
/// `from a.b import x` needs this.
pub async fn nav_resolve_module(host: &Host, window: &str, name: String, from: IpcPath) -> IdeResult<Option<IpcPath>> {
// `a.b.c` is `a/b/c.py(i)` or `a/b/c/__init__.py(i)` in the project or one of its content roots
// (an attached dependency project included). Neither the language server (it analyses a single
// root) nor the definition index resolves a package segment, so ⌘B on the `a.b` of
// `from a.b import x` needs this.
let project = host.project(window)?;
blocking(move || {
let dots = name.len() - name.trim_start_matches('.').len();
@@ -196,19 +182,17 @@ pub async fn nav_resolve_module(host: &Host, window: &str, name: String, from: I
.await
}
/// Index definitions named `name` within the roots `from` may navigate into (its own root
/// plus its configured dependencies).
#[command(trust = always)]
/// Index definitions named `name` in the other roots `from` may navigate into (its configured
/// dependencies and extra content roots — see `navigation_roots`): the cross-root answer when
/// the language server cannot resolve an import into an attached dependency project. `from`'s
/// own root is left out: the server sees it, so a name it could not resolve there is not
/// answered by every declaration that happens to share it (any `save` for `repo.save()`).
pub async fn nav_index_definitions(
host: &Host,
window: &str,
name: String,
from: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
// The cross-root answer when the language server cannot resolve an import into an attached
// dependency project. `from`'s own root is left out: the server sees it, so a name it could
// not resolve there is not answered by every declaration that happens to share it (any `save`
// for `repo.save()`).
let project = host.project(window)?;
blocking(move || {
let roots = crate::project::navigation_roots(&project, &from);
@@ -223,12 +207,11 @@ pub async fn nav_index_definitions(
.await
}
/// Every Python class in the project (attached dependency roots included) and its base names,
/// for native inheritance gutter markers.
#[command(trust = always)]
/// Every Python class in the project (attached dependency roots included) and its base
/// names, answered from the project index: its symbols already carry the bases, and it
/// covers content roots, so this is the whole-project answer the UI uses for inheritance
/// gutter markers when no type-hierarchy provider exists. No file is parsed here.
pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassInheritance>> {
// The index covers content roots, so this is the whole-project answer when no type-hierarchy
// provider exists.
let project = host.project(window)?;
let syntax = host.syntax();
blocking(move || {
@@ -301,7 +284,6 @@ static CLASS_BASES: std::sync::LazyLock<parking_lot::Mutex<ClassBasesCache>> =
std::sync::LazyLock::new(Default::default);
/// The existing file or directory a path written in `from` names (`href`, `url()`, a string literal).
#[command(trust = always)]
pub async fn fs_resolve_reference(
host: &Host,
window: &str,
@@ -318,7 +300,6 @@ pub async fn fs_resolve_reference(
}
/// Files and folders that continue `prefix`, a path being typed in `from`.
#[command(trust = always)]
pub async fn path_completions(
host: &Host,
window: &str,
@@ -335,7 +316,6 @@ pub async fn path_completions(
}
/// Paths in an HTML document or stylesheet that name no existing file.
#[command(trust = always)]
pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FileReference>> {
let project = host.project(window)?;
let syntax = host.syntax();
@@ -358,23 +338,37 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
.await
}
ide_command::domain!(
nav:
find_dirs,
find_files,
find_files_named,
find_symbols,
find_symbols_named,
fs_resolve_reference,
index_file_extensions,
index_status,
mark_recent,
nav_index_definitions,
nav_inheritance,
nav_resolve_module,
path_completions,
recent_files,
remove_recent,
web_goto,
web_unresolved_references,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_files_named", |c| async move { find_files_named(&c.host, &c.window, c.arg("name")?).await });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_symbols", |c| async move {
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?).await
});
d.add("find_symbols_named", |c| async move {
find_symbols_named(&c.host, &c.window, c.arg("names")?, c.arg("within")?).await
});
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")?) });
d.add("recent_files", |c| async move { recent_files(&c.host, &c.window) });
d.add("web_goto", |c| async move { web_goto(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await });
d.add("nav_resolve_module", |c| async move {
nav_resolve_module(&c.host, &c.window, c.arg("name")?, c.arg("from")?).await
});
d.add("nav_index_definitions", |c| async move {
nav_index_definitions(&c.host, &c.window, c.arg("name")?, c.arg("from")?).await
});
d.add("nav_inheritance", |c| async move { nav_inheritance(&c.host, &c.window).await });
d.add("fs_resolve_reference", |c| async move {
fs_resolve_reference(&c.host, &c.window, c.arg("from")?, c.arg("value")?).await
});
d.add("path_completions", |c| async move {
path_completions(&c.host, &c.window, c.arg("from")?, c.arg("prefix")?).await
});
d.add("web_unresolved_references", |c| async move {
web_unresolved_references(&c.host, &c.window, c.arg("doc")?).await
});
}
+41 -41
Переглянути файл
@@ -2,13 +2,12 @@
use crate::Host;
pub use crate::notebook::NotebookOutputEvent;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_notebook::{NotebookEdit, NotebookSnapshot};
use std::path::PathBuf;
#[command(trust = always)]
pub async fn notebook_open(host: &Host, window: &str, path: String) -> IdeResult<NotebookSnapshot> {
pub async fn open(host: &Host, window: &str, path: String) -> IdeResult<NotebookSnapshot> {
let project = host.project(window)?;
let path = PathBuf::from(path);
let path = if path.is_absolute() { path } else { project.root.join(path) };
@@ -16,21 +15,18 @@ pub async fn notebook_open(host: &Host, window: &str, path: String) -> IdeResult
host.blocking(move || notebooks.open(&path)).await
}
#[command(trust = always)]
pub fn notebook_get(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
pub fn get(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
host.project(window)?.notebooks.get(&id)
}
#[command(trust = trusted)]
pub fn notebook_cell_docs(host: &Host, window: &str, id: String) -> IdeResult<Vec<ide_lsp::NotebookCellDoc>> {
// The language-server documents of the notebook's code cells (empty when no server syncs notebooks).
/// The language-server documents of the notebook's code cells (empty when no server syncs notebooks).
pub fn cell_docs(host: &Host, window: &str, id: String) -> IdeResult<Vec<ide_lsp::NotebookCellDoc>> {
let project = host.project(window)?;
let path = project.notebooks.path_of(&id)?;
Ok(project.lsp.notebook_cells(&path))
}
#[command(trust = always)]
pub async fn notebook_edit(
pub async fn edit(
host: &Host,
window: &str,
id: String,
@@ -41,26 +37,22 @@ pub async fn notebook_edit(
host.blocking(move || notebooks.edit(&id, version, edit)).await
}
#[command(trust = always)]
pub async fn notebook_save(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
pub async fn save(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
host.blocking(move || notebooks.save(&id)).await
}
#[command(trust = always)]
pub async fn notebook_undo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
pub async fn undo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
host.blocking(move || notebooks.undo(&id, false)).await
}
#[command(trust = always)]
pub async fn notebook_redo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
pub async fn redo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
host.blocking(move || notebooks.undo(&id, true)).await
}
#[command(trust = always)]
pub async fn notebook_reload(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
pub async fn reload(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
// An abandoned IPC future must not leave a lifecycle transition half applied.
tokio::spawn(async move { notebooks.reload(&id, false).await })
@@ -68,8 +60,7 @@ pub async fn notebook_reload(host: &Host, window: &str, id: String) -> IdeResult
.map_err(|error| IdeError::internal(error.to_string()))?
}
#[command(trust = trusted)]
pub async fn notebook_restart(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
pub async fn restart(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
host.require_trust(window)?;
let notebooks = host.project(window)?.notebooks.clone();
tokio::spawn(async move { notebooks.reload(&id, true).await })
@@ -77,16 +68,14 @@ pub async fn notebook_restart(host: &Host, window: &str, id: String) -> IdeResul
.map_err(|error| IdeError::internal(error.to_string()))?
}
#[command(trust = always)]
pub async fn notebook_close(host: &Host, window: &str, id: String) -> IdeResult<()> {
pub async fn close(host: &Host, window: &str, id: String) -> IdeResult<()> {
let notebooks = host.project(window)?.notebooks.clone();
tokio::spawn(async move { notebooks.close(&id).await })
.await
.map_err(|error| IdeError::internal(error.to_string()))?
}
#[command(trust = always)]
pub async fn notebook_interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
pub async fn interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
let notebooks = host.project(window)?.notebooks.clone();
tokio::spawn(async move { notebooks.interrupt(&id).await })
.await
@@ -94,8 +83,7 @@ pub async fn notebook_interrupt(host: &Host, window: &str, id: String) -> IdeRes
}
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn notebook_execute(
pub async fn execute(
host: &Host,
window: &str,
id: String,
@@ -148,18 +136,30 @@ impl Drop for RequestGuard<'_> {
}
}
ide_command::domain!(
notebook:
notebook_cell_docs,
notebook_close,
notebook_edit,
notebook_execute,
notebook_get,
notebook_interrupt,
notebook_open,
notebook_redo,
notebook_reload,
notebook_restart,
notebook_save,
notebook_undo,
);
pub(crate) fn register(d: &mut Dispatcher) {
d.add("notebook_open", |c| async move { open(&c.host, &c.window, c.arg("path")?).await });
d.add("notebook_get", |c| async move { get(&c.host, &c.window, c.arg("id")?) });
d.add("notebook_cell_docs", |c| async move { cell_docs(&c.host, &c.window, c.arg("id")?) });
d.add("notebook_edit", |c| async move {
edit(&c.host, &c.window, c.arg("id")?, c.arg("version")?, c.arg("edit")?).await
});
d.add("notebook_save", |c| async move { save(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_reload", |c| async move { reload(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_undo", |c| async move { undo(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_redo", |c| async move { redo(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_close", |c| async move { close(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_interrupt", |c| async move { interrupt(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_restart", |c| async move { restart(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_execute", |c| async move {
execute(
&c.host,
&c.window,
c.arg("id")?,
c.arg("cells")?,
c.arg("python")?,
c.arg("request")?,
c.sender("onOutput")?,
)
.await
});
}
+8 -98
Переглянути файл
@@ -1,11 +1,10 @@
use crate::{Host, Project};
use ide_command::command;
use ide_core::IdeResult;
use ide_core::settings::Settings;
use ide_core::{IdeEvent, IdeResult, RequestId, TaskId};
use ide_workspace::settings::SettingsScope;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::{Path, PathBuf};
use std::path::Path;
use std::sync::Arc;
#[derive(Serialize, Deserialize, Type)]
@@ -54,36 +53,20 @@ pub async fn open(host: &Arc<Host>, window: &str, path: &Path) -> IdeResult<Arc<
host.blocking(move || h.open_project(&window, &path)).await
}
#[command(trust = always, desktop_body = async)]
pub async fn open_project(host: &Arc<Host>, window: &str, path: PathBuf) -> IdeResult<ProjectInfo> {
let project = open(host, window, &path).await?;
Ok(info(&project))
}
/// The project open in this window (a settings window: its parent's), if any.
#[command(trust = always, desktop_body = sync)]
pub fn project_current(host: &Host, window: &str) -> Option<ProjectInfo> {
pub fn current(host: &Host, window: &str) -> Option<ProjectInfo> {
host.project(window).ok().filter(|p| !p.light).map(|p| info(&p))
}
#[command(trust = always, desktop_body = spawn)]
pub fn close_project(host: &Host, window: &str) {
host.close_project(window);
}
/// Effective settings for the window's project, or global settings without one.
#[command(trust = always, desktop_body = sync)]
pub fn settings_get(host: &Host, window: &str) -> Settings {
pub fn settings(host: &Host, window: &str) -> Settings {
host.with_proxy_password(match host.project(window) {
Ok(p) => p.settings.effective(),
Err(_) => host.global_settings.effective(),
})
}
/// The removed built-in theme id a settings file of this window still names, if any:
/// `settings_get` reports the built-in that stands in for it, so the notice about
/// a theme that moved to a plugin can address the installs it concerns.
#[command(trust = always, desktop_body = sync)]
/// The removed built-in theme a settings file of this window still names, if any
/// (`settings` reports its stand-in): the "provided by a plugin now" notice targets these.
pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
match host.project(window) {
Ok(p) => p.settings.named_removed_theme().or_else(|| host.global_settings.named_removed_theme()),
@@ -91,66 +74,10 @@ pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
}
}
/// `value` is JSON text, e.g. `14` or `"dark"`. Every window (for a project
/// value: that project's windows) is told (`IdeEvent::SettingsChanged`) so it
/// re-reads its effective settings.
#[command(trust = always, desktop_body = sync)]
pub fn settings_set(
host: &Host,
window: &str,
scope: SettingsScope,
key: String,
value: String,
) -> IdeResult<Settings> {
let applied = set_settings(host, window, scope, &key, &value)?;
let sink = host.window_sink(window);
sink.emit(IdeEvent::SettingsChanged { key });
if let Some(root) = applied.roots_changed {
sink.emit(IdeEvent::ProjectRootsChanged { root });
}
Ok(applied.settings)
}
/// Effective source / test / resource / excluded roots of the window's project:
/// auto-detected from build files, overridden by Settings › Project Structure.
#[command(trust = always)]
pub fn project_roots(host: &Host, window: &str) -> IdeResult<ide_workspace::ProjectRoots> {
pub fn roots(host: &Host, window: &str) -> IdeResult<ide_workspace::ProjectRoots> {
Ok(host.project(window)?.roots())
}
#[command(trust = always)]
pub fn cancel_request(host: &Host, id: RequestId) {
host.cancel_request(id);
}
/// Stops a background task the backend reported with `cancellable` set; false when it
/// has ended or can't be cancelled.
#[command(trust = always)]
pub fn cancel_task(id: TaskId) -> bool {
ide_core::task::cancel(id)
}
#[command(trust = always)]
pub fn project_trust_status(host: &Host, path: PathBuf) -> IdeResult<crate::trust::TrustStatus> {
host.trust.status(&path)
}
#[command(trust = always)]
pub fn project_trust_list(host: &Host) -> IdeResult<crate::trust::TrustDecisions> {
host.trust.decisions()
}
#[command(trust = always, desktop_body = async)]
pub async fn project_trust_set(host: &Host, path: PathBuf, trusted: bool, folder: bool) -> IdeResult<()> {
host.set_project_trust(&path, trusted, folder).await
}
#[command(trust = always, desktop_body = async)]
pub async fn project_trust_remove_location(host: &Host, path: PathBuf) -> IdeResult<()> {
host.trust.remove_location(&path)?;
host.refresh_project_trust().await
}
pub fn save_workspace(host: &Host, window: &str, name: &str, paths: Vec<std::path::PathBuf>) -> IdeResult<ProjectInfo> {
let project = host.project(window)?;
let previous = ide_workspace::workspace::Workspace::load(&project.root)?
@@ -248,7 +175,7 @@ pub fn set_settings(
let is_proxy = key == "proxy" || key.starts_with("proxy.");
let Some(mut value) = host.take_proxy_password(key, value)? else {
host.apply_proxy();
return Ok(SettingsApplied { settings: settings_get(host, window), project_scope, roots_changed: None });
return Ok(SettingsApplied { settings: settings(host, window), project_scope, roots_changed: None });
};
// One canonical spelling per linked POM, including a project outside the opened root.
if project_scope
@@ -363,20 +290,3 @@ pub fn set_settings(
let roots_changed = current.as_ref().filter(|_| roots_changed && project_scope).map(|p| p.root.clone().into());
Ok(SettingsApplied { settings: host.with_proxy_password(settings), project_scope, roots_changed })
}
ide_command::domain!(
project:
cancel_request,
cancel_task,
close_project,
open_project,
project_current,
project_roots,
project_trust_list,
project_trust_remove_location,
project_trust_set,
project_trust_status,
settings_get,
settings_removed_theme,
settings_set,
);
+21 -14
Переглянути файл
@@ -1,7 +1,7 @@
//! File move / rename refactoring: reference updates from the language
//! servers, the move itself (one undoable step) and its undo.
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeResult, RequestId, WorkspaceEdit};
use ide_lsp::types::FileRenameEdits;
@@ -15,7 +15,6 @@ fn pairs(moves: &[FileMove]) -> Vec<(PathBuf, PathBuf)> {
}
/// `workspace/willRenameFiles` on every interested server (before the move). Cancellable.
#[command(trust = always)]
pub async fn refactor_file_move_edits(
host: &Host,
window: &str,
@@ -36,7 +35,6 @@ pub async fn refactor_file_move_edits(
/// Applies `edit` (from [`refactor_file_move_edits`], possibly empty), moves the
/// files and notifies the servers. Returns the id for [`refactor_undo_file_move`].
#[command(trust = always)]
pub async fn refactor_move_files(
host: &Host,
window: &str,
@@ -57,7 +55,6 @@ pub async fn refactor_move_files(
}
/// Undoes a file move: moves back and reverts the reference updates.
#[command(trust = always)]
pub async fn refactor_undo_file_move(host: &Host, window: &str, id: u32) -> IdeResult<UndoOutcome> {
let project = host.project(window)?;
let p = project.clone();
@@ -67,14 +64,12 @@ pub async fn refactor_undo_file_move(host: &Host, window: &str, id: u32) -> IdeR
}
/// Whether the file move `id` can still be undone.
#[command(trust = always)]
pub fn refactor_can_undo_file_move(host: &Host, window: &str, id: u32) -> IdeResult<bool> {
Ok(host.project(window)?.moves.can_undo(id))
}
/// "Search in comments and strings": textual occurrences of the moved files'
/// names, qualified names and paths (before the move). Cancellable.
#[command(trust = always)]
pub async fn refactor_file_move_text_edits(
host: &Host,
window: &str,
@@ -103,11 +98,23 @@ pub async fn refactor_file_move_text_edits(
result
}
ide_command::domain!(
refactor:
refactor_can_undo_file_move,
refactor_file_move_edits,
refactor_file_move_text_edits,
refactor_move_files,
refactor_undo_file_move,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("refactor_file_move_edits", |c| async move {
refactor_file_move_edits(&c.host, &c.window, c.arg("request")?, c.arg("moves")?).await
});
d.add("refactor_move_files", |c| async move {
refactor_move_files(&c.host, &c.window, c.arg("moves")?, c.arg("edit")?, c.arg("label")?).await
});
d.add(
"refactor_undo_file_move",
|c| async move { refactor_undo_file_move(&c.host, &c.window, c.arg("id")?).await },
);
d.add(
"refactor_can_undo_file_move",
|c| async move { refactor_can_undo_file_move(&c.host, &c.window, c.arg("id")?) },
);
d.add("refactor_file_move_text_edits", |c| async move {
refactor_file_move_text_edits(&c.host, &c.window, c.arg("request")?, c.arg("moves")?).await
});
}
+20 -77
Переглянути файл
@@ -1,33 +1,11 @@
use super::{Channel, Emit};
use super::Emit;
use crate::Host;
use ide_command::command;
use ide_core::remote_settings::RunTargetKind;
use ide_core::{IdeError, IdeResult, RunId};
use ide_run::{OutputChunk, RunConfig, RunInfo, StartOptions};
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;
/// Detected configs followed by user-defined ones (user ids win on conflict).
#[command(trust = trusted)]
pub async fn run_configs(host: &Arc<Host>, window: &str) -> IdeResult<Vec<RunConfig>> {
// Detection reads build files (and Spring Boot sources): off the command thread.
let (host, window) = (host.clone(), window.to_owned());
super::doc::blocking(move || configs(&host, &window)).await
}
#[command(trust = trusted)]
pub async fn run_save_configs(
host: &Arc<Host>,
window: &str,
configs: Vec<RunConfig>,
removed_detected_ids: Option<Vec<String>>,
) -> IdeResult<()> {
let (host, window) = (host.clone(), window.to_owned());
let removed = removed_detected_ids.unwrap_or_default();
super::doc::blocking(move || save_configs(&host, &window, &configs, &removed)).await
}
/// Detected configs followed by user-defined ones (user ids win on conflict).
pub fn configs(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
host.require_trust(window)?;
@@ -205,16 +183,9 @@ fn settings_only(
})
}
/// Temporary configurations as they are kept between sessions: without what settings derived.
#[command(trust = trusted)]
pub async fn run_without_derived(host: &Arc<Host>, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
let (host, window) = (host.clone(), window.to_owned());
super::doc::blocking(move || without_derived(&host, &window, configs)).await
}
/// Without what settings derived (toolchain commands, Maven options, `JAVA_HOME`…), so they
/// follow later settings changes.
fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
/// Temporary configurations as they are kept between sessions: without what settings derived
/// (toolchain commands, Maven options, `JAVA_HOME`…), so they follow later settings changes.
pub fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
host.require_trust(window)?;
let project = host.project(window)?;
configs
@@ -229,15 +200,8 @@ fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeRes
.collect()
}
/// Kept temporary configurations with the current settings applied.
#[command(trust = trusted)]
pub async fn run_apply_settings(host: &Arc<Host>, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
let (host, window) = (host.clone(), window.to_owned());
super::doc::blocking(move || apply_settings(&host, &window, configs)).await
}
/// Today's settings applied, as [`configs`] lists the others.
fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
/// Kept temporary configurations with today's settings applied, as [`configs`] lists the others.
pub fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
host.require_trust(window)?;
let project = host.project(window)?;
configs
@@ -257,17 +221,17 @@ fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResu
.collect()
}
#[command(trust = trusted)]
pub async fn run_start(
pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit<OutputChunk>) -> IdeResult<RunInfo> {
start_request(host, window, config, on_output, None).await
}
pub async fn start_request(
host: &Host,
window: &str,
config: RunConfig,
on_output: Channel<OutputChunk>,
on_output: Emit<OutputChunk>,
request: Option<ide_core::RequestId>,
) -> IdeResult<RunInfo> {
let on_output: Emit<OutputChunk> = Arc::new(move |chunk| {
let _ = on_output.send(chunk);
});
let cancel = request.map(|id| host.begin_request(id)).unwrap_or_default();
let operation = config.extras.params.get("plugin.operation").cloned();
let mut config = config;
@@ -522,9 +486,8 @@ fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathB
}
}
#[command(trust = always)]
pub fn run_stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
// Interrupt, then kill after Settings › Run's termination timeout.
/// Stops a run (interrupt, then kill after Settings › Run's termination timeout).
pub fn stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
if let Some(plugins) = host.plugin_host() {
plugins.run_operation_stopped(id);
}
@@ -540,10 +503,8 @@ pub fn run_stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
host.processes.stop_with_grace(id, grace)
}
#[command(trust = trusted)]
pub fn run_stdin(host: &Host, id: RunId, data: String) -> IdeResult<()> {
// Input the user typed into a run (the agent's goes to the process directly).
let data = data.as_str();
/// Input the user typed into a run (the agent's goes to the process directly).
pub fn stdin(host: &Host, id: RunId, data: &str) -> IdeResult<()> {
host.mcp_agent_runs.user_input(id, data);
if host.remote.runs.contains(id) {
return host.remote.runs.write_stdin(id, data);
@@ -551,31 +512,27 @@ pub fn run_stdin(host: &Host, id: RunId, data: String) -> IdeResult<()> {
host.processes.write_stdin(id, data)
}
/// Terminal size of a run started with "Emulate terminal in output console".
#[command(trust = trusted)]
pub fn run_resize(host: &Host, id: RunId, cols: u16, rows: u16) -> IdeResult<()> {
pub fn resize(host: &Host, id: RunId, cols: u16, rows: u16) -> IdeResult<()> {
if host.remote.runs.contains(id) {
return host.remote.runs.resize(id, cols, rows);
}
host.processes.resize(id, cols, rows)
}
#[command(trust = trusted)]
pub fn run_close_stdin(host: &Host, id: RunId) -> IdeResult<()> {
pub fn close_stdin(host: &Host, id: RunId) -> IdeResult<()> {
if host.remote.runs.contains(id) {
return host.remote.runs.close_stdin(id);
}
host.processes.close_stdin(id)
}
#[command(trust = always)]
pub fn run_list(host: &Host) -> Vec<RunInfo> {
pub fn list(host: &Host) -> Vec<RunInfo> {
let mut runs = host.processes.list();
runs.extend(host.remote.runs.list());
runs
}
pub mod commands;
mod commands;
pub(crate) mod container;
pub use commands::*;
@@ -606,17 +563,3 @@ mod ownership_tests {
assert!(configs.is_empty(), "{configs:?}");
}
}
ide_command::domain!(
run:
run_apply_settings,
run_close_stdin,
run_configs,
run_list,
run_resize,
run_save_configs,
run_start,
run_stdin,
run_stop,
run_without_derived,
);
+78 -68
Переглянути файл
@@ -1,10 +1,11 @@
#[allow(unused_imports)]
use super::*;
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult};
use ide_run::RunConfig;
use ide_run::import::{RunImport, RunImportSource};
#[command(trust = trusted)]
pub async fn run_dotnet_resolve(host: &Host, window: &str, config: RunConfig, debug: bool) -> IdeResult<RunConfig> {
host.require_trust(window)?;
if !matches!(config.kind.as_str(), "dotnet" | "dotnet-test")
@@ -29,7 +30,6 @@ fn application_cache(project: &crate::project::Project, id: &str) -> std::path::
project.cache_dir.join("application-update").join(format!("{:x}", hash.finish()))
}
#[command(trust = trusted)]
pub async fn run_application_build(
host: &Host,
window: &str,
@@ -74,7 +74,6 @@ pub async fn run_application_build(
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub async fn run_application_publish(
host: &Host,
window: &str,
@@ -97,61 +96,54 @@ pub async fn run_application_publish(
}
/// Configuration templates: per-type defaults applied to new configurations.
#[command(trust = trusted)]
pub async fn run_templates(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
pub fn run_templates(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
let root = host.project(window)?.root.clone();
crate::ops::doc::blocking(move || ide_run::load_templates(&root)).await
ide_run::load_templates(&root)
}
#[command(trust = trusted)]
pub async fn run_save_templates(host: &Host, window: &str, templates: Vec<RunConfig>) -> IdeResult<()> {
pub fn run_save_templates(host: &Host, window: &str, templates: Vec<RunConfig>) -> IdeResult<()> {
let root = host.project(window)?.root.clone();
crate::ops::doc::blocking(move || ide_run::save_templates(&root, &templates)).await
ide_run::save_templates(&root, &templates)
}
/// Project files run configurations can be imported from (`.vscode/launch.json`).
#[command(trust = trusted)]
pub async fn run_import_sources(host: &Host, window: &str) -> IdeResult<Vec<RunImportSource>> {
pub fn run_import_sources(host: &Host, window: &str) -> IdeResult<Vec<RunImportSource>> {
let root = host.project(window)?.root.clone();
crate::ops::doc::blocking(move || Ok(ide_run::import::available(&root))).await
Ok(ide_run::import::available(&root))
}
/// Configurations read from `source`, not saved; names already in `existing` are skipped.
#[command(trust = trusted)]
pub async fn run_import_configs(
/// Configurations read from `source`, not saved; names already in `existing` (the
/// configurations being edited) are skipped.
pub fn run_import_configs(
host: &Host,
window: &str,
source: RunImportSource,
existing: Vec<RunConfig>,
) -> IdeResult<RunImport> {
// `existing`: the configurations being edited.
host.require_trust(window)?;
let root = host.project(window)?.root.clone();
crate::ops::doc::blocking(move || ide_run::import_configs(&root, source, &existing)).await
ide_run::import_configs(&root, source, &existing)
}
/// The environment runs inherit when "Include system environment variables" is on.
#[command(trust = always)]
pub fn run_system_env() -> std::collections::BTreeMap<String, String> {
pub fn run_system_env(_host: &Host, _window: &str) -> std::collections::BTreeMap<String, String> {
ide_run::system_env()
}
/// Variables of the `.env` files a debug launch names, for the debugger to start with.
#[command(trust = trusted)]
pub async fn run_env_files(files: Vec<std::path::PathBuf>) -> IdeResult<std::collections::BTreeMap<String, String>> {
// In order (later files win): the same files a run loads, over the system environment
// debug adapters inherit.
crate::ops::doc::blocking(move || {
ide_run::envfile::load(&files, &ide_run::system_env())
.map_err(|e| IdeError::not_found(format!("cannot read .env file: {e}")))
})
.await
/// Variables of the `.env` files a debug launch names, in order (later files win):
/// the same files a run loads, over the system environment debug adapters inherit.
pub fn run_env_files(
_host: &Host,
_window: &str,
files: Vec<std::path::PathBuf>,
) -> IdeResult<std::collections::BTreeMap<String, String>> {
ide_run::envfile::load(&files, &ide_run::system_env())
.map_err(|e| IdeError::not_found(format!("cannot read .env file: {e}")))
}
/// Writes the Gradle init script adding `jvm_args` to the JVMs the build forks; returns its path.
#[command(trust = always)]
pub async fn run_gradle_jvm_args_script(jvm_args: Vec<String>) -> IdeResult<String> {
// The forked JVMs: `bootRun`, `run`, tests; the path is for `--init-script`.
/// Writes the Gradle init script that adds `jvm_args` to the JVMs the build forks
/// (`bootRun`, `run`, tests) and returns its path, for `--init-script`.
pub async fn run_gradle_jvm_args_script(_host: &Host, _window: &str, jvm_args: Vec<String>) -> IdeResult<String> {
tokio::task::spawn_blocking(move || {
ide_run::gradle_jvm::write_init_script(&ide_run::gradle_jvm::default_dir(), &jvm_args)
.map(|p| p.to_string_lossy().into_owned())
@@ -161,10 +153,9 @@ pub async fn run_gradle_jvm_args_script(jvm_args: Vec<String>) -> IdeResult<Stri
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Writes one of the IDE's Gradle init scripts where the build runs; returns its path.
#[command(trust = trusted)]
pub async fn run_gradle_init_script(name: String, text: String) -> IdeResult<String> {
// `text`; the file is named `<name>-<hash>`, for `--init-script`.
/// Writes one of the IDE's Gradle init scripts (`text`; the file is named `<name>-<hash>`) on
/// the machine that runs the build, for `--init-script`, and returns its path.
pub async fn run_gradle_init_script(_host: &Host, _window: &str, name: String, text: String) -> IdeResult<String> {
if name.is_empty() || !name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') {
return Err(IdeError::invalid(format!("invalid init script name {name:?}")));
}
@@ -179,7 +170,6 @@ pub async fn run_gradle_init_script(name: String, text: String) -> IdeResult<Str
/// Results from the JUnit XML reports (Surefire, Failsafe, Gradle) of the module at
/// `module` (relative to the project root) written since `since_ms` (Unix epoch, ms).
#[command(trust = trusted)]
pub async fn run_test_reports(
host: &Host,
window: &str,
@@ -194,7 +184,6 @@ pub async fn run_test_reports(
.map_err(|e| IdeError::internal(e.to_string()))
}
#[command(trust = trusted)]
pub async fn run_tomcat_home(host: &Host, window: &str, home: String) -> IdeResult<ide_run::tomcat::TomcatHome> {
host.require_trust(window)?;
let root = host.project(window)?.root.clone();
@@ -203,7 +192,6 @@ pub async fn run_tomcat_home(host: &Host, window: &str, home: String) -> IdeResu
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub async fn run_tomcat_installations(
host: &Host,
window: &str,
@@ -280,7 +268,6 @@ fn build_project_war(
Ok(())
}
#[command(trust = trusted)]
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)?;
@@ -300,7 +287,6 @@ pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<id
.map_err(|e| IdeError::internal(e.to_string()))
}
#[command(trust = trusted)]
pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> IdeResult<Option<RunConfig>> {
host.require_trust(window)?;
if config.extras.params.get("deployment").is_some_and(|v| v != "artifact") {
@@ -369,7 +355,6 @@ pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> I
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mode: String) -> IdeResult<()> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -381,7 +366,8 @@ pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mod
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
/// Updates a running Tomcat artifact deployment from the module's compiled output and web
/// resources (`ide_run::tomcat::sync_outputs`). `false`: rebuild the WAR instead.
pub async fn run_tomcat_sync(
host: &Host,
window: &str,
@@ -390,8 +376,6 @@ pub async fn run_tomcat_sync(
class_paths: Vec<String>,
resources_only: bool,
) -> IdeResult<bool> {
// Updates a running Tomcat artifact deployment from the module's compiled output and web
// resources (`ide_run::tomcat::sync_outputs`). `false`: rebuild the WAR instead.
host.require_trust(window)?;
let project = host.project(window)?;
if !host.processes.list().iter().any(|r| r.running && r.config_id == config.id) {
@@ -411,24 +395,50 @@ pub async fn run_tomcat_sync(
.map_err(|e| IdeError::internal(e.to_string()))?
}
ide_command::domain!(
run_commands:
run_application_build,
run_application_publish,
run_dotnet_resolve,
run_env_files,
run_gradle_init_script,
run_gradle_jvm_args_script,
run_import_configs,
run_import_sources,
run_save_templates,
run_system_env,
run_templates,
run_test_reports,
run_tomcat_artifacts,
run_tomcat_build,
run_tomcat_home,
run_tomcat_installations,
run_tomcat_sync,
run_tomcat_update,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("run_dotnet_resolve", |c| async move {
run_dotnet_resolve(&c.host, &c.window, c.arg("config")?, c.arg("debug")?).await
});
d.add("run_application_build", |c| async move {
run_application_build(&c.host, &c.window, c.arg("config")?, c.arg("module")?).await
});
d.add("run_application_publish", |c| async move {
run_application_publish(&c.host, &c.window, c.arg("config")?, c.arg("classPaths")?, c.arg("mainClass")?).await
});
d.add("run_tomcat_home", |c| async move { run_tomcat_home(&c.host, &c.window, c.arg("home")?).await });
d.add("run_tomcat_installations", |c| async move { run_tomcat_installations(&c.host, &c.window).await });
d.add("run_tomcat_artifacts", |c| async move { run_tomcat_artifacts(&c.host, &c.window).await });
d.add("run_tomcat_build", |c| async move { run_tomcat_build(&c.host, &c.window, c.arg("config")?).await });
d.add("run_tomcat_sync", |c| async move {
run_tomcat_sync(
&c.host,
&c.window,
c.arg("config")?,
c.arg("module")?,
c.arg("classPaths")?,
c.arg("resourcesOnly")?,
)
.await
});
d.add("run_tomcat_update", |c| async move {
run_tomcat_update(&c.host, &c.window, c.arg("config")?, c.arg("mode")?).await
});
d.add("run_templates", |c| async move { run_templates(&c.host, &c.window) });
d.add("run_save_templates", |c| async move { run_save_templates(&c.host, &c.window, c.arg("templates")?) });
d.add("run_import_sources", |c| async move { run_import_sources(&c.host, &c.window) });
d.add("run_import_configs", |c| async move {
run_import_configs(&c.host, &c.window, c.arg("source")?, c.arg("existing")?)
});
d.add("run_system_env", |c| async move { Ok(run_system_env(&c.host, &c.window)) });
d.add("run_env_files", |c| async move { run_env_files(&c.host, &c.window, c.arg("files")?) });
d.add("run_gradle_jvm_args_script", |c| async move {
run_gradle_jvm_args_script(&c.host, &c.window, c.arg("jvmArgs")?).await
});
d.add("run_gradle_init_script", |c| async move {
run_gradle_init_script(&c.host, &c.window, c.arg("name")?, c.arg("text")?).await
});
d.add("run_test_reports", |c| async move {
run_test_reports(&c.host, &c.window, c.arg("module")?, c.arg("sinceMs")?).await
});
}
+29 -21
Переглянути файл
@@ -1,8 +1,7 @@
//! File › New Project (`ide-scaffold`). Its commands run in Restricted Mode: New Project writes
//! only where the user chose and runs no code of an open project.
//! File › New Project (`ide-scaffold`).
use crate::Host;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_scaffold::{CreateRequest, Field, GeneratorInfo, Requirement, ScaffoldEvent, Values};
@@ -12,21 +11,20 @@ fn join_err(e: impl std::fmt::Display) -> IdeError {
}
/// The project generators File › New Project offers, in list order.
#[command(trust = always)]
pub fn scaffold_catalog() -> Vec<GeneratorInfo> {
pub fn scaffold_catalog(_host: &Host, _window: &str) -> Vec<GeneratorInfo> {
ide_scaffold::catalog()
}
/// The fields a generator's project service adds for `values`; cancellable with
/// The fields a generator's project service adds for `values` (Spring Initializr's
/// Boot versions and dependencies…); empty for other generators. Cancellable with
/// `cancel_request(request)`.
#[command(trust = always)]
pub async fn scaffold_options(
host: &Host,
_window: &str,
generator: String,
values: Values,
request: RequestId,
) -> IdeResult<Vec<Field>> {
// Spring Initializr's Boot versions and dependencies…; empty for other generators.
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || ide_scaffold::options(&generator, &values, &cancel))
.await
@@ -36,21 +34,25 @@ pub async fn scaffold_options(
}
/// The programs a generator needs for `values`, and whether they are installed.
#[command(trust = always)]
pub async fn scaffold_requirements(generator: String, values: Values) -> IdeResult<Vec<Requirement>> {
pub async fn scaffold_requirements(
_host: &Host,
_window: &str,
generator: String,
values: Values,
) -> IdeResult<Vec<Requirement>> {
tokio::task::spawn_blocking(move || ide_scaffold::requirements(&generator, &values)).await.map_err(join_err)?
}
/// Creates a project, streaming progress through `on_event`, and returns its directory,
/// trusted. Cancellable with `cancel_request(request)`; a failed or cancelled run leaves nothing.
#[command(trust = always)]
/// Creates a project, streaming its steps and tool output through `on_event`, and
/// returns its directory, trusted: the user just created it. Cancellable with
/// `cancel_request(request)`; a failed or cancelled run leaves no files behind.
pub async fn scaffold_create(
host: &Host,
_window: &str,
req: CreateRequest,
request: RequestId,
on_event: Channel<ScaffoldEvent>,
) -> IdeResult<IpcPath> {
// Trusted because the user just created it; a failed or cancelled run leaves no files behind.
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || {
ide_scaffold::create(&req, &cancel, &|e| {
@@ -65,10 +67,16 @@ pub async fn scaffold_create(
Ok(dir.into())
}
ide_command::domain!(
scaffold:
scaffold_catalog,
scaffold_create,
scaffold_options,
scaffold_requirements,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("scaffold_catalog", |c| async move { Ok(scaffold_catalog(&c.host, &c.window)) });
d.add("scaffold_options", |c| async move {
scaffold_options(&c.host, &c.window, c.arg("generator")?, c.arg("values")?, c.arg("request")?).await
});
d.add("scaffold_requirements", |c| async move {
scaffold_requirements(&c.host, &c.window, c.arg("generator")?, c.arg("values")?).await
});
d.add("scaffold_create", |c| async move {
scaffold_create(&c.host, &c.window, c.arg("req")?, c.arg("request")?, c.sender("onEvent")?).await
});
}
+68 -41
Переглянути файл
@@ -1,7 +1,7 @@
//! Interpreters / toolchains (`ide-sdk`): discovery, Python virtualenvs and packages.
use crate::Host;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_sdk::python::PythonPackage;
@@ -10,7 +10,7 @@ use std::path::PathBuf;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
pub mod container_python;
pub(crate) mod container_python;
pub use container_python::{ContainerPython, sdk_container_python, sdk_container_python_refresh};
fn join_err(e: impl std::fmt::Display) -> IdeError {
@@ -34,7 +34,6 @@ pub struct ProjectInterpreter {
}
/// Installed interpreters / toolchains of `kind`; project-local ones first.
#[command(trust = trusted)]
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
let project = host.project(window).ok();
@@ -62,10 +61,9 @@ pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<V
.map_err(join_err)
}
/// The Python interpreters of the recently opened projects, each with its project.
#[command(trust = trusted)]
/// The Python interpreters of the projects opened recently (newest first), each with the
/// project it belongs to. The open project is skipped: [`sdk_detect`] lists its own.
pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeResult<Vec<ProjectInterpreter>> {
// Newest first. The open project is skipped: `sdk_detect` lists its own.
host.require_trust(window)?;
let current = host.project(window).ok().map(|p| p.root.clone());
let config = host.config_dir.clone();
@@ -111,7 +109,6 @@ pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeRe
}
/// An existing Python executable or virtualenv folder as an SDK; `None` if Python cannot run.
#[command(trust = trusted)]
pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<Sdk>> {
host.require_trust(window)?;
let root = host.project(window).ok().map(|p| p.root.clone());
@@ -121,7 +118,6 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
}
/// The interpreter the project uses: the configured one, else its virtualenv.
#[command(trust = trusted)]
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -147,7 +143,6 @@ pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) ->
}
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
#[command(trust = trusted)]
pub fn sdk_php_effective(host: &Host, window: &str) -> IdeResult<Option<ide_core::IpcPath>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -157,7 +152,6 @@ pub fn sdk_php_effective(host: &Host, window: &str) -> IdeResult<Option<ide_core
/// The version of the PHP interpreter `php` and of the Xdebug it loads, run in `cwd` (default: the
/// project root).
#[command(trust = trusted)]
pub async fn sdk_php_xdebug(
host: &Host,
window: &str,
@@ -183,8 +177,6 @@ pub struct PhpLanguageLevels {
pub member: Option<ide_core::IpcPath>,
}
/// The PHP language level of the project `path` belongs to: the effective one and Auto's.
#[command(trust = trusted)]
pub async fn sdk_php_language_level(host: &Host, window: &str, path: PathBuf) -> IdeResult<PhpLanguageLevels> {
let project = host.project(window)?;
let (project_root, project_settings) = (project.root.clone(), project.settings.effective());
@@ -215,14 +207,12 @@ pub struct ComposerInstallState {
pub reason: ide_sdk::php::ComposerInstall,
}
/// The Composer project `path` belongs to, when its dependencies need `composer install`.
#[command(trust = trusted)]
/// `None` in an untrusted project too: `composer install` runs the project's scripts.
pub async fn sdk_php_composer_install(
host: &Host,
window: &str,
path: PathBuf,
) -> IdeResult<Option<ComposerInstallState>> {
// `None` in an untrusted project too: `composer install` runs the project's scripts.
let project = host.project(window)?;
if !project.is_trusted() {
return Ok(None);
@@ -238,7 +228,6 @@ pub async fn sdk_php_composer_install(
/// SDK / library source folders shown under "External Libraries" in the Project view,
/// with the Maven / Gradle dependency jars of the build model.
#[command(trust = trusted)]
pub async fn sdk_project_libraries(
host: &Host,
window: &str,
@@ -303,7 +292,6 @@ pub async fn sdk_project_libraries(
}
/// Looks up `names` (bare command names): `node_modules/.bin` above `near`, then the search path.
#[command(trust = trusted)]
pub async fn sdk_locate_tools(
host: &Host,
window: &str,
@@ -320,7 +308,6 @@ pub async fn sdk_locate_tools(
}
/// Creates a Python environment with `tool` (`venv` / `uv` / `poetry`); output streams through `on_output`.
#[command(trust = trusted)]
pub async fn sdk_python_create_venv(
host: &Host,
window: &str,
@@ -343,7 +330,6 @@ pub async fn sdk_python_create_venv(
result?
}
#[command(trust = trusted)]
pub async fn sdk_python_packages(
host: &Host,
window: &str,
@@ -360,7 +346,6 @@ pub async fn sdk_python_packages(
/// Installs (`uninstall = false`) or removes a package; output streams through `on_output`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn sdk_python_pip(
host: &Host,
window: &str,
@@ -390,10 +375,9 @@ pub async fn sdk_python_pip(
result?
}
/// The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home.
#[command(trust = trusted)]
/// The JDK whose home is `path` (a macOS bundle too), as the SDK list shows it; `None` when
/// `path` is no JDK home (Add JDK from Disk…).
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
// A macOS bundle too (Add JDK from Disk…).
tokio::task::spawn_blocking(move || {
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
})
@@ -401,6 +385,67 @@ pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
.map_err(join_err)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
d.add("sdk_jdk_at", |c| async move { sdk_jdk_at(c.arg("path")?).await });
d.add(
"sdk_python_project_interpreters",
|c| async move { sdk_python_project_interpreters(&c.host, &c.window).await },
);
d.add(
"sdk_python_interpreter",
|c| async move { sdk_python_interpreter(&c.host, &c.window, c.arg("path")?).await },
);
d.add("sdk_python_effective", |c| async move { sdk_python_effective(&c.host, &c.window, c.arg("near")?) });
d.add("sdk_php_effective", |c| async move { sdk_php_effective(&c.host, &c.window) });
d.add("sdk_container_python", |c| async move { sdk_container_python(&c.host, &c.window) });
d.add("sdk_container_python_refresh", |c| async move { sdk_container_python_refresh(&c.host, &c.window).await });
d.add("sdk_php_xdebug", |c| async move { sdk_php_xdebug(&c.host, &c.window, c.arg("php")?, c.arg("cwd")?).await });
d.add(
"sdk_php_language_level",
|c| async move { sdk_php_language_level(&c.host, &c.window, c.arg("path")?).await },
);
d.add(
"sdk_php_composer_install",
|c| async move { sdk_php_composer_install(&c.host, &c.window, c.arg("path")?).await },
);
d.add("sdk_project_libraries", |c| async move {
sdk_project_libraries(&c.host, &c.window, c.arg("request")?, c.sender("onGroups")?).await
});
d.add("sdk_locate_tools", |c| async move {
sdk_locate_tools(&c.host, &c.window, c.arg("names")?, c.arg("near")?).await
});
d.add("sdk_python_create_venv", |c| async move {
sdk_python_create_venv(
&c.host,
&c.window,
c.arg("tool")?,
c.arg("base")?,
c.arg("location")?,
c.arg("request")?,
c.sender("onOutput")?,
)
.await
});
d.add("sdk_python_packages", |c| async move {
sdk_python_packages(&c.host, &c.window, c.arg("python")?, c.arg("request")?).await
});
d.add("sdk_python_pip", |c| async move {
sdk_python_pip(
&c.host,
&c.window,
c.arg("python")?,
c.arg("requirement")?,
c.arg("uninstall")?,
c.arg("upgrade")?,
c.arg("request")?,
c.sender("onOutput")?,
)
.await
});
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
@@ -515,21 +560,3 @@ mod tests {
host.close_project("main");
}
}
ide_command::domain!(
sdk:
sdk_detect,
sdk_jdk_at,
sdk_locate_tools,
sdk_php_composer_install,
sdk_php_effective,
sdk_php_language_level,
sdk_php_xdebug,
sdk_project_libraries,
sdk_python_create_venv,
sdk_python_effective,
sdk_python_interpreter,
sdk_python_packages,
sdk_python_pip,
sdk_python_project_interpreters,
);
+3 -8
Переглянути файл
@@ -7,7 +7,6 @@
use crate::Host;
use crate::project::Project;
use ide_command::command;
use ide_core::event::NotifyLevel;
use ide_core::remote_settings::{RunTarget, RunTargetKind};
use ide_core::settings::Settings;
@@ -101,8 +100,7 @@ pub(crate) fn library_group(host: &Host, root: &Path, settings: &Settings) -> Op
snapshots::library_group(name, &dir, &snapshot)
}
/// The project interpreter when it is a Docker or Compose run target's, with its snapshot.
#[command(trust = trusted)]
/// The project interpreter when it is a run target's, with its snapshot.
pub fn sdk_container_python(host: &Host, window: &str) -> IdeResult<Option<ContainerPython>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -131,10 +129,9 @@ fn describe(host: &Host, root: &Path, settings: &Settings) -> Option<ContainerPy
Some(out)
}
/// Copies the container's Python libraries again (after the image changed).
#[command(trust = trusted)]
/// Takes a new snapshot of the project interpreter's container (also of an image that
/// has one already), then the language servers pick it up.
pub async fn sdk_container_python_refresh(host: &Host, window: &str) -> IdeResult<Option<ContainerPython>> {
// A new snapshot even of an image that has one already; the language servers then pick it up.
host.require_trust(window)?;
let project = host.project(window)?;
update(Dirs::of(host), &project, true).await?;
@@ -299,5 +296,3 @@ fn unique() -> String {
let secs = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_secs());
format!("{:x}-{}-{}", secs & 0xff_ffff, std::process::id(), COUNT.fetch_add(1, Ordering::Relaxed))
}
ide_command::domain!(sdk_container_python: sdk_container_python, sdk_container_python_refresh);
+6 -12
Переглянути файл
@@ -1,6 +1,5 @@
use super::Channel;
use super::Emit;
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, RequestId};
use ide_search::{FileMatches, ProjectFileSet, SearchQuery, SearchSummary};
use serde::{Deserialize, Serialize};
@@ -24,13 +23,12 @@ pub fn literal_range(l: ide_language::Literal) -> ide_search::LiteralRange {
/// Find in Files. Results stream through `on_event`; ends with `Done`.
/// Cancel with `cancel_request(request)`.
#[command(trust = always)]
pub async fn search_start(
pub async fn start(
host: &Host,
window: &str,
request: RequestId,
mut query: SearchQuery,
on_event: Channel<SearchEvent>,
on_event: Emit<SearchEvent>,
) -> IdeResult<()> {
let project = host.project(window)?;
// Excluded roots (Project Structure marks and detected `target`, `node_modules`, …) and
@@ -41,13 +39,11 @@ pub async fn search_start(
let syntax = host.syntax();
let summary = host
.blocking(move || {
search_project(&project, &syntax, &query, &cancel, &|file| {
let _ = events.send(SearchEvent::File { file });
})
search_project(&project, &syntax, &query, &cancel, &|file| events(SearchEvent::File { file }))
})
.await;
host.end_request(request);
let _ = on_event.send(SearchEvent::Done { summary: summary? });
on_event(SearchEvent::Done { summary: summary? });
Ok(())
}
@@ -177,7 +173,5 @@ mod tests {
}
}
pub mod commands;
mod commands;
pub use commands::*;
ide_command::domain!(search: search_start);
+33 -6
Переглянути файл
@@ -1,6 +1,8 @@
#[allow(unused_imports)]
use super::*;
use crate::Host;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeResult, Pos, RequestId, TextEdit};
use ide_search::{ReplaceEvent, ReplaceHost, ReplacePreview, ReplaceTarget, SearchQuery};
use ide_workspace::Documents;
@@ -49,7 +51,6 @@ impl ReplaceHost for DocumentsHost<'_> {
/// editor buffers are replaced in place and left unsaved; files that were not
/// open are opened transiently, saved and closed.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn replace_in_files(
host: &Host,
window: &str,
@@ -78,7 +79,6 @@ pub async fn replace_in_files(
}
/// Before / after text of `path` for Replace › Preview (unsaved buffer included).
#[command(trust = trusted)]
pub async fn replace_preview(
host: &Host,
window: &str,
@@ -98,9 +98,36 @@ pub async fn replace_preview(
}
/// Validates a query (e.g. regex syntax) while the user types.
#[command(trust = always)]
pub fn search_validate(query: SearchQuery) -> IdeResult<()> {
pub fn search_validate(_host: &Host, _window: &str, query: SearchQuery) -> IdeResult<()> {
ide_search::validate_query(&query)
}
ide_command::domain!(search_commands: replace_in_files, replace_preview, search_validate);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("replace_in_files", |c| async move {
replace_in_files(
&c.host,
&c.window,
c.arg("request")?,
c.arg("query")?,
c.arg("replacement")?,
c.arg("preserveCase")?,
c.arg("targets")?,
c.sender("onEvent")?,
)
.await
});
d.add("replace_preview", |c| async move {
replace_preview(
&c.host,
&c.window,
c.arg("query")?,
c.arg("replacement")?,
c.arg("preserveCase")?,
c.arg("path")?,
c.arg("only")?,
)
.await
});
d.add("search_validate", |c| async move { search_validate(&c.host, &c.window, c.arg("query")?) });
}
+8 -4
Переглянути файл
@@ -1,7 +1,7 @@
//! Proofreading › Typo: spell checking of open documents.
use crate::Host;
use crate::Project;
use ide_command::command;
use crate::rpc::Dispatcher;
use super::doc::blocking;
use ide_core::settings::SpellingSettings;
@@ -36,7 +36,6 @@ fn speller(project: &Project) -> Speller {
/// Misspelt words in the comments, string literals and declared names of
/// `doc` that `scope` includes (all of its text for prose). Cancel with
/// `cancel_request(request)`.
#[command(trust = always)]
pub async fn spell_check(
host: &Host,
window: &str,
@@ -106,7 +105,6 @@ pub async fn spell_check(
}
/// Replacements for a misspelt `word`, best first (Typo › Change to…).
#[command(trust = always)]
pub async fn spell_suggest(host: &Host, window: &str, word: String) -> IdeResult<Vec<String>> {
let project = host.project(window).ok();
blocking(move || {
@@ -116,4 +114,10 @@ pub async fn spell_suggest(host: &Host, window: &str, word: String) -> IdeResult
.await
}
ide_command::domain!(spell: spell_check, spell_suggest);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("spell_check", |c| async move {
spell_check(&c.host, &c.window, c.arg("doc")?, c.arg("scope")?, c.arg("request")?).await
});
d.add("spell_suggest", |c| async move { spell_suggest(&c.host, &c.window, c.arg("word")?).await });
}
+22 -53
Переглянути файл
@@ -2,59 +2,28 @@
//! server ([`crate::rpc`]). A remote window connects from the server (deployment, database
//! tunnels, run targets, SSH sessions), so the host keys it trusts and the passwords it is
//! given belong to the server's [`ide_ssh::SshManager`], not the desktop's.
use crate::Host;
use ide_command::command;
use ide_core::IdeResult;
use crate::rpc::Dispatcher;
use ide_core::remote_settings::SshConfiguration;
/// Test Connection: connects with `config` as edited (not necessarily saved).
#[command(trust = always)]
pub async fn ssh_test(host: &Host, config: SshConfiguration, secret: Option<String>) -> IdeResult<String> {
host.ssh.test(&config, secret).await
pub(crate) fn register(d: &mut Dispatcher) {
d.add("ssh_test", |c| async move {
let (config, secret) = (c.arg::<SshConfiguration>("config")?, c.arg::<Option<String>>("secret")?);
c.host.ssh.test(&config, secret).await
});
d.add("ssh_set_secret", |c| async move {
let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
c.host.ssh.set_secret(&id, secret, save);
Ok(())
});
d.add("ssh_password_saved", |c| async move { Ok(c.host.ssh.password_saved(&c.arg::<String>("key")?)) });
d.add("ssh_needs_secret", |c| async move {
let ssh = &c.host.ssh;
Ok(ssh.needs_secret(&ssh.config(&c.arg::<String>("id")?)?))
});
d.add("ssh_trust_host", |c| async move { c.host.ssh.trust_host(&c.arg::<String>("id")?).await });
d.add("ssh_connected", |c| async move { Ok(c.host.ssh.connected()) });
d.add("ssh_disconnect", |c| async move {
c.host.ssh.disconnect(&c.arg::<String>("id")?);
Ok(())
});
}
/// Remembers the password / passphrase of configuration `id` (`None` forgets it).
#[command(trust = always)]
pub fn ssh_set_secret(host: &Host, id: String, secret: Option<String>, save: bool) {
host.ssh.set_secret(&id, secret, save);
}
/// Whether a password is saved under `key` (an FTP deployment server's).
#[command(trust = always)]
pub fn ssh_password_saved(host: &Host, key: String) -> bool {
host.ssh.password_saved(&key)
}
/// Whether connecting with configuration `id` needs a password first.
#[command(trust = always)]
pub fn ssh_needs_secret(host: &Host, id: String) -> IdeResult<bool> {
Ok(host.ssh.needs_secret(&host.ssh.config(&id)?))
}
/// Trusts the host key that failed the last connection of configuration `id`.
#[command(trust = always)]
pub async fn ssh_trust_host(host: &Host, id: String) -> IdeResult<()> {
host.ssh.trust_host(&id).await
}
/// Ids of the configurations with an open connection.
#[command(trust = always)]
pub fn ssh_connected(host: &Host) -> Vec<String> {
host.ssh.connected()
}
#[command(trust = always)]
pub fn ssh_disconnect(host: &Host, id: String) {
host.ssh.disconnect(&id);
}
ide_command::domain!(
ssh:
ssh_connected,
ssh_disconnect,
ssh_needs_secret,
ssh_password_saved,
ssh_set_secret,
ssh_test,
ssh_trust_host,
);
+33 -20
Переглянути файл
@@ -3,7 +3,7 @@
use crate::Host;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, LanguageId, Range, RequestId};
use ide_dap::{StackFrame, TraceRun};
pub use ide_dap::{TracePhase, TraceProgress, TraceUnavailable};
@@ -102,8 +102,8 @@ pub enum TerminalView {
Threw { exception: JvmValue },
}
/// The stream chains around `frame`'s line; `top`: it is the thread's top frame.
#[command(trust = trusted)]
/// The stream chains around `frame`'s line, in source order, with why each cannot be traced.
/// `top`: `frame` is the thread's top frame, the only one a trace can run from.
pub async fn debug_stream_chains(
host: &Host,
window: &str,
@@ -111,16 +111,17 @@ pub async fn debug_stream_chains(
frame: StackFrame,
top: bool,
) -> IdeResult<Vec<StreamChainInfo>> {
// In source order, with why each cannot be traced; only the top frame can run a trace.
host.require_trust(window)?;
let backend = host.debugger.capabilities(session)?.stream_trace;
Ok(candidates(host, window, frame, top, backend).await?.into_iter().map(|c| c.info).collect())
}
/// Traces chain `chain_index` of [`debug_stream_chains`], whose `range` the UI showed, while the
/// program runs it; cancelling `request` stops recording.
/// Runs the program from `thread_id`, stopped in `frame`, through the chain `chain_index` of
/// [`debug_stream_chains`], recording each element, and leaves it stopped after the chain's
/// terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in between
/// can move another chain to the same index. Cancelling `request` stops recording while the
/// program runs on.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn debug_stream_trace(
host: &Host,
window: &str,
@@ -132,9 +133,6 @@ pub async fn debug_stream_trace(
range: Range,
on_progress: Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
// Runs the program from `thread_id`, stopped in `frame`, and leaves it stopped after the
// chain's terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in
// between can move another chain to the same index. The program runs on after a cancel.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let chain = ChainRef { frame, index: chain_index, range };
@@ -197,14 +195,12 @@ async fn trace(
})
}
/// Ends the running trace's terminal operation; `None` when no trace runs.
#[command(trust = trusted)]
/// Ends the running trace's terminal operation (Abort Operation); `None` when no trace runs.
pub async fn debug_stream_trace_abort(
host: &Host,
window: &str,
session: DebugSessionId,
) -> IdeResult<Option<AbortState>> {
// Backs the debugger's Abort Operation action.
host.require_trust(window)?;
host.debugger.stream_trace_abort(session).await
}
@@ -442,12 +438,29 @@ fn box_kind(type_name: &str) -> Option<BoxKind> {
})
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_stream_chains", |c| async move {
debug_stream_chains(&c.host, &c.window, c.arg("session")?, c.arg("frame")?, c.arg("top")?).await
});
d.add("debug_stream_trace", |c| async move {
debug_stream_trace(
&c.host,
&c.window,
c.arg("session")?,
c.arg("request")?,
c.arg("threadId")?,
c.arg("frame")?,
c.arg("chainIndex")?,
c.arg("range")?,
c.sender("onProgress")?,
)
.await
});
d.add("debug_stream_trace_abort", |c| async move {
debug_stream_trace_abort(&c.host, &c.window, c.arg("session")?).await
});
}
#[cfg(test)]
mod tests;
ide_command::domain!(
stream_trace:
debug_stream_chains,
debug_stream_trace,
debug_stream_trace_abort,
);
+27 -20
Переглянути файл
@@ -8,7 +8,7 @@
//! `unavailable`.
use crate::Host;
use crate::Project;
use ide_command::command;
use crate::rpc::Dispatcher;
use super::doc::blocking;
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, LanguageId, Pos, Range, RequestId};
@@ -46,13 +46,11 @@ async fn on_doc<T: Send + 'static>(
/// What the structure service supports for a language (`tree`: every query,
/// `locals`: scope analysis).
#[command(trust = always)]
pub fn syntax_support(host: &Host, window: &str, language: LanguageId) -> IdeResult<StructureSupport> {
Ok(host.project(window)?.structure.support(&language))
}
/// The smallest named node covering `range`, with its ancestors (parent first).
#[command(trust = always)]
pub async fn syntax_node_at(
host: &Host,
window: &str,
@@ -65,7 +63,6 @@ pub async fn syntax_node_at(
/// The expression a selection denotes (exact or minimally enclosing), with its
/// statement, block and caret candidates.
#[command(trust = always)]
pub async fn syntax_expression_at(
host: &Host,
window: &str,
@@ -77,7 +74,6 @@ pub async fn syntax_expression_at(
}
/// `ERROR` / `MISSING` nodes (e.g. a missing `;`) in document order.
#[command(trust = always)]
pub async fn syntax_errors(
host: &Host,
window: &str,
@@ -89,7 +85,6 @@ pub async fn syntax_errors(
/// Scope analysis of the identifier at `pos`: its local definition and
/// references, or why it is not a local.
#[command(trust = always)]
pub async fn syntax_locals(
host: &Host,
window: &str,
@@ -101,7 +96,6 @@ pub async fn syntax_locals(
}
/// Identifier tokens spelled `name` in a document, excluding comments and strings.
#[command(trust = always)]
pub async fn syntax_identifiers(
host: &Host,
window: &str,
@@ -114,7 +108,6 @@ pub async fn syntax_identifiers(
/// [`syntax_identifiers`] over files (open buffers win over disk); files
/// without occurrences or without a grammar are left out. Cancellable.
#[command(trust = always)]
pub async fn syntax_identifiers_in_files(
host: &Host,
window: &str,
@@ -144,7 +137,6 @@ pub async fn syntax_identifiers_in_files(
/// Extend Selection chain plus statement / declaration ranges at `pos`
/// (Move Statement, Complete Statement for languages without a Lezer grammar).
#[command(trust = always)]
pub async fn syntax_structural_ranges(
host: &Host,
window: &str,
@@ -155,14 +147,29 @@ pub async fn syntax_structural_ranges(
on_doc(host, window, doc, request, move |s, snap, c| s.structural_ranges(snap, pos, c)).await
}
ide_command::domain!(
syntax:
syntax_errors,
syntax_expression_at,
syntax_identifiers,
syntax_identifiers_in_files,
syntax_locals,
syntax_node_at,
syntax_structural_ranges,
syntax_support,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("syntax_support", |c| async move { syntax_support(&c.host, &c.window, c.arg("language")?) });
d.add("syntax_node_at", |c| async move {
syntax_node_at(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("request")?).await
});
d.add("syntax_expression_at", |c| async move {
syntax_expression_at(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("request")?).await
});
d.add(
"syntax_errors",
|c| async move { syntax_errors(&c.host, &c.window, c.arg("doc")?, c.arg("request")?).await },
);
d.add("syntax_locals", |c| async move {
syntax_locals(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("request")?).await
});
d.add("syntax_identifiers", |c| async move {
syntax_identifiers(&c.host, &c.window, c.arg("doc")?, c.arg("name")?, c.arg("request")?).await
});
d.add("syntax_identifiers_in_files", |c| async move {
syntax_identifiers_in_files(&c.host, &c.window, c.arg("paths")?, c.arg("name")?, c.arg("request")?).await
});
d.add("syntax_structural_ranges", |c| async move {
syntax_structural_ranges(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("request")?).await
});
}
+12 -54
Переглянути файл
@@ -1,6 +1,5 @@
use super::{Channel, Emit};
use super::Emit;
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, TerminalId};
use ide_terminal::{TerminalInfo, TerminalOptions};
@@ -8,8 +7,7 @@ mod images;
const MAX_IMAGE_BYTES: usize = 20 * 1024 * 1024;
#[command(trust = always)]
pub async fn term_store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime: String) -> IdeResult<String> {
pub async fn store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime: String) -> IdeResult<String> {
if data.len() > MAX_IMAGE_BYTES {
return Err(ide_core::IdeError::invalid("image is too large to paste (limit 20 MB)"));
}
@@ -20,14 +18,11 @@ pub async fn term_store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime:
host.blocking(move || images::store(&data_dir, &data, &mime)).await
}
/// Async to stay off the main thread: forking the IDE (its whole address space)
/// to start the shell takes tens of milliseconds, a frozen UI if run there.
#[command(trust = always)]
pub async fn term_spawn(
pub fn spawn(
host: &Host,
window: &str,
mut options: TerminalOptions,
on_output: Channel<String>,
on_output: Emit<String>,
) -> IdeResult<TerminalInfo> {
if !host.project(window).is_ok_and(|p| p.is_trusted()) {
// Project terminal settings can otherwise start a command as soon as a tab restores.
@@ -46,14 +41,7 @@ pub async fn term_spawn(
.filter(|p| p.is_trusted())
.and_then(|p| ide_sdk::apply::terminal_activation(&p.root, &p.settings.effective(), &shell));
let key = host.owner_window(window).to_owned();
let info = host.terminals.spawn(
options,
key,
host.window_sink(window),
Box::new(move |chunk| {
let _ = on_output.send(chunk);
}),
)?;
let info = host.terminals.spawn(options, key, host.window_sink(window), Box::new(move |chunk| on_output(chunk)))?;
if let Some(line) = activation {
let _ = host.terminals.write(info.id, &format!(" {line}\r"));
}
@@ -145,40 +133,22 @@ impl ide_terminal::TerminalChannel for SshTerminal {
}
}
#[command(trust = always)]
pub fn term_write(host: &Host, id: TerminalId, data: String) -> IdeResult<()> {
host.terminals.write(id, &data)
pub fn write(host: &Host, id: TerminalId, data: &str) -> IdeResult<()> {
host.terminals.write(id, data)
}
#[command(trust = always)]
pub fn term_resize(host: &Host, id: TerminalId, cols: u16, rows: u16) -> IdeResult<()> {
pub fn resize(host: &Host, id: TerminalId, cols: u16, rows: u16) -> IdeResult<()> {
host.terminals.resize(id, cols, rows)
}
#[command(trust = always)]
pub fn term_kill(host: &Host, id: TerminalId) -> IdeResult<()> {
pub fn kill(host: &Host, id: TerminalId) -> IdeResult<()> {
host.terminals.kill(id)
}
/// Whether the session is running a command (closing its tab asks first). A
/// `tcgetpgrp` or one process snapshot: async only to stay off the main thread.
#[command(trust = always)]
pub async fn term_is_busy(host: &Host, id: TerminalId) -> IdeResult<bool> {
pub fn is_busy(host: &Host, id: TerminalId) -> IdeResult<bool> {
host.terminals.is_busy(id)
}
/// Shell used when Settings › Terminal › Shell path is empty.
#[command(trust = always)]
pub fn term_default_shell() -> String {
ide_terminal::default_shell_path()
}
/// Installed shells for the Terminal's "New Predefined Session" menu.
#[command(trust = always)]
pub fn term_available_shells() -> Vec<String> {
ide_terminal::available_shells()
}
#[cfg(test)]
mod tests {
use super::*;
@@ -201,23 +171,11 @@ mod tests {
project_environment: false,
});
let id = TerminalId::next();
let error = term_store_image(&host, id, vec![0; MAX_IMAGE_BYTES + 1], "image/png".into()).await.unwrap_err();
let error = store_image(&host, id, vec![0; MAX_IMAGE_BYTES + 1], "image/png".into()).await.unwrap_err();
assert_eq!(error.kind, ErrorKind::InvalidInput);
assert_eq!(error.message, "image is too large to paste (limit 20 MB)");
let error = term_store_image(&host, id, vec![0; MAX_IMAGE_BYTES], "image/png".into()).await.unwrap_err();
let error = store_image(&host, id, vec![0; MAX_IMAGE_BYTES], "image/png".into()).await.unwrap_err();
assert_eq!(error.message, "terminal session not found");
assert!(!host.data_dir.join("terminal-images").exists());
}
}
ide_command::domain!(
term:
term_available_shells,
term_default_shell,
term_is_busy,
term_kill,
term_resize,
term_spawn,
term_store_image,
term_write,
);
+40 -26
Переглянути файл
@@ -1,7 +1,7 @@
//! Language server / debug adapter installer and JDK downloads (`ide-tools`).
use crate::Host;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_sdk::Sdk;
@@ -56,7 +56,6 @@ fn reconfigure_servers(host: &Host) {
}
/// Status of every known language server / debug adapter and the languages using it.
#[command(trust = trusted)]
pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
let tools = tools(host, window)?;
let langs = languages(host, window);
@@ -65,7 +64,6 @@ pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
/// Installs (or reinstalls) a tool into `<app-data>/tools`, streaming output through
/// `on_event`. Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn tools_install(
host: &Host,
window: &str,
@@ -93,7 +91,6 @@ pub async fn tools_install(
/// Newer versions of the tools the IDE installed (release downloads and npm packages).
/// Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> IdeResult<Vec<ToolUpdate>> {
let tools = tools(host, window)?;
let cancel = host.begin_request(request);
@@ -103,7 +100,6 @@ pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> Ide
}
/// Removes a tool the IDE installed.
#[command(trust = trusted)]
pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResult<ToolInfo> {
let tools = tools(host, window)?;
let langs = languages(host, window);
@@ -113,14 +109,17 @@ pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResu
}
/// JDK distributions Download JDK offers.
#[command(trust = always)]
pub fn jdk_download_vendors() -> Vec<JdkVendor> {
pub fn jdk_download_vendors(_host: &Host, _window: &str) -> Vec<JdkVendor> {
ide_tools::jdk::vendors()
}
/// Java versions `vendor` publishes; cancellable with `cancel_request(request)`.
#[command(trust = always)]
pub async fn jdk_download_releases(host: &Host, vendor: String, request: RequestId) -> IdeResult<JdkReleases> {
pub async fn jdk_download_releases(
host: &Host,
_window: &str,
vendor: String,
request: RequestId,
) -> IdeResult<JdkReleases> {
let tools = Tools::new(&host.local_data_dir);
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || tools.jdk_releases(&vendor, &cancel)).await.map_err(join_err);
@@ -129,8 +128,7 @@ pub async fn jdk_download_releases(host: &Host, vendor: String, request: Request
}
/// Where Download JDK puts JDKs unless told otherwise.
#[command(trust = always)]
pub fn jdk_download_location(host: &Host) -> IdeResult<ide_core::IpcPath> {
pub fn jdk_download_location(host: &Host, _window: &str) -> IdeResult<ide_core::IpcPath> {
Ok(ide_tools::jdk::jdks_dir(&host.local_data_dir).into())
}
@@ -138,9 +136,10 @@ pub fn jdk_download_location(host: &Host) -> IdeResult<ide_core::IpcPath> {
/// [`jdk_download_location`]), streaming progress through `on_event`; cancellable
/// with `cancel_request(request)`. The JDK is then detected like an installed one,
/// and language servers waiting for a JDK (jdtls) start on it.
#[command(trust = always)]
#[allow(clippy::too_many_arguments)]
pub async fn jdk_download(
host: &Host,
_window: &str,
vendor: String,
version: u32,
location: Option<PathBuf>,
@@ -172,8 +171,8 @@ pub async fn jdk_download(
Ok(sdk)
}
/// The Java version the window's jdtls needs; `None` while it isn't installed or doesn't tell.
#[command(trust = always)]
/// The Java version the jdtls this window launches needs; `None` while it isn't
/// installed or doesn't tell.
pub async fn jdtls_required_java(host: &Host, window: &str) -> IdeResult<Option<u32>> {
let settings = match host.project(window) {
Ok(project) => project.settings.effective(),
@@ -189,15 +188,30 @@ pub async fn jdtls_required_java(host: &Host, window: &str) -> IdeResult<Option<
tokio::task::spawn_blocking(move || ide_sdk::java::jdtls_required_java(&cfg)).await.map_err(join_err)
}
ide_command::domain!(
tools:
jdk_download,
jdk_download_location,
jdk_download_releases,
jdk_download_vendors,
jdtls_required_java,
tools_install,
tools_list,
tools_uninstall,
tools_updates,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("tools_list", |c| async move { tools_list(&c.host, &c.window).await });
d.add("tools_install", |c| async move {
tools_install(&c.host, &c.window, c.arg("name")?, c.arg("request")?, c.sender("onEvent")?).await
});
d.add("tools_uninstall", |c| async move { tools_uninstall(&c.host, &c.window, c.arg("name")?).await });
d.add("tools_updates", |c| async move { tools_updates(&c.host, &c.window, c.arg("request")?).await });
d.add("jdk_download_vendors", |c| async move { Ok(jdk_download_vendors(&c.host, &c.window)) });
d.add("jdk_download_releases", |c| async move {
jdk_download_releases(&c.host, &c.window, c.arg("vendor")?, c.arg("request")?).await
});
d.add("jdk_download_location", |c| async move { jdk_download_location(&c.host, &c.window) });
d.add("jdtls_required_java", |c| async move { jdtls_required_java(&c.host, &c.window).await });
d.add("jdk_download", |c| async move {
jdk_download(
&c.host,
&c.window,
c.arg("vendor")?,
c.arg("version")?,
c.arg("location")?,
c.arg("request")?,
c.sender("onEvent")?,
)
.await
});
}
+5 -10
Переглянути файл
@@ -1,11 +1,9 @@
use crate::{Host, apply_git_executable};
use ide_command::command;
use ide_core::IdeResult;
use ide_vcs::FileStatus;
/// Changes of every repository of the project.
#[command(trust = always)]
pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
pub async fn status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
let project = host.project(window)?;
host.blocking(move || {
let settings = project.settings.effective();
@@ -24,10 +22,9 @@ pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>>
.await
}
/// Changes of `paths` only: the dirty-scope refresh after a watcher batch.
#[command(trust = always)]
pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::PathBuf>) -> IdeResult<Vec<FileStatus>> {
// `paths` that belong to no repository are ignored, and an empty list is the full status.
/// Changes of `paths` only: the dirty-scope refresh after a watcher batch. `paths` that belong
/// to no repository are ignored, and an empty list is the full status.
pub async fn status_paths(host: &Host, window: &str, paths: Vec<std::path::PathBuf>) -> IdeResult<Vec<FileStatus>> {
let project = host.project(window)?;
host.blocking(move || {
let settings = project.settings.effective();
@@ -46,7 +43,7 @@ pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::P
.await
}
pub mod commands;
mod commands;
pub use commands::*;
/// Refuses (with `refusal`) to remove or move the worktree that holds the open project.
@@ -87,5 +84,3 @@ fn check_worktree_away_from_project(
}
Ok(())
}
ide_command::domain!(vcs: vcs_status, vcs_status_paths);
File diff suppressed because it is too large. Load diff
+4 -9
Переглянути файл
@@ -1,10 +1,9 @@
//! The built-in web server's URLs.
use crate::Host;
use ide_command::command;
use ide_core::IdeResult;
use ide_core::IpcPath;
use ide_core::proxy_settings::{ProxyMode, ProxySettings};
use std::path::Path;
use std::time::Duration;
/// Whether `url` names this machine (`localhost` or a loopback address).
@@ -47,12 +46,10 @@ pub async fn serves_page(url: &str) -> bool {
response.status().is_success() && html
}
/// The built-in server's URL for `path` (started on first use).
#[command(trust = always)]
pub async fn web_url(host: &Host, window: &str, path: IpcPath) -> IdeResult<String> {
// Under the window's project when it holds the file.
/// The URL serving `file`, under the window's project when it holds the file.
pub async fn url(host: &Host, window: &str, file: &Path) -> IdeResult<String> {
let root = host.project(window).ok().map(|p| p.root.clone());
host.web.url_for(root.as_deref(), &path).await
host.web.url_for(root.as_deref(), file).await
}
#[cfg(test)]
@@ -108,5 +105,3 @@ mod tests {
assert!(!serves_page("not a url").await);
}
}
ide_command::domain!(web: web_url);
+11 -284
Переглянути файл
@@ -1,48 +1,23 @@
//! Plugin window commands shared by local IPC and remote RPC.
//! Plugin command requests shared by local IPC and remote RPC.
use super::{
CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost, PluginInfo,
PluginStatusItem, WorkbenchEvent,
};
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use super::PluginHost;
use ide_core::{IdeResult, RequestId};
use ide_plugin::Invocation;
use ide_workspace::settings::SettingsScope;
use std::collections::BTreeMap;
use std::path::PathBuf;
use std::sync::Arc;
async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Runs a plugin command in the context of this window's project and focused editor.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn plugin_run_command(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
pub async fn run_command(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugin_id: String,
command_id: String,
arg: Option<String>,
editor: Option<PluginEditor>,
paths: Option<Vec<PathBuf>>,
settings_scope: Option<SettingsScope>,
command_chain: Option<Vec<String>>,
invocation: Invocation,
request: Option<RequestId>,
) -> IdeResult<Option<String>> {
let plugins = plugins.clone();
let invocation = Invocation {
command_chain: command_chain.unwrap_or_default(),
client: Some(window.to_owned()),
workspace_root: host.project(window).ok().map(|p| p.root.clone()),
editor: editor.map(PluginEditor::context),
selected_paths: paths.unwrap_or_default(),
global_settings: matches!(settings_scope, Some(SettingsScope::Global)),
};
let cancel = request.map(|id| host.begin_project_read_request(window, id));
let cancel = request.map(|id| match invocation.client.as_deref() {
Some(window) => host.begin_project_read_request(window, id),
None => host.begin_request(id),
});
let result = host
.blocking(move || {
plugins.run_command_with_cancel(&plugin_id, &command_id, arg.as_deref(), invocation, cancel.as_ref())
@@ -53,251 +28,3 @@ pub async fn plugin_run_command(
}
result
}
/// The UI language (BCP 47) that plugin code reads with `ui.locale()`.
#[command(trust = always)]
pub async fn plugin_set_ui_locale(plugins: &Arc<PluginHost>, tag: String) -> IdeResult<()> {
plugins.set_ui_locale(&tag);
Ok(())
}
/// Workbench events from this window (only the kinds of `plugin_event_kinds`).
#[command(trust = trusted)]
pub fn plugin_post_events(
plugins: &Arc<PluginHost>,
window: &str,
events: Vec<WorkbenchEvent>,
editor: Option<PluginEditor>,
) {
plugins.post_window_events(window, events, editor);
}
/// Kinds of workbench events plugins want (re-fetch on `subscriptionsChanged`).
#[command(trust = trusted, desktop_body = async)]
pub async fn plugin_event_kinds(plugins: &Arc<PluginHost>) -> Vec<EventKind> {
plugins.event_kinds().into_iter().collect()
}
/// Every plugin status bar item (later changes arrive as `statusItemChanged`).
#[command(trust = trusted)]
pub fn plugin_status_items(plugins: &Arc<PluginHost>, window: &str) -> Vec<PluginStatusItem> {
plugins.status_snapshot(window)
}
/// Plugin context keys in effect for this window (later changes arrive as `contextChanged`).
#[command(trust = trusted)]
pub fn plugin_context_keys(plugins: &Arc<PluginHost>, window: &str) -> Vec<PluginContextKey> {
plugins.context_keys(Some(window))
}
/// Cancels a plugin task (`taskStarted` with `cancellable`).
#[command(trust = trusted)]
pub fn plugin_cancel_task(plugins: &Arc<PluginHost>, task_id: String) -> bool {
plugins.cancel_task(&task_id)
}
/// Reports the user's answer to a plugin's `promptRequested`: the chosen keys
/// (pick), `[text]` (input), anything (confirm: OK), or `None` when dismissed.
#[command(trust = trusted)]
pub fn plugin_answer_prompt(plugins: &Arc<PluginHost>, prompt_id: String, answer: Option<Vec<String>>) -> bool {
plugins.answer_prompt(&prompt_id, answer)
}
/// A window's answer to a plugin's `commitRequested`; false when the call no
/// longer waits.
#[command(trust = trusted)]
pub fn plugin_answer_commit(plugins: &Arc<PluginHost>, request_id: String, answer: CommitAnswer) -> bool {
plugins.answer_commit(&request_id, answer)
}
/// The UI reports the focused editor's file (`editor-focused` events).
#[command(trust = always)]
pub fn plugin_set_active_file(plugins: &Arc<PluginHost>, window: &str, path: Option<String>) {
plugins.set_active_file(window, path);
}
/// The invoking window's reply to a plugin command request.
#[command(trust = trusted)]
pub fn plugin_answer_command(
plugins: &Arc<PluginHost>,
window: &str,
request_id: String,
answer: CommandAnswer,
) -> IdeResult<bool> {
Ok(plugins.answer_command(window, &request_id, answer))
}
/// The project root a `scope` setting applies to (`None`: global).
fn scope_root(host: &Host, window: &str, scope: SettingsScope) -> IdeResult<Option<PathBuf>> {
Ok(match scope {
SettingsScope::Global => None,
SettingsScope::Project => Some(host.project(window)?.root.clone()),
})
}
/// Re-approves a plugin's executable, globally or for this window's project.
#[command(trust = outside_restricted)]
pub async fn plugin_choose_program(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
capability: String,
scope: SettingsScope,
path: Option<PathBuf>,
) -> IdeResult<PluginInfo> {
let plugins = plugins.clone();
let root = scope_root(host, window, scope)?;
blocking(move || plugins.choose_program(&plugin_id, &capability, root.as_deref(), path.as_deref())).await
}
/// The currently approved executable in the selected scope, after revalidating its pin.
#[command(trust = outside_restricted)]
pub async fn plugin_program(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
program: String,
scope: SettingsScope,
) -> IdeResult<ide_core::IpcPath> {
let plugins = plugins.clone();
let root = scope_root(host, window, scope)?;
blocking(move || plugins.program_for_project(&plugin_id, &program, root.as_deref()).map(Into::into)).await
}
/// Project-scoped decoration snapshots; the window filters to its current root.
#[command(trust = trusted)]
pub fn plugin_decoration_sets(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec<DecorationSet>> {
plugins.decoration_sets()
}
/// Reports exactly one completion from the operation's launching window.
#[command(trust = trusted)]
pub fn plugin_finish_operation(
plugins: &Arc<PluginHost>,
window: &str,
id: String,
status: Option<i32>,
stopped: bool,
) -> IdeResult<bool> {
Ok(plugins.finish_operation(window, &id, status, stopped))
}
/// Dispatches a wasm content editor action through the owning plugin's event handler.
#[command(trust = trusted)]
pub fn plugin_content_tab_action(
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
action: ide_plugin::ContentTabAction,
) -> IdeResult<()> {
plugins.content_tab_action(window, &plugin_id, action)
}
/// Selects test-tree paths in an owned plugin test configuration.
#[command(trust = trusted)]
pub async fn plugin_select_tests(
plugins: &Arc<PluginHost>,
window: &str,
config: String,
tests: Vec<Vec<String>>,
) -> IdeResult<Option<Vec<String>>> {
let (plugins, client) = (plugins.clone(), window.to_owned());
blocking(move || plugins.select_tests(&client, &config, tests)).await
}
/// Parses one batch of an owned test configuration's output.
#[command(trust = trusted)]
pub async fn plugin_parse_test_results(
plugins: &Arc<PluginHost>,
window: &str,
config: String,
chunk: String,
) -> IdeResult<Option<Vec<ide_plugin::PluginTestEvent>>> {
let (plugins, client) = (plugins.clone(), window.to_owned());
blocking(move || plugins.parse_test_results(&client, &config, chunk)).await
}
/// Starts only the pinned command recorded for this window's terminal operation.
#[command(trust = trusted)]
pub async fn plugin_terminal_session_spawn(
host: &Arc<Host>,
plugins: &Arc<PluginHost>,
window: &str,
operation: String,
cols: u16,
rows: u16,
on_output: crate::ops::Channel<String>,
) -> IdeResult<ide_terminal::TerminalInfo> {
let (plugins, host, window) = (plugins.clone(), host.clone(), window.to_owned());
blocking(move || {
plugins.spawn_terminal_session(
&host,
&window,
&operation,
cols,
rows,
Arc::new(move |chunk| {
let _ = on_output.send(chunk);
}),
)
})
.await
}
/// Marks a keyed tab closed before ending its process.
#[command(trust = trusted)]
pub fn plugin_terminal_session_close(plugins: &Arc<PluginHost>, window: &str, operation: String) -> IdeResult<()> {
plugins.close_terminal_session(window, &operation)
}
/// Revalidates a plugin run's executable before debugging, including reruns.
#[command(trust = trusted)]
pub async fn plugin_prepare_debug_run(
plugins: &Arc<PluginHost>,
window: &str,
config: ide_run::RunConfig,
) -> IdeResult<ide_run::RunConfig> {
let (plugins, client) = (plugins.clone(), window.to_owned());
blocking(move || plugins.prepare_debug_run(&client, config)).await
}
/// Waits for the process an `attach-child` plugin configuration's debugger attaches to.
#[command(trust = trusted)]
pub async fn plugin_debug_attach_target(
host: &Arc<Host>,
plugins: &Arc<PluginHost>,
window: &str,
config: String,
run: ide_core::RunId,
) -> IdeResult<ide_dap::attach::AttachableProcess> {
let (plugins, host, client) = (plugins.clone(), host.clone(), window.to_owned());
blocking(move || plugins.debug_attach_target(&host, &client, &config, run)).await
}
ide_command::domain!(
plugins_commands:
plugin_answer_command,
plugin_answer_commit,
plugin_answer_prompt,
plugin_cancel_task,
plugin_choose_program,
plugin_content_tab_action,
plugin_context_keys,
plugin_debug_attach_target,
plugin_decoration_sets,
plugin_event_kinds,
plugin_finish_operation,
plugin_parse_test_results,
plugin_post_events,
plugin_prepare_debug_run,
plugin_program,
plugin_run_command,
plugin_select_tests,
plugin_set_active_file,
plugin_set_ui_locale,
plugin_status_items,
plugin_terminal_session_close,
plugin_terminal_session_spawn,
);
+4 -9
Переглянути файл
@@ -3,23 +3,20 @@
//! local projects, `openidea-server` for remote ones.
use super::{CommitSelection, PluginCommitCheckRef, PluginCommitCheckResult, PluginHost};
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use std::sync::Arc;
/// Runs plugins' before-commit checks on what `selection` commits, until
/// `request` is cancelled.
#[command(trust = trusted)]
pub async fn plugin_commit_checks(
/// Runs the plugins' before-commit checks `checks` on what `selection` commits,
/// until request `request` is cancelled.
pub async fn commit_checks(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
selection: CommitSelection,
checks: Vec<PluginCommitCheckRef>,
request: RequestId,
) -> IdeResult<Vec<PluginCommitCheckResult>> {
host.require_trust(window)?;
let plugins = plugins.clone();
let invocation = super::views::view_invocation(host, window, None, None)?;
let cancel = host.begin_project_read_request(window, request);
let result = tokio::task::spawn_blocking(move || plugins.commit_checks(invocation, selection, checks, &cancel))
@@ -29,5 +26,3 @@ pub async fn plugin_commit_checks(
host.end_request(request);
result
}
ide_command::domain!(plugins_commit: plugin_commit_checks);
+1 -1
Переглянути файл
@@ -638,7 +638,7 @@ impl PluginHost {
let contains = owned.extras.params.get(DEBUG_ATTACH_CONTAINS).cloned();
let deadline = Instant::now() + Duration::from_secs(60);
loop {
let info = crate::ops::run::run_list(host).into_iter().find(|r| r.id == run && r.config_id == owned.id);
let info = crate::ops::run::list(host).into_iter().find(|r| r.id == run && r.config_id == owned.id);
let Some(pid) = info.as_ref().filter(|r| r.running).and_then(|r| r.pid) else {
return Err(IdeError::not_found("the run ended before a process to debug started"));
};
+9 -31
Переглянути файл
@@ -1,5 +1,4 @@
use super::PluginHost;
use ide_command::command;
use ide_core::{IdeError, IdeResult};
use ide_plugin::Invocation;
use std::{path::PathBuf, sync::Arc};
@@ -10,15 +9,13 @@ pub struct NavigationFiles {
pub extensions: Vec<String>,
}
#[command(trust = trusted)]
/// File discovery is separate from clicking: the UI schedules small background
/// batches after initial index completion and updates only changed files later.
pub async fn plugin_navigation_files(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
) -> IdeResult<NavigationFiles> {
// File discovery is separate from clicking: the UI schedules small background
// batches after initial index completion and updates only changed files later.
let plugins = plugins.clone();
let project = host.project(window)?;
blocking(move || {
let extensions = plugins.navigation_extensions(&project.root);
@@ -43,10 +40,9 @@ pub async fn plugin_navigation_files(
.await
}
#[command(trust = trusted)]
pub fn plugin_navigation_invalidate(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
paths: Option<Vec<PathBuf>>,
) -> IdeResult<()> {
@@ -55,10 +51,9 @@ pub fn plugin_navigation_invalidate(
Ok(())
}
#[command(trust = trusted)]
pub async fn plugin_navigation_index(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
paths: Vec<PathBuf>,
request: ide_core::RequestId,
@@ -66,7 +61,6 @@ pub async fn plugin_navigation_index(
if paths.len() > 16 {
return Err(IdeError::invalid("navigation batches are limited to 16 files"));
}
let plugins = plugins.clone();
let project = host.project(window)?;
let cancel = host.begin_project_request(window, request);
let client = window.to_owned();
@@ -146,28 +140,24 @@ pub async fn plugin_navigation_index(
result
}
#[command(trust = trusted)]
/// The HTTP routes `plugin_id` reports for this window's project.
pub async fn plugin_endpoints(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
plugin_id: String,
) -> IdeResult<Vec<crate::plugins::endpoints::PluginEndpoint>> {
// The HTTP routes `plugin_id` reports for this window's project.
let plugins = plugins.clone();
let project = host.project(window)?;
blocking(move || Ok(plugins.endpoints(&plugin_id, &project.root)?.as_ref().clone())).await
}
#[command(trust = trusted)]
pub async fn plugin_navigation_goto(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
doc: ide_core::DocId,
pos: ide_core::Pos,
) -> IdeResult<Option<crate::plugins::navigation::NavigationResult>> {
let plugins = plugins.clone();
let project = host.project(window)?;
let client = window.to_owned();
blocking(move || {
@@ -179,17 +169,15 @@ pub async fn plugin_navigation_goto(
.await
}
#[command(trust = trusted)]
pub async fn plugin_navigation_markers(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
paths: Vec<PathBuf>,
) -> IdeResult<Vec<crate::plugins::navigation::FileMarkers>> {
if paths.len() > 64 {
return Err(IdeError::invalid("marker batches are limited to 64 files"));
}
let plugins = plugins.clone();
let project = host.project(window)?;
let client = window.to_owned();
blocking(move || {
@@ -203,13 +191,3 @@ pub async fn plugin_navigation_markers(
async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
ide_command::domain!(
plugins_index_ops:
plugin_endpoints,
plugin_navigation_files,
plugin_navigation_goto,
plugin_navigation_index,
plugin_navigation_invalidate,
plugin_navigation_markers,
);
+409 -8
Переглянути файл
@@ -11,21 +11,25 @@
//! grants (a `process:` grant is pinned to the program on this machine's
//! `PATH`).
//!
//! The commands a window needs at run time (`plugin_run_command`, `plugin_post_events`, …) are
//! `#[command]`s served by every project host, so a remote window's UI routes them here
//! unchanged. Plugin results come back as `plugin`
//! The commands a window needs at run time (`plugin_run_command`,
//! `plugin_post_events`, `plugin_event_kinds`, `plugin_status_items`,
//! `plugin_context_keys`, `plugin_cancel_task`, `plugin_answer_prompt`, `plugin_set_active_file`,
//! `plugin_line_markers`, `plugin_set_ui_locale`, `plugin_view_render`, `plugin_view_event`,
//! `plugin_service_detail`, `plugin_service_log`, `plugin_answer_commit`, `plugin_commit_checks`)
//! carry the desktop commands' names and arguments, so a remote window's UI
//! routes them here unchanged. Plugin results come back as `plugin`
//! notifications ([`PluginEventMessage`]); secrets stay in the desktop's
//! keychain and are asked for with a `plugin_secret` request
//! ([`SecretRequest`]) when a request header needs one (rule 4).
use super::{Consent, HostWorkspace, PluginEvent, PluginHost, PluginSource, SecretStore};
use crate::catalogue::TrustClass;
use super::{Consent, HostWorkspace, PluginEditor, PluginEvent, PluginHost, PluginSource, SecretStore};
use crate::rpc::Dispatcher;
use base64::Engine as _;
use ide_core::{IdeError, IdeResult};
use ide_extension::{MANIFEST_FILE, ledger};
use ide_jsonrpc::Peer;
use ide_plugin::Limits;
use ide_plugin::{Invocation, Limits};
use ide_workspace::settings::SettingsScope;
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
@@ -43,6 +47,49 @@ pub const SECRET_REQUEST: &str = "plugin_secret";
pub const SECRET_WRITE: &str = "plugin_secret_write";
/// OAuth listeners bound on the desktop, never the project server.
pub const AUTH_REQUEST: &str = "plugin_auth";
/// What [`RemotePlugins::register`] adds to a server's commands.
pub const COMMANDS: &[&str] = &[
SYNC_PACKAGES,
"plugin_run_command",
"plugin_set_ui_locale",
"plugin_select_tests",
"plugin_parse_test_results",
"plugin_terminal_session_close",
"plugin_terminal_session_spawn",
"plugin_prepare_debug_run",
"plugin_debug_attach_target",
"plugin_finish_operation",
"plugin_content_tab_action",
"plugin_post_events",
"plugin_event_kinds",
"plugin_status_items",
"plugin_context_keys",
"plugin_cancel_task",
"plugin_answer_prompt",
"plugin_choose_program",
"plugin_program",
"plugin_answer_command",
"plugin_answer_commit",
"plugin_commit_checks",
"mcp_set_open_editors",
"mcp_set_focused_editor",
"mcp_report_problems",
"plugin_decoration_sets",
"plugin_set_active_file",
"plugin_view_render",
"plugin_view_event",
"plugin_service_detail",
"plugin_service_log",
"plugin_navigation_files",
"plugin_navigation_invalidate",
"plugin_navigation_index",
"plugin_navigation_goto",
"plugin_navigation_markers",
"plugin_endpoints",
"plugin_run_targets",
"plugin_answer_run_target",
"plugin_line_markers",
];
#[derive(Clone, Serialize, Deserialize)]
pub struct SecretWrite {
@@ -435,10 +482,10 @@ impl RemotePlugins {
result
}
/// [`SYNC_PACKAGES`]; the plugin commands of remote windows are `#[command]`s.
/// The run-time commands of remote windows plus [`SYNC_PACKAGES`].
pub fn register(self: &Arc<Self>, d: &mut Dispatcher) {
let this = self.clone();
d.add(SYNC_PACKAGES, TrustClass::Trusted, move |c| {
d.add(SYNC_PACKAGES, move |c| {
let this = this.clone();
async move {
let packages: Vec<RemotePackage> = c.arg("packages")?;
@@ -446,9 +493,363 @@ impl RemotePlugins {
blocking(move || Ok(this.sync(packages, files.unwrap_or_default()))).await
}
});
let host = Arc::downgrade(&self.host);
let h = host.clone();
d.add("plugin_run_command", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let plugin_id: String = c.arg("pluginId")?;
let command_id: String = c.arg("commandId")?;
let arg: Option<String> = c.arg("arg")?;
let editor: Option<PluginEditor> = c.arg("editor")?;
let paths: Option<Vec<PathBuf>> = c.arg("paths")?;
let settings_scope: Option<SettingsScope> = c.arg("settingsScope")?;
let invocation = Invocation {
command_chain: c.arg::<Option<Vec<String>>>("commandChain")?.unwrap_or_default(),
client: Some(c.window.clone()),
workspace_root: c.host.project(&c.window).ok().map(|p| p.root.clone()),
editor: editor.map(PluginEditor::context),
selected_paths: paths.unwrap_or_default(),
global_settings: matches!(settings_scope, Some(SettingsScope::Global)),
};
super::commands::run_command(&c.host, host, plugin_id, command_id, arg, invocation, c.arg("request")?)
.await
}
});
let h = host.clone();
d.add("plugin_set_ui_locale", move |c| {
let h = h.clone();
async move {
alive(&h)?.set_ui_locale(&c.arg::<String>("tag")?);
Ok(())
}
});
let h = host.clone();
d.add("plugin_select_tests", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let config = c.arg::<String>("config")?;
let tests = c.arg("tests")?;
blocking(move || host.select_tests(&c.window, &config, tests)).await
}
});
let h = host.clone();
d.add("plugin_parse_test_results", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let config = c.arg::<String>("config")?;
let chunk = c.arg("chunk")?;
blocking(move || host.parse_test_results(&c.window, &config, chunk)).await
}
});
let h = host.clone();
d.add("plugin_terminal_session_close", move |c| {
let h = h.clone();
async move { alive(&h)?.close_terminal_session(&c.window, &c.arg::<String>("operation")?) }
});
let h = host.clone();
d.add("plugin_terminal_session_spawn", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let operation: String = c.arg("operation")?;
let cols = c.arg("cols")?;
let rows = c.arg("rows")?;
let output = c.channel("onOutput")?;
blocking(move || plugins.spawn_terminal_session(&c.host, &c.window, &operation, cols, rows, output))
.await
}
});
let h = host.clone();
d.add("plugin_prepare_debug_run", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let config = c.arg("config")?;
blocking(move || plugins.prepare_debug_run(&c.window, config)).await
}
});
let h = host.clone();
d.add("plugin_debug_attach_target", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let (config, run) = (c.arg::<String>("config")?, c.arg("run")?);
blocking(move || plugins.debug_attach_target(&c.host, &c.window, &config, run)).await
}
});
let h = host.clone();
d.add("plugin_finish_operation", move |c| {
let h = h.clone();
async move {
Ok(alive(&h)?.finish_operation(&c.window, &c.arg::<String>("id")?, c.arg("status")?, c.arg("stopped")?))
}
});
let h = host.clone();
d.add("plugin_content_tab_action", move |c| {
let h = h.clone();
async move { alive(&h)?.content_tab_action(&c.window, &c.arg::<String>("pluginId")?, c.arg("action")?) }
});
let h = host.clone();
d.add("plugin_post_events", move |c| {
let h = h.clone();
async move {
alive(&h)?.post_window_events(&c.window, c.arg("events")?, c.arg("editor")?);
Ok(())
}
});
let h = host.clone();
d.add("plugin_event_kinds", move |_| {
let h = h.clone();
async move { Ok(alive(&h)?.event_kinds().into_iter().collect::<Vec<_>>()) }
});
let h = host.clone();
d.add("plugin_status_items", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.status_snapshot(&c.window)) }
});
let h = host.clone();
d.add("plugin_context_keys", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.context_keys(Some(&c.window))) }
});
let h = host.clone();
d.add("plugin_cancel_task", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.cancel_task(&c.arg::<String>("taskId")?)) }
});
let h = host.clone();
d.add("plugin_answer_prompt", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.answer_prompt(&c.arg::<String>("promptId")?, c.arg("answer")?)) }
});
let h = host.clone();
d.add("plugin_choose_program", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let id: String = c.arg("pluginId")?;
let cap: String = c.arg("capability")?;
let scope: SettingsScope = c.arg("scope")?;
let path: Option<PathBuf> = c.arg("path")?;
let root = match scope {
SettingsScope::Global => None,
SettingsScope::Project => Some(c.host.project(&c.window)?.root.clone()),
};
blocking(move || host.choose_program(&id, &cap, root.as_deref(), path.as_deref())).await
}
});
let h = host.clone();
d.add("plugin_program", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let id: String = c.arg("pluginId")?;
let program: String = c.arg("program")?;
let scope: SettingsScope = c.arg("scope")?;
let root = match scope {
SettingsScope::Global => None,
SettingsScope::Project => Some(c.host.project(&c.window)?.root.clone()),
};
blocking(move || host.program_for_project(&id, &program, root.as_deref()).map(ide_core::IpcPath::from))
.await
}
});
let h = host.clone();
d.add("plugin_answer_command", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.answer_command(&c.window, &c.arg::<String>("requestId")?, c.arg("answer")?)) }
});
let h = host.clone();
d.add("plugin_answer_commit", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.answer_commit(&c.arg::<String>("requestId")?, c.arg("answer")?)) }
});
let h = host.clone();
d.add("plugin_commit_checks", move |c| {
let h = h.clone();
async move {
super::commit::commit_checks(
&c.host,
alive(&h)?,
&c.window,
c.arg("selection")?,
c.arg("checks")?,
c.arg("request")?,
)
.await
}
});
d.add("mcp_set_open_editors", |c| async move {
let paths: Vec<ide_core::IpcPath> = c.arg("paths")?;
c.host.project(&c.window)?;
c.host.mcp_reports.set_open_editors(&c.window, paths.into_iter().map(PathBuf::from).collect());
Ok(())
});
d.add("mcp_set_focused_editor", |c| async move {
c.host.project(&c.window)?;
c.host.mcp_reports.set_focused_editor(&c.window, c.arg("editor")?, c.arg("focused")?);
Ok(())
});
d.add("mcp_report_problems", |c| async move {
c.host.project(&c.window)?;
c.host.mcp_reports.report_problems(&c.window, c.arg("reset")?, c.arg("files")?);
Ok(())
});
let h = host.clone();
d.add("plugin_decoration_sets", move |_c| {
let h = h.clone();
async move { Ok(alive(&h)?.decoration_sets()) }
});
let h = host.clone();
d.add("plugin_set_active_file", move |c| {
let h = h.clone();
async move {
alive(&h)?.set_active_file(&c.window, c.arg("path")?);
Ok(())
}
});
let h = host.clone();
d.add("plugin_view_render", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
super::views::render(
&c.host,
plugins,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("viewport")?,
c.arg("doc")?,
c.arg("editor")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_view_event", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
super::views::event(
&c.host,
plugins,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("event")?,
c.arg("doc")?,
c.arg("editor")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_service_detail", move |c| {
let h = h.clone();
async move {
super::views::service_detail(
&c.host,
alive(&h)?,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("key")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_service_log", move |c| {
let h = h.clone();
async move {
super::views::service_log(
&c.host,
alive(&h)?,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("key")?,
c.arg("tab")?,
c.arg("on")?,
c.arg("request")?,
c.sender("onLine")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_navigation_files", move |c| {
let h = h.clone();
async move { super::index_ops::plugin_navigation_files(&c.host, alive(&h)?, &c.window).await }
});
let h = host.clone();
d.add("plugin_navigation_invalidate", move |c| { let h = h.clone(); async move {
super::index_ops::plugin_navigation_invalidate(&c.host, alive(&h)?, &c.window, c.arg("paths")?)
} });
let h = host.clone();
d.add("plugin_navigation_index", move |c| {
let h = h.clone();
async move {
super::index_ops::plugin_navigation_index(
&c.host,
alive(&h)?,
&c.window,
c.arg("paths")?,
c.arg("request")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_navigation_goto", move |c| {
let h = h.clone();
async move {
super::index_ops::plugin_navigation_goto(&c.host, alive(&h)?, &c.window, c.arg("doc")?, c.arg("pos")?)
.await
}
});
let h = host.clone();
d.add("plugin_navigation_markers", move |c| {
let h = h.clone();
async move {
super::index_ops::plugin_navigation_markers(&c.host, alive(&h)?, &c.window, c.arg("paths")?).await
}
});
let h = host.clone();
d.add("plugin_endpoints", move |c| {
let h = h.clone();
async move { super::index_ops::plugin_endpoints(&c.host, alive(&h)?, &c.window, c.arg("pluginId")?).await }
});
let h = host.clone();
d.add("plugin_run_targets", move |c| {
let h = h.clone();
async move { super::run_targets::list(&c.host, alive(&h)?.as_ref(), &c.window) }
});
let h = host.clone();
d.add("plugin_answer_run_target", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let id: String = c.arg("id")?;
let use_target = c.arg("useTarget")?;
blocking(move || super::run_targets::answer(&c.host, &plugins, &c.window, &id, use_target)).await
}
});
d.add("plugin_line_markers", |c| async move {
crate::ops::lsp::plugin_line_markers(&c.host, &c.window, c.arg("doc")?).await
});
}
}
fn alive(host: &Weak<PluginHost>) -> IdeResult<Arc<PluginHost>> {
host.upgrade().ok_or_else(|| IdeError::unavailable("the plugin host has shut down"))
}
async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
-26
Переглянути файл
@@ -1,12 +1,9 @@
//! Project-owned registrations, retained across idle instance reclamation.
use super::api::{PluginApi, Shared};
use super::{PluginEvent, PluginHost};
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult};
use ide_plugin::{HostError, PluginRunTarget};
use std::path::{Path, PathBuf};
use std::sync::Arc;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
@@ -154,27 +151,6 @@ impl PluginHost {
}
}
#[command(trust = trusted)]
pub async fn plugin_run_targets(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
) -> IdeResult<Vec<RegisteredRunTarget>> {
list(host, plugins, window)
}
#[command(trust = trusted)]
pub async fn plugin_answer_run_target(
host: &Arc<Host>,
plugins: &Arc<PluginHost>,
window: &str,
id: String,
use_target: bool,
) -> IdeResult<ide_core::settings::Settings> {
let (shared, plugins, window) = (host.clone(), plugins.clone(), window.to_owned());
host.blocking(move || answer(&shared, &plugins, &window, &id, use_target)).await
}
pub fn list(host: &crate::Host, plugins: &PluginHost, window: &str) -> IdeResult<Vec<RegisteredRunTarget>> {
Ok(plugins.run_targets(&host.project(window)?.root))
}
@@ -218,5 +194,3 @@ pub fn answer(
plugins.shared.sink.emit(None, PluginEvent::RunTargetsChanged);
Ok(project.settings.effective())
}
ide_command::domain!(plugins_run_targets: plugin_answer_run_target, plugin_run_targets);
+13 -34
Переглянути файл
@@ -4,7 +4,6 @@
//! the desktop for local projects, `openidea-server` for remote ones.
use super::{PluginEditor, PluginHost, PluginOutputLine};
use ide_command::command;
use ide_core::{DocId, IdeError, IdeResult};
use ide_plugin::{EditorContext, Invocation, ServiceTab, View, ViewEvent, Viewport};
use std::sync::Arc;
@@ -39,13 +38,10 @@ async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + '
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Content of a plugin view (`doc`: the document of a custom editor; `editor`: for
/// a tool window, the window's active editor, as commands get it).
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn plugin_view_render(
pub async fn render(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
plugin_id: String,
view: String,
@@ -53,17 +49,14 @@ pub async fn plugin_view_render(
doc: Option<DocId>,
editor: Option<PluginEditor>,
) -> IdeResult<View> {
let plugins = plugins.clone();
let invocation = view_invocation(host, window, doc, editor)?;
blocking(move || plugins.render_view(&plugin_id, &view, viewport, invocation)).await
}
/// A user action in a plugin view or custom editor (`doc`, `editor`: as for rendering).
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn plugin_view_event(
pub async fn event(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
plugin_id: String,
view: String,
@@ -71,45 +64,39 @@ pub async fn plugin_view_event(
doc: Option<DocId>,
editor: Option<PluginEditor>,
) -> IdeResult<()> {
let plugins = plugins.clone();
let invocation = view_invocation(host, window, doc, editor)?;
blocking(move || plugins.view_event(&plugin_id, &view, event, invocation)).await
}
/// The Services pane of node `key` of a plugin's `location = "services"` view.
#[command(trust = trusted)]
pub async fn plugin_service_detail(
/// The Services pane of node `key` of a plugin's services view.
pub async fn service_detail(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
plugin_id: String,
view: String,
key: String,
) -> IdeResult<Vec<ServiceTab>> {
let plugins = plugins.clone();
let invocation = view_invocation(host, window, None, None)?;
blocking(move || plugins.service_detail(&plugin_id, &view, &key, invocation)).await
}
/// Runs the program of the log tab `tab` of node `key`'s Services pane (with
/// the toggles in `on`), streaming its output until it exits or `request` is
/// cancelled; returns the exit code.
/// Runs the program of the log tab `tab` of node `key`'s pane in the window's
/// project root, streaming its lines until it exits or request `request` is
/// cancelled; returns its exit code.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn plugin_service_log(
pub async fn service_log(
host: &crate::Host,
plugins: &Arc<PluginHost>,
plugins: Arc<PluginHost>,
window: &str,
request: ide_core::RequestId,
plugin_id: String,
view: String,
key: String,
tab: String,
on: Vec<String>,
request: ide_core::RequestId,
on_line: crate::ops::Channel<PluginOutputLine>,
) -> IdeResult<Option<i32>> {
// Runs in the window's project root.
let plugins = plugins.clone();
let invocation = view_invocation(host, window, None, None)?;
let cancel = host.begin_project_read_request(window, request);
let result = blocking(move || {
@@ -150,11 +137,3 @@ mod tests {
assert!(view_invocation(&host, "main", None, None).unwrap().editor.is_none());
}
}
ide_command::domain!(
plugins_views:
plugin_service_detail,
plugin_service_log,
plugin_view_event,
plugin_view_render,
);
+11 -7
Переглянути файл
@@ -306,7 +306,7 @@ impl Host {
}
{
let documents = documents.clone();
lsp.set_apply_edit_hook(Box::new(move |edit| documents.apply_workspace_edit(&edit).is_ok()));
lsp.set_apply_edit_hook(Box::new(move |edit| apply_workspace_edit(&documents, &edit).is_ok()));
}
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
@@ -1320,6 +1320,11 @@ impl Project {
}
}
/// Applies a multi-file edit through the document layer so open editors update live.
pub fn apply_workspace_edit(documents: &Documents, edit: &ide_core::WorkspaceEdit) -> IdeResult<()> {
documents.apply_workspace_edit(edit)
}
/// Files the watcher reports per batch that Local History snapshots.
const HISTORY_BATCH_LIMIT: usize = 500;
@@ -2144,12 +2149,11 @@ mod workspace_edit_tests {
version: None,
edits: vec![TextEdit { range: Range::new(Pos::new(0, 0), Pos::new(0, 3)), new_text: "sum_values".into() }],
};
documents
.apply_workspace_edit(&WorkspaceEdit {
files: vec![changes(real.clone()), changes(alias)],
..Default::default()
})
.unwrap();
apply_workspace_edit(
&documents,
&WorkspaceEdit { files: vec![changes(real.clone()), changes(alias)], ..Default::default() },
)
.unwrap();
assert_eq!(std::fs::read_to_string(real).unwrap(), "sum_values();\n");
assert_eq!(documents.snapshot(doc.id).unwrap().text, "sum_values();\n");
}
+170 -24
Переглянути файл
@@ -15,15 +15,15 @@
//! remote project (`plugins::remote_host`).
use crate::Host;
use crate::catalogue::TrustClass;
use crate::ops::{self, Emit};
use ide_core::{IdeError, IdeEvent, IdeResult};
use ide_core::{IdeError, IdeEvent, IdeResult, RequestId, TaskId};
use ide_jsonrpc::{Handler, Peer, codes};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;
use std::future::Future;
use std::path::PathBuf;
use std::pin::Pin;
use std::sync::{Arc, OnceLock};
@@ -104,28 +104,30 @@ impl Call {
type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
type HandlerFn = Arc<dyn Fn(Call) -> BoxFuture<IdeResult<Value>> + Send + Sync>;
/// Commands the server answers, by name, each with the trust class it declares.
/// Commands the server answers, by name.
#[derive(Default, Clone)]
pub struct Dispatcher {
handlers: HashMap<&'static str, (TrustClass, HandlerFn)>,
handlers: HashMap<&'static str, HandlerFn>,
}
impl Dispatcher {
pub fn add<F, Fut, T>(&mut self, name: &'static str, trust: TrustClass, f: F) -> &mut Self
pub fn add<F, Fut, T>(&mut self, name: &'static str, f: F) -> &mut Self
where
F: Fn(Call) -> Fut + Send + Sync + 'static,
Fut: Future<Output = IdeResult<T>> + Send + 'static,
T: Serialize,
{
let f = Arc::new(f);
let handler: HandlerFn = Arc::new(move |call| {
let fut = f(call);
Box::pin(async move {
let value = fut.await?;
serde_json::to_value(value).map_err(|e| IdeError::internal(e.to_string()))
})
});
assert!(self.handlers.insert(name, (trust, handler)).is_none(), "command {name} is registered twice");
self.handlers.insert(
name,
Arc::new(move |call| {
let fut = f(call);
Box::pin(async move {
let value = fut.await?;
serde_json::to_value(value).map_err(|e| IdeError::internal(e.to_string()))
})
}),
);
self
}
@@ -135,15 +137,150 @@ impl Dispatcher {
out
}
/// The trust class `name` was registered with.
pub fn trust(&self, name: &str) -> Option<TrustClass> {
self.handlers.get(name).map(|(trust, _)| *trust)
}
/// The commands every project host answers: those declared with `#[command]`.
/// The commands of the core remote slice: project, files, documents, search,
/// terminals, runs and VCS status.
pub fn standard() -> Self {
let mut d = Self::default();
ops::register_domains(&mut d);
d.add("project_trust_status", |c| async move { c.host.trust.status(&c.arg::<PathBuf>("path")?) })
.add("project_trust_list", |c| async move { c.host.trust.decisions() })
.add("project_trust_set", |c| async move {
c.host.set_project_trust(&c.arg::<PathBuf>("path")?, c.arg("trusted")?, c.arg("folder")?).await
})
.add("project_trust_remove_location", |c| async move {
c.host.trust.remove_location(&c.arg::<PathBuf>("path")?)?;
c.host.refresh_project_trust().await
});
d.add("open_project", |c| async move {
let path: PathBuf = c.arg("path")?;
let project = ops::project::open(&c.host, &c.window, &path).await?;
Ok(ops::project::info(&project))
})
.add("project_current", |c| async move { Ok(ops::project::current(&c.host, &c.window)) })
.add("close_project", |c| async move {
c.host.close_project(&c.window);
Ok(())
})
.add("jvm_file_presentations", |c| async move {
ops::jvm_icons::jvm_file_presentations(&c.host, &c.window, c.arg("paths")?).await
})
.add("project_roots", |c| async move { ops::project::roots(&c.host, &c.window) })
.add("settings_get", |c| async move { Ok(ops::project::settings(&c.host, &c.window)) })
.add("settings_removed_theme", |c| async move { Ok(ops::project::settings_removed_theme(&c.host, &c.window)) })
.add("settings_set", |c| async move {
let key: String = c.arg("key")?;
let scope = c.arg("scope")?;
let applied = ops::project::set_settings(&c.host, &c.window, scope, &key, &c.arg::<String>("value")?)?;
let sink = c.host.window_sink(&c.window);
sink.emit(IdeEvent::SettingsChanged { key });
if let Some(root) = applied.roots_changed {
sink.emit(IdeEvent::ProjectRootsChanged { root });
}
Ok(applied.settings)
})
.add("cancel_request", |c| async move {
c.host.cancel_request(c.arg::<RequestId>("id")?);
Ok(())
})
.add("cancel_task", |c| async move { Ok(ide_core::task::cancel(c.arg::<TaskId>("id")?)) })
.add("fs_read_dir", |c| async move { ops::fs::read_dir(&c.host, &c.window, c.arg("path")?).await })
.add("fs_entry_kind", |c| async move { ops::fs::entry_kind(&c.host, c.arg("path")?).await })
.add("fs_create_file", |c| async move { ops::fs::create_file(&c.host, &c.window, c.arg("path")?) })
.add("fs_create_file_bytes", |c| async move {
ops::fs::create_file_bytes(&c.host, &c.window, c.arg("path")?, c.arg("data")?).await
})
.add("fs_create_dir", |c| async move { ide_vfs::create_dir(&c.arg::<PathBuf>("path")?) })
.add("fs_rename", |c| async move { ops::fs::rename(&c.host, &c.window, c.arg("from")?, c.arg("to")?).await })
.add("fs_set_writable", |c| async move {
ops::fs::set_writable(&c.host, &c.window, c.arg("path")?, c.arg("writable")?)
})
.add("fs_delete", |c| async move { ops::fs::delete(&c.host, &c.window, c.arg("path")?).await })
.add("fs_copy", |c| async move { ops::fs::copy(&c.host, &c.window, c.arg("from")?, c.arg("to")?).await })
.add("fs_copy_merge", |c| async move {
ops::fs::copy_merge(
&c.host,
&c.window,
c.arg("sourceRoot")?,
c.arg("destinationRoot")?,
c.arg("path")?,
c.arg("overwrite")?,
)
.await
})
.add("fs_compare_directories", |c| async move {
ops::fs::compare_directories(
&c.host,
&c.window,
c.arg("left")?,
c.arg("right")?,
c.arg("request")?,
c.sender("onProgress")?,
)
.await
})
.add("fs_read_text", |c| async move { ops::fs::read_text(&c.host, &c.window, c.arg("path")?).await })
.add("doc_open", |c| async move { ops::doc::open(&c.host, &c.window, c.arg("path")?).await })
.add("doc_open_untitled", |c| async move {
ops::doc::open_untitled(&c.host, &c.window, c.arg::<Option<String>>("name")?).await
})
.add(
"doc_save_as",
|c| async move { ops::doc::save_as(&c.host, &c.window, c.arg("doc")?, c.arg("path")?).await },
)
.add("doc_close", |c| async move {
ops::doc::blocking(move || ops::doc::close(&c.host, &c.window, c.arg("doc")?)).await
})
.add("doc_edit", |c| async move {
ops::doc::blocking(move || {
ops::doc::edit(&c.host, &c.window, c.arg("doc")?, c.arg("baseVersion")?, c.arg("changes")?)
})
.await
})
.add("doc_save", |c| async move { ops::doc::save(&c.host, &c.window, c.arg("doc")?).await })
.add("doc_save_all", |c| async move { ops::doc::save_all(&c.host, &c.window).await })
.add("doc_sync_from_disk", |c| async move { ops::doc::sync_from_disk(&c.host, &c.window).await })
.add("doc_snapshot", |c| async move { ops::doc::snapshot(&c.host, &c.window, c.arg("doc")?).await })
.add("search_start", |c| async move {
let on_event = c.channel("onEvent")?;
ops::search::start(&c.host, &c.window, c.arg("request")?, c.arg("query")?, on_event).await
})
.add("term_spawn", |c| async move {
let on_output = c.channel("onOutput")?;
ops::term::spawn(&c.host, &c.window, c.arg("options")?, on_output)
})
.add("term_store_image", |c| async move {
ops::term::store_image(&c.host, c.arg("id")?, c.arg("data")?, c.arg("mime")?).await
})
.add("term_write", |c| async move { ops::term::write(&c.host, c.arg("id")?, &c.arg::<String>("data")?) })
.add("term_resize", |c| async move { ops::term::resize(&c.host, c.arg("id")?, c.arg("cols")?, c.arg("rows")?) })
.add("term_kill", |c| async move { ops::term::kill(&c.host, c.arg("id")?) })
.add("term_is_busy", |c| async move { ops::term::is_busy(&c.host, c.arg("id")?) })
.add("term_default_shell", |_| async move { Ok(ide_terminal::default_shell_path()) })
.add("term_available_shells", |_| async move { Ok(ide_terminal::available_shells()) })
.add("run_configs", |c| async move { ops::doc::blocking(move || ops::run::configs(&c.host, &c.window)).await })
.add("run_save_configs", |c| async move {
ops::run::save_configs(
&c.host,
&c.window,
&c.arg::<Vec<ide_run::RunConfig>>("configs")?,
&c.arg::<Option<Vec<String>>>("removedDetectedIds")?.unwrap_or_default(),
)
})
.add("run_without_derived", |c| async move { ops::run::without_derived(&c.host, &c.window, c.arg("configs")?) })
.add("run_apply_settings", |c| async move { ops::run::apply_settings(&c.host, &c.window, c.arg("configs")?) })
.add("run_system_env", |_| async move { Ok(ide_run::system_env()) })
.add("run_start", |c| async move {
let on_output = c.channel("onOutput")?;
ops::run::start_request(&c.host, &c.window, c.arg("config")?, on_output, c.arg("request")?).await
})
.add("run_stop", |c| async move { ops::run::stop(&c.host, &c.window, c.arg("id")?) })
.add("web_url", |c| async move { ops::web::url(&c.host, &c.window, &c.arg::<PathBuf>("path")?).await })
.add("run_stdin", |c| async move { ops::run::stdin(&c.host, c.arg("id")?, &c.arg::<String>("data")?) })
.add("run_resize", |c| async move { ops::run::resize(&c.host, c.arg("id")?, c.arg("cols")?, c.arg("rows")?) })
.add("run_close_stdin", |c| async move { ops::run::close_stdin(&c.host, c.arg("id")?) })
.add("run_list", |c| async move { Ok(ops::run::list(&c.host)) })
.add("vcs_status", |c| async move { ops::vcs::status(&c.host, &c.window).await })
.add("vcs_status_paths", |c| async move { ops::vcs::status_paths(&c.host, &c.window, c.arg("paths")?).await });
ops::register_all(&mut d);
d
}
}
@@ -198,8 +335,6 @@ pub fn client_accepts(event: &IdeEvent) -> bool {
| IdeEvent::LanguageServerWarning { .. }
| IdeEvent::LanguageServerRemoved { .. }
| IdeEvent::LspRefresh { .. }
| IdeEvent::LspMessageRequest { .. }
| IdeEvent::LspMessageRequestDone { .. }
| IdeEvent::TerminalExited { .. }
| IdeEvent::RunExited { .. }
| IdeEvent::Debug { .. }
@@ -212,6 +347,17 @@ pub fn client_accepts(event: &IdeEvent) -> bool {
}
}
/// The commands a desktop routes to its server: what `openidea-server` of this build answers,
/// fixed here rather than taken from the server, so a server cannot move a command to this machine.
pub fn client_commands() -> Vec<&'static str> {
let mut out = Dispatcher::standard().commands();
out.extend(crate::plugins::remote_host::COMMANDS);
out.push(crate::plugins::remote::SYNC_COMMAND);
out.sort_unstable();
out.dedup();
out
}
struct PeerSink {
peer: Arc<OnceLock<Peer>>,
window: Option<String>,
@@ -252,10 +398,10 @@ impl Handler for ServerHandler {
"invoke" => {
let call: Invoke =
serde_json::from_value(params).map_err(|e| (codes::INVALID_PARAMS, e.to_string()))?;
let Some((trust, handler)) = self.dispatcher.handlers.get(call.cmd.as_str()).cloned() else {
let Some(handler) = self.dispatcher.handlers.get(call.cmd.as_str()).cloned() else {
return Err((codes::METHOD_NOT_FOUND, format!("command {} is not available remotely", call.cmd)));
};
self.host.authorize(&call.window, trust).map_err(error_reply)?;
self.host.authorize_command(&call.window, &call.cmd).map_err(error_reply)?;
let c = Call { host: self.host.clone(), window: call.window, args: call.args, peer: self.peer.clone() };
// Requests run on blocking-capable threads: wait for the command here.
self.host.runtime.block_on(handler(c)).map_err(error_reply)
+367 -5
Переглянути файл
@@ -1,5 +1,4 @@
//! User-owned project execution decisions. Project settings never grant trust.
use crate::catalogue::TrustClass;
use ide_core::{IdeError, IdeResult};
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
@@ -305,15 +304,366 @@ impl crate::Host {
}
}
/// Commands allowed in Restricted Mode, by exact name: those which only inspect/edit source or
/// operate user-owned application state. A new command is denied until deliberately listed here.
pub fn restricted_command_allowed(cmd: &str) -> bool {
matches!(
cmd,
"fs_compare_directories"
| "fs_copy"
| "fs_copy_merge"
| "fs_create_dir"
| "fs_create_file"
| "fs_create_file_bytes"
| "fs_delete"
| "fs_entry_kind"
| "fs_open_with_system"
// The user's own diff program (global settings) on the diff's two sides.
| "diff_external_tool"
| "fs_probe"
| "fs_read_dir"
| "fs_read_image"
| "fs_read_range"
| "fs_read_text"
| "fs_rename"
| "fs_resolve_reference"
| "fs_set_writable"
| "doc_close"
| "doc_edit"
| "doc_folding"
| "doc_highlights"
| "doc_language"
| "doc_open"
| "doc_open_untitled"
| "doc_open_virtual"
| "doc_outline"
| "doc_python_facts"
| "doc_save"
| "doc_save_as"
| "doc_save_all"
| "doc_selection_ranges"
| "doc_set_bom"
| "doc_set_encoding"
| "doc_set_line_ending"
| "doc_snapshot"
| "doc_sync_from_disk"
| "syntax_errors"
| "syntax_expression_at"
| "syntax_identifiers"
| "syntax_identifiers_in_files"
| "syntax_locals"
| "syntax_node_at"
| "syntax_structural_ranges"
| "syntax_support"
| "search_start"
| "search_validate"
| "nav_index_definitions"
| "nav_inheritance"
| "nav_resolve_module"
| "history_content"
| "history_list"
| "history_list_dir"
| "history_put_label"
| "history_restore"
| "spell_check"
| "spell_suggest"
| "analysis_locate_duplicates"
| "structural_languages"
| "structural_search"
| "structural_validate"
| "refactor_can_undo_file_move"
| "refactor_file_move_edits"
| "refactor_file_move_text_edits"
| "refactor_move_files"
| "refactor_undo_file_move"
| "window_close_context"
| "window_complete_launch"
| "window_cycle"
| "window_flash_taskbar"
| "window_group_cancel_close"
| "window_group_close"
| "window_group_close_tabs"
| "window_group_current"
| "window_group_detach"
| "window_group_merge"
| "window_group_reorder"
| "window_group_restore"
| "window_group_select"
| "window_is_fullscreen"
| "window_new"
| "window_open_comparison"
| "window_open_deployment"
| "window_open_diff"
| "window_open_file_in_new_window"
| "window_open_files"
| "window_open_project"
| "window_open_projects"
| "window_open_remote"
| "window_open_settings"
| "window_set_titlebar_height"
| "window_start_drag"
| "window_take_launch"
| "window_toggle_fullscreen"
| "window_toggle_zoom"
| "term_available_shells"
| "term_default_shell"
| "term_is_busy"
| "term_kill"
| "term_resize"
| "term_spawn"
| "term_store_image"
| "term_write"
| "settings_export"
| "settings_get"
| "settings_get_global"
| "settings_removed_theme"
| "settings_import"
| "settings_list_jetbrains_ides"
| "settings_read_jetbrains"
| "settings_set"
| "project_trust_add_location"
| "project_trust_list"
| "project_trust_remove_location"
| "project_trust_set"
| "project_trust_status"
// New Project writes only where the user chose and runs no code of an open project.
| "scaffold_catalog"
| "scaffold_create"
| "scaffold_options"
| "scaffold_requirements"
| "ssh_askpass_answer"
| "ssh_connected"
| "ssh_disconnect"
| "ssh_needs_secret"
| "ssh_open_terminal"
| "ssh_password_saved"
| "ssh_set_secret"
| "ssh_test"
| "ssh_trust_host"
| "git_credential_forget"
| "git_credentials"
| "app_info"
| "app_build_info"
| "app_cli_install"
| "app_cli_uninstall"
| "app_log_location"
| "app_check_update"
| "app_update_window_ready"
| "app_update_status"
| "app_update_announcement"
| "app_install_update"
| "caches_schedule_invalidation"
| "clear_caches"
| "clipboard_file_list"
| "clipboard_has_files"
| "clipboard_has_image"
| "clipboard_image"
| "clipboard_set_file_list"
| "clipboard_write_text"
| "jdk_download_vendors"
| "jdk_download_releases"
| "jdk_download_location"
| "jdk_download"
| "jdtls_required_java"
| "run_system_env"
| "run_gradle_jvm_args_script"
| "proxy_check_connection"
| "docker_settings"
| "docker_save_settings"
| "docker_set_registry_password"
| "docker_run_env"
| "db_console_path"
| "db_consoles"
| "db_export_file"
| "vcs_write_patch"
| "app_metrics"
| "app_quit"
| "app_cancel_quit"
| "app_restart"
| "languages"
| "menu_refresh"
| "menu_model"
| "menu_configure"
| "menu_set_disabled"
| "prepare_workspace_edit"
| "apply_workspace_edit"
| "undo_workspace_edit"
| "redo_workspace_edit"
| "lsp_servers"
| "lsp_resend_diagnostics"
| "recent_projects"
| "remove_recent_project"
| "recent_project_groups"
| "set_recent_project_groups"
| "open_project"
| "close_project"
| "project_current"
| "project_roots"
| "index_status"
| "index_file_extensions"
| "jvm_file_presentations"
| "deploy_coverage"
| "deploy_test_connection"
| "find_files"
| "find_files_named"
| "find_dirs"
| "find_symbols"
| "find_symbols_named"
| "mark_recent"
| "remove_recent"
| "recent_files"
| "web_goto"
| "path_completions"
| "web_unresolved_references"
| "project_rename"
| "light_edit_open"
| "light_edit_open_untitled"
| "workspace_create"
| "workspace_discover_projects"
| "workspace_update"
| "workspace_attach"
| "cancel_request"
| "cancel_task"
| "log_frontend"
| "env_reload"
| "remote_invoke"
| "remote_current"
| "remote_disconnect"
| "remote_connect"
| "remote_trust_status"
| "remote_trust_set"
| "remote_bootstrap_list"
| "wsl_distros"
| "wsl_resolve"
| "remote_list"
| "remote_open"
| "remote_of"
| "web_browsers"
| "web_url"
| "web_open"
| "debug_attachable_processes"
| "agent_subscribe"
| "agent_entries"
| "agent_commands"
| "agent_unqueue"
| "agent_cancel"
| "agent_stop_background"
| "agent_archive"
| "agent_unarchive"
| "agent_registry_list"
| "agent_registry_install"
| "agent_registry_remove"
| "agent_mcp_list"
| "agent_mcp_save"
| "agent_mcp_save_json"
| "agent_mcp_set_enabled"
| "agent_mcp_remove"
| "agent_mcp_import"
| "agent_mcp_discover_sources"
| "agent_mcp_import_selected"
| "agent_set_mcp_overrides"
| "coverage_import"
| "system_font_families"
| "user_font_data"
| "plugin_subscribe"
| "plugin_list"
| "plugin_set_active_file"
| "plugin_set_theme"
| "plugin_set_theme_frame"
| "plugin_catalog"
| "plugin_assets"
| "plugin_set_ui_locale"
| "plugin_market"
| "plugin_market_url"
| "plugin_set_market_url"
| "plugin_market_download"
| "plugin_unpack_package"
| "plugin_stage_package"
| "plugin_preview_install"
| "plugin_read_intellij_theme"
| "plugin_installed_intellij_themes"
| "notebook_open"
| "notebook_get"
| "notebook_edit"
| "notebook_save"
| "notebook_undo"
| "notebook_redo"
| "notebook_reload"
| "notebook_close"
| "notebook_interrupt"
| "run_stop"
| "run_list"
| "debug_stop"
| "debug_sessions"
| "vcs_clone"
| "vcs_init"
| "vcs_status"
| "vcs_status_paths"
| "vcs_roots"
| "vcs_branch_info"
| "vcs_line_hunks"
| "vcs_file_at"
| "vcs_blame"
| "vcs_block_history"
| "vcs_log"
| "vcs_log_refs"
| "vcs_log_users"
| "vcs_log_details"
| "vcs_log_details_batch"
| "vcs_revision_children"
| "vcs_revision_files"
| "vcs_open_external_log"
| "vcs_commit_files"
| "vcs_commits_changes"
| "vcs_branches"
| "vcs_stashes"
| "vcs_conflict_versions"
| "vcs_diff_text"
| "vcs_diff_hunks"
| "vcs_detected_git"
| "vcs_config_get"
| "vcs_tags"
| "vcs_remotes"
| "vcs_worktrees"
| "vcs_diff_with_worktree"
| "vcs_compare_scope"
| "vcs_compare_paths"
| "vcs_diff_revisions"
| "vcs_diff_numstat"
| "vcs_merge_base"
| "vcs_has_hook"
| "vcs_shelves"
| "vcs_shelf_patch"
| "vcs_changelists_load"
) || cmd.starts_with("plugin:")
}
/// Commands that change which plugin code runs: allowed where no project is open (the
/// welcome screen), otherwise only in a trusted project.
pub fn projectless_command_allowed(cmd: &str) -> bool {
matches!(
cmd,
"plugin_install_dir"
| "plugin_uninstall"
| "plugin_set_enabled"
| "plugin_grant"
| "plugin_set_capability"
| "plugin_revoke_net_host"
| "plugin_choose_program"
| "plugin_program"
| "plugin_roll_back"
| "plugin_reload"
)
}
impl crate::Host {
/// Whether `window` may run a command of class `trust`.
pub fn authorize(&self, window: &str, trust: TrustClass) -> IdeResult<()> {
if trust == TrustClass::Always {
pub fn authorize_command(&self, window: &str, command: &str) -> IdeResult<()> {
if restricted_command_allowed(command) {
return Ok(());
}
match self.project(window) {
Ok(project) => project.require_trust(),
Err(_) if trust == TrustClass::OutsideRestricted => Ok(()),
Err(_) if projectless_command_allowed(command) => Ok(()),
Err(error) => Err(error),
}
}
@@ -337,6 +687,18 @@ impl TrustStore {
#[cfg(test)]
mod tests {
#[test]
fn restricted_mode_allows_clipboard_write_text() {
assert!(super::restricted_command_allowed("clipboard_write_text"));
}
#[test]
fn restricted_mode_denies_new_commands_whatever_their_name() {
for cmd in ["fs_new_command", "term_new_command", "ssh_new_command", "settings_new_command", "git_credential_x"]
{
assert!(!super::restricted_command_allowed(cmd), "{cmd} is allowed without being listed");
}
}
#[test]
fn remote_project_decisions_are_kept_on_this_machine() {
+1 -1
Переглянути файл
@@ -19,7 +19,7 @@ fn remember_codex_modes(data: &Path) {
}
fn codex_mode(host: &Host) -> Option<String> {
let providers = ide_host::ops::agent::agent_providers(host, "main").unwrap();
let providers = ide_host::ops::agent::providers(host, "main").unwrap();
let codex = providers.into_iter().find(|p| p.id == "codex").expect("codex is listed");
codex.config.into_iter().find(|o| o.id == "mode").and_then(|o| o.current)
}
+3 -3
Переглянути файл
@@ -31,7 +31,7 @@ fn open(host: &Host, tmp: &tempfile::TempDir) {
}
fn env_of(host: &Host, id: &str) -> BTreeMap<String, String> {
let providers = ide_host::ops::agent::agent_providers(host, "main").unwrap();
let providers = ide_host::ops::agent::providers(host, "main").unwrap();
providers.into_iter().find(|p| p.id == id).unwrap_or_else(|| panic!("{id}")).env
}
@@ -42,7 +42,7 @@ async fn agent_environment_values_stay_out_of_agent_files() {
let host = host(tmp.path());
open(&host, &tmp);
let env = BTreeMap::from([("ANTHROPIC_API_KEY".to_owned(), VALUE.to_owned())]);
ide_host::ops::agent::agent_set_env(&host, "main", "claude".into(), env.clone()).unwrap();
ide_host::ops::agent::set_env(&host, "main", "claude".into(), env.clone()).unwrap();
ide_host::ops::agent::save_custom_agent(
&host,
"main",
@@ -63,7 +63,7 @@ async fn agent_environment_values_stay_out_of_agent_files() {
assert_eq!(env_of(&host, "claude"), env);
assert_eq!(env_of(&host, "mine"), env);
ide_host::ops::agent::remove_custom_agent(&host, "main", "mine".into()).unwrap();
ide_host::ops::agent::agent_set_env(&host, "main", "claude".into(), BTreeMap::new()).unwrap();
ide_host::ops::agent::set_env(&host, "main", "claude".into(), BTreeMap::new()).unwrap();
assert_eq!(host.agent_secrets.keys("agent/"), Vec::<String>::new());
host.close_project("main");
}
+1 -4
Переглянути файл
@@ -3,10 +3,7 @@
use ide_agent::{McpScope, McpServer, McpServerInput};
use ide_core::NullSink;
use ide_core::settings::McpTransport;
use ide_host::ops::agent::{
agent_mcp_import as mcp_import, agent_mcp_list as mcp_list, agent_mcp_save as mcp_save,
agent_mcp_set_enabled as mcp_set_enabled,
};
use ide_host::ops::agent::{mcp_import, mcp_list, mcp_save, mcp_set_enabled};
use ide_host::{Host, HostConfig};
use std::path::{Path, PathBuf};
use std::sync::Arc;
+2 -2
Переглянути файл
@@ -68,7 +68,7 @@ done
}
for _ in 0..20 {
for window in ["first", "second"] {
let state = ops::agent::agent_refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
assert!(state.refreshing);
}
}
@@ -87,7 +87,7 @@ done
assert!(completed.is_ok(), "both windows must receive the completed catalog");
for _ in 0..20 {
for window in ["first", "second"] {
let catalog = ops::agent::agent_refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
assert!(!catalog.refreshing);
assert!(catalog.retry_at_ms.is_some());
let models = catalog.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();
+3 -6
Переглянути файл
@@ -40,12 +40,9 @@ fn closing_a_project_closes_its_terminals_and_keeps_other_windows() {
}));
host.trust.decide(&root, true, false).unwrap();
host.open_project("main", &root).unwrap();
let project_shell = ops::term::term_spawn(&host, "main", options(&root), ops::Channel::new(|_| {}))
.await
.expect("project terminal");
let other_shell = ops::term::term_spawn(&host, "other", options(&root), ops::Channel::new(|_| {}))
.await
.expect("other terminal");
let project_shell =
ops::term::spawn(&host, "main", options(&root), Arc::new(|_| {})).expect("project terminal");
let other_shell = ops::term::spawn(&host, "other", options(&root), Arc::new(|_| {})).expect("other terminal");
assert_eq!(host.terminals.list().len(), 2);
host.close_project("main");
+3 -4
Переглянути файл
@@ -101,7 +101,7 @@ async fn compose_target_is_the_python_interpreter() {
set("runTargets", serde_json::json!([{ "kind": "compose", "id": "web", "name": "Compose web", "service": "web" }]));
// A local interpreter: Django is only in the image.
ops::doc::doc_open(&host, WINDOW, main.clone()).await.unwrap();
ops::doc::open(&host, WINDOW, main.clone()).await.unwrap();
let before = diagnostics(&events, &main, Duration::from_secs(120), unresolved).await;
eprintln!("local interpreter: {before:?}");
@@ -140,16 +140,15 @@ async fn compose_target_is_the_python_interpreter() {
allow_parallel: false,
extras: Default::default(),
};
ops::run::run_start(
ops::run::start(
&host,
WINDOW,
config,
ide_host::ops::Channel::new(move |chunk| match chunk {
Arc::new(move |chunk| match chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => {
sink.lock().unwrap().push_str(&text)
}
}),
None,
)
.await
.unwrap();
+4 -1
Переглянути файл
@@ -22,7 +22,10 @@ async fn split_storage_keeps_user_history_and_uses_local_tools_and_caches() {
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
assert_eq!(std::path::PathBuf::from(ops::tools::jdk_download_location(&host).unwrap()), local.join("tools/jdks"));
assert_eq!(
std::path::PathBuf::from(ops::tools::jdk_download_location(&host, "main").unwrap()),
local.join("tools/jdks")
);
let light = host.open_light("main", &root.join("notes.txt")).unwrap();
assert!(light.cache_dir.starts_with(&local));
assert!(data.join("history").exists());
+8 -8
Переглянути файл
@@ -21,17 +21,17 @@ async fn new_query_consoles_are_numbered_after_the_default_one() {
let names = |paths: Vec<ide_core::IpcPath>| -> Vec<String> {
paths.iter().map(|p| p.0.file_name().unwrap().to_string_lossy().into_owned()).collect()
};
assert!(db::db_consoles(&host, "pg".into(), false).unwrap().is_empty());
assert!(db::consoles(&host, "pg", false).unwrap().is_empty());
// The first new console is the default one, then console_1, console_2…
assert_eq!(names(db::db_consoles(&host, "pg".into(), true).unwrap()), ["console.sql"]);
assert_eq!(names(db::db_consoles(&host, "pg".into(), true).unwrap()), ["console.sql", "console_1.sql"]);
let all = db::db_consoles(&host, "pg".into(), true).unwrap();
assert_eq!(names(db::consoles(&host, "pg", true).unwrap()), ["console.sql"]);
assert_eq!(names(db::consoles(&host, "pg", true).unwrap()), ["console.sql", "console_1.sql"]);
let all = db::consoles(&host, "pg", true).unwrap();
assert_eq!(names(all.clone()), ["console.sql", "console_1.sql", "console_2.sql"]);
// Numbers sort numerically, and the default console path is the first one.
std::fs::write(all[0].0.with_file_name("console_10.sql"), "").unwrap();
assert_eq!(names(db::db_consoles(&host, "pg".into(), false).unwrap())[3], "console_10.sql");
assert_eq!(db::db_console_path(&host, "pg".into()).unwrap().0, all[0].0);
assert_eq!(names(db::consoles(&host, "pg", false).unwrap())[3], "console_10.sql");
assert_eq!(db::console_path(&host, "pg").unwrap().0, all[0].0);
// Each database of a source has its own consoles.
assert!(db::db_consoles(&host, "pg:other".into(), false).unwrap().is_empty());
assert!(db::db_consoles(&host, "../x".into(), true).is_err());
assert!(db::consoles(&host, "pg:other", false).unwrap().is_empty());
assert!(db::consoles(&host, "../x", true).is_err());
}
+5 -7
Переглянути файл
@@ -1,4 +1,4 @@
//! Docker run targets through `ops::run::run_start`, with a stand-in `docker`
//! Docker run targets through `ops::run::start`, with a stand-in `docker`
//! (`OPENIDEA_DOCKER`) that prints what it was given.
#![cfg(unix)]
@@ -46,16 +46,15 @@ fn config(target: &str, root: &Path) -> RunConfig {
async fn output_of(host: &Host, config: RunConfig) -> String {
let out = Arc::new(Mutex::new(String::new()));
let sink = out.clone();
ops::run::run_start(
ops::run::start(
host,
"main",
config,
ide_host::ops::Channel::new(move |chunk| match chunk {
Arc::new(move |chunk| match chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => {
sink.lock().push_str(&text)
}
}),
None,
)
.await
.unwrap();
@@ -150,10 +149,9 @@ async fn docker_targets_run_through_the_docker_cli() {
"{out}"
);
debug.debug_adapter = Some("delve".into());
let err = ops::run::run_start(&host, "main", debug, ops::Channel::new(|_| {}), None).await.unwrap_err();
let err = ops::run::start(&host, "main", debug, Arc::new(|_| {})).await.unwrap_err();
assert!(err.message.contains("only Python"), "{}", err.message);
let err =
ops::run::run_start(&host, "main", config("far", &root), ops::Channel::new(|_| {}), None).await.unwrap_err();
let err = ops::run::start(&host, "main", config("far", &root), Arc::new(|_| {})).await.unwrap_err();
assert!(err.message.contains("another machine"), "{}", err.message);
}
+3 -4
Переглянути файл
@@ -50,16 +50,15 @@ type Output = Arc<Mutex<String>>;
async fn start(host: &Host, config: RunConfig) -> (ide_core::RunId, Output) {
let out: Output = Arc::default();
let sink = out.clone();
let info = ops::run::run_start(
let info = ops::run::start(
host,
"main",
config,
ide_host::ops::Channel::new(move |chunk| match chunk {
Arc::new(move |chunk| match chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => {
sink.lock().push_str(&text)
}
}),
None,
)
.await
.unwrap();
@@ -146,7 +145,7 @@ async fn runs_in_docker_and_compose_containers() {
tokio::time::sleep(Duration::from_millis(100)).await;
}
assert_ne!(containers("label=openidea.run=sleep"), "", "{}", out.lock());
ops::run::run_stop(&host, "main", id).unwrap();
ops::run::stop(&host, "main", id).unwrap();
let out = finished(&out, 30).await;
assert!(out.contains(" stop openidea-sleep-"), "{out}");
for _ in 0..100 {
+5 -5
Переглянути файл
@@ -231,8 +231,8 @@ impl Smoke {
}
async fn doc(&self, file: &str) -> (DocId, String) {
let info = ops::doc::doc_open(&self.host, WINDOW, self.root.join(file)).await.unwrap();
let info = ops::doc::doc_snapshot(&self.host, WINDOW, info.id).await.unwrap();
let info = ops::doc::open(&self.host, WINDOW, self.root.join(file)).await.unwrap();
let info = ops::doc::snapshot(&self.host, WINDOW, info.id).await.unwrap();
(info.id, info.text)
}
@@ -260,13 +260,13 @@ impl Smoke {
}
async fn replace(&self, doc: DocId, from: u32, to: u32, insert: &str) {
let version = ops::doc::doc_snapshot(&self.host, WINDOW, doc).await.unwrap().version;
let version = ops::doc::snapshot(&self.host, WINDOW, doc).await.unwrap().version;
let changes = ChangeSet { changes: vec![TextChange { from, to, insert: insert.into() }] };
ops::doc::doc_edit(&self.host, WINDOW, doc, version, changes).await.unwrap();
ops::doc::edit(&self.host, WINDOW, doc, version, changes).unwrap();
}
async fn restore(&self, doc: DocId, text: &str) {
let current = ops::doc::doc_snapshot(&self.host, WINDOW, doc).await.unwrap().text;
let current = ops::doc::snapshot(&self.host, WINDOW, doc).await.unwrap().text;
self.replace(doc, 0, utf16_len(&current), text).await;
}
+24 -26
Переглянути файл
@@ -1,7 +1,7 @@
//! LightEdit: a window editing loose files without a project.
use ide_core::{ChangeSet, NullSink, TextChange};
use ide_host::{Host, HostConfig, catalogue::TrustClass, ops};
use ide_host::{Host, HostConfig, ops};
use std::sync::Arc;
use std::time::Duration;
@@ -35,18 +35,18 @@ async fn edits_loose_files_without_project_services() {
assert_eq!(light.root, a_dir);
assert!(host.open_light("main", &b_dir).is_err(), "a folder is not opened for LightEdit");
let doc = ops::doc::doc_open(&host, "main", a_dir.join("one.py")).await.unwrap();
let doc = ops::doc::open(&host, "main", a_dir.join("one.py")).await.unwrap();
assert!(doc.text.starts_with("print"));
let changes = ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: "#\n".into() }] };
let version = ops::doc::doc_edit(&host, "main", doc.id, doc.version, changes).await.unwrap();
let version = ops::doc::edit(&host, "main", doc.id, doc.version, changes).unwrap();
assert!(version > doc.version);
ops::doc::doc_save(&host, "main", doc.id).await.unwrap();
ops::doc::save(&host, "main", doc.id).await.unwrap();
assert_eq!(std::fs::read_to_string(a_dir.join("one.py")).unwrap(), "#\nprint(1)\n");
// More files join the same session, wherever they are.
let again = host.open_light("main", &b_dir.join("two.rs")).unwrap();
assert!(Arc::ptr_eq(&light, &again));
ops::doc::doc_open(&host, "main", b_dir.join("two.rs")).await.unwrap();
ops::doc::open(&host, "main", b_dir.join("two.rs")).await.unwrap();
assert!(light.index.wait_idle(Duration::from_secs(10)));
assert_eq!(light.index.status().files, 0, "nothing is indexed");
@@ -106,12 +106,11 @@ async fn light_windows_stay_restricted_when_folder_trust_changes() {
host.set_project_trust(&root, true, true).await.unwrap();
assert!(!light.is_trusted());
assert!(!trusted_folder.is_trusted());
for class in [TrustClass::OutsideRestricted, TrustClass::Trusted] {
assert!(host.authorize("main", class).is_err(), "{class:?}");
for command in ["sdk_detect", "sdk_locate_tools", "notebook_execute", "notebook_restart", "run_start"] {
assert!(host.authorize_command("main", command).is_err(), "{command}");
}
assert!(host.authorize("main", TrustClass::Always).is_ok());
let doc = ops::doc::doc_open(&host, "main", other.join("two.js")).await.unwrap();
let doc = ops::doc::open(&host, "main", other.join("two.js")).await.unwrap();
let error = ops::lsp::lsp_format(
&host,
"main",
@@ -157,15 +156,15 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
.unwrap();
let host = host(&tmp.path().join("app"));
host.open_light("main", &file).unwrap();
let notebook = ops::notebook::notebook_open(&host, "main", file.to_string_lossy().into()).await.unwrap();
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
let notebook = ops::notebook::open(&host, "main", file.to_string_lossy().into()).await.unwrap();
assert!(ops::notebook::save(&host, "main", notebook.id.clone()).await.is_ok());
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
let error = ops::notebook::restart(&host, "main", notebook.id.clone()).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
let error = ops::notebook::notebook_execute(
let error = ops::notebook::execute(
&host,
"main",
notebook.id,
@@ -192,24 +191,23 @@ async fn untitled_buffers_reach_the_disk_through_save_as() {
// home folder, no watcher yet, doc commands work.
let empty = host.open_light_empty("main").unwrap();
assert!(empty.light);
let untitled = ops::doc::doc_open_untitled(&host, "main", None).await.unwrap();
let untitled = ops::doc::open_untitled(&host, "main", None).await.unwrap();
assert_eq!(untitled.path, std::path::PathBuf::from("untitled:Untitled-1"));
assert_eq!(untitled.language.as_str(), "plaintext");
let version =
ops::doc::doc_edit(&host, "main", untitled.id, untitled.version, untitled_edit("# notes\n")).await.unwrap();
assert!(ops::doc::doc_save(&host, "main", untitled.id).await.is_ok(), "saving nowhere is a no-op");
let version = ops::doc::edit(&host, "main", untitled.id, untitled.version, untitled_edit("# notes\n")).unwrap();
assert!(ops::doc::save(&host, "main", untitled.id).await.is_ok(), "saving nowhere is a no-op");
assert!(host.project("main").unwrap().documents.is_dirty(untitled.id).unwrap());
// Save As: the buffer lands on the disk and turns into a file document.
let target = dir.join("deep/notes.md");
let saved = ops::doc::doc_save_as(&host, "main", untitled.id, target.clone()).await.unwrap();
let saved = ops::doc::save_as(&host, "main", untitled.id, target.clone()).await.unwrap();
assert_eq!(saved.path, target);
assert_eq!(saved.language.as_str(), "markdown");
assert!(!saved.dirty);
// The platform's default line separator applies to new buffers.
assert_eq!(std::fs::read_to_string(&target).unwrap().replace("\r\n", "\n"), "# notes\n");
ops::doc::doc_edit(&host, "main", untitled.id, version, untitled_edit("x\n")).await.unwrap();
ops::doc::doc_save(&host, "main", untitled.id).await.unwrap();
ops::doc::edit(&host, "main", untitled.id, version, untitled_edit("x\n")).unwrap();
ops::doc::save(&host, "main", untitled.id).await.unwrap();
assert_eq!(std::fs::read_to_string(&target).unwrap().replace("\r\n", "\n"), "x\n# notes\n");
// The saved file's folder is followed for external changes now.
@@ -228,9 +226,9 @@ async fn untitled_buffers_follow_the_window_into_a_project() {
// A LightEdit window with an edited untitled buffer (and a clean one).
host.open_light_empty("main").unwrap();
let draft = ops::doc::doc_open_untitled(&host, "main", None).await.unwrap();
ops::doc::doc_edit(&host, "main", draft.id, draft.version, untitled_edit("{\"draft\": true}")).await.unwrap();
let clean = ops::doc::doc_open_untitled(&host, "main", None).await.unwrap();
let draft = ops::doc::open_untitled(&host, "main", None).await.unwrap();
ops::doc::edit(&host, "main", draft.id, draft.version, untitled_edit("{\"draft\": true}")).unwrap();
let clean = ops::doc::open_untitled(&host, "main", None).await.unwrap();
// The window switches to a project: the buffers follow, contents and dirty flags kept.
let project_root = tmp_root.join("proj");
@@ -239,15 +237,15 @@ async fn untitled_buffers_follow_the_window_into_a_project() {
assert!(!project.light);
let carried =
ops::doc::doc_open_untitled(&host, "main", Some(draft.path.to_string_lossy().into_owned())).await.unwrap();
ops::doc::open_untitled(&host, "main", Some(draft.path.to_string_lossy().into_owned())).await.unwrap();
assert_eq!(carried.path, draft.path, "same key, fresh registry: a new doc id carries the content");
let snap = ops::doc::doc_snapshot(&host, "main", carried.id).await.unwrap();
let snap = ops::doc::snapshot(&host, "main", carried.id).await.unwrap();
assert_eq!(snap.text, "{\"draft\": true}");
assert!(host.project("main").unwrap().documents.is_dirty(carried.id).unwrap());
assert_eq!(snap.language.as_str(), "plaintext");
let clean_carried =
ops::doc::doc_open_untitled(&host, "main", Some(clean.path.to_string_lossy().into_owned())).await.unwrap();
ops::doc::open_untitled(&host, "main", Some(clean.path.to_string_lossy().into_owned())).await.unwrap();
assert!(!host.project("main").unwrap().documents.is_dirty(clean_carried.id).unwrap());
host.shutdown().await;
}
+4 -5
Переглянути файл
@@ -763,8 +763,7 @@ fn run_tool_window(h: &Harness) -> Arc<std::sync::Mutex<Vec<ide_run::RunConfig>>
config.extras.params.insert(ide_host::mcp::AGENT_PARAM.into(), name);
config.extras.target = Some(String::new());
out.lock().unwrap().push(config.clone());
let result =
ide_host::ops::run::run_start(&host, "main", config, ide_host::ops::Channel::new(|_| {}), None).await;
let result = ide_host::ops::run::start(&host, "main", config, Arc::new(|_| {})).await;
let error = result.err().map(|e| e.message);
let _ = host.mcp_requests.answer("main", id, error.is_none(), error);
}
@@ -836,7 +835,7 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
// What the user types (a line from the Run console's input) ends a wait at once, with advice for the agent.
let process = agent_process(&h, "_agent_check");
ide_host::ops::run::run_stdin(&h.host, process, "yes\n".into()).unwrap();
ide_host::ops::run::stdin(&h.host, process, "yes\n").unwrap();
let typed = h.json("wait_for_run", json!({"name": "check", "timeout": 10000})).await;
assert_eq!(typed["waitEnded"], "userIntervened", "{typed}");
assert_eq!(typed["interventions"][0]["message"], "User input: yes");
@@ -850,14 +849,14 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
// The user's Stop, rerun and closing the tab are reported with their time.
h.json("run_command", json!({"name": "server", "command": "sleep 30", "timeout": 0})).await;
ide_host::ops::run::run_stop(&h.host, "main", agent_process(&h, "_agent_server")).unwrap();
ide_host::ops::run::stop(&h.host, "main", agent_process(&h, "_agent_server")).unwrap();
let stop = h.json("wait_for_run", json!({"name": "server", "timeout": 10000})).await;
assert!(stop["interventions"][0]["message"].as_str().unwrap().starts_with("The user stopped this command at"));
let ended = h.json("wait_for_run", json!({"name": "server", "timeout": 10000})).await;
assert_eq!(ended["state"], "stoppedByUser", "{ended}");
let config = started.lock().unwrap().last().cloned().unwrap();
ide_host::ops::run::run_start(&h.host, "main", config, ide_host::ops::Channel::new(|_| {}), None).await.unwrap();
ide_host::ops::run::start(&h.host, "main", config, Arc::new(|_| {})).await.unwrap();
let status = h.json("get_run_status", json!({"name": "server"})).await;
assert_eq!(status["startedBy"], "user", "{status}");
assert!(status["interventions"][0]["message"].as_str().unwrap().starts_with("The user reran this command at"));
+5 -6
Переглянути файл
@@ -74,7 +74,7 @@ async fn user_server_values_stay_out_of_the_user_settings() {
let host = host(tmp.path());
open(&host, &root);
for (name, scope) in [("user-server", McpScope::User), ("repo-server", McpScope::Workspace)] {
ide_host::ops::agent::agent_mcp_save(&host, "main", input(name, scope)).unwrap();
ide_host::ops::agent::mcp_save(&host, "main", input(name, scope)).unwrap();
}
host.close_project("main");
@@ -84,7 +84,7 @@ async fn user_server_values_stay_out_of_the_user_settings() {
let host = self::host(tmp.path());
open(&host, &root);
let servers = ide_host::ops::agent::agent_mcp_list(&host, "main").unwrap();
let servers = ide_host::ops::agent::mcp_list(&host, "main").unwrap();
assert_eq!(header(&servers, "user::user-server"), format!("Bearer {VALUE}"));
assert_eq!(header(&servers, "workspace::repo-server"), format!("Bearer {VALUE}"));
host.close_project("main");
@@ -104,7 +104,7 @@ async fn values_in_user_settings_move_to_the_credential_store() {
let host = host(tmp.path());
assert_eq!(files_containing(tmp.path(), VALUE), Vec::<PathBuf>::new());
open(&host, &root);
let servers = ide_host::ops::agent::agent_mcp_list(&host, "main").unwrap();
let servers = ide_host::ops::agent::mcp_list(&host, "main").unwrap();
assert_eq!(header(&servers, "user::remote"), format!("Bearer {VALUE}"));
let remote = servers.iter().find(|s| s.id == "user::remote").unwrap();
assert!(remote.headers.iter().any(|h| h.name == "X-Saved" && h.value == "saved-earlier"), "{remote:?}");
@@ -120,13 +120,12 @@ async fn a_projects_own_values_stay_in_its_file() {
std::fs::write(&file, SERVER_WITH_VALUE).unwrap();
let host = host(tmp.path());
open(&host, &root);
let servers = ide_host::ops::agent::agent_mcp_list(&host, "main").unwrap();
let servers = ide_host::ops::agent::mcp_list(&host, "main").unwrap();
assert_eq!(header(&servers, "workspace::remote"), format!("Bearer {VALUE}"));
assert_eq!(std::fs::read_to_string(&file).unwrap(), SERVER_WITH_VALUE, "reading leaves the project file alone");
// Saving the servers keeps the project's values in the project's file for everyone else.
let servers =
ide_host::ops::agent::agent_mcp_set_enabled(&host, "main", "workspace::remote".into(), false).unwrap();
let servers = ide_host::ops::agent::mcp_set_enabled(&host, "main", "workspace::remote".into(), false).unwrap();
assert_eq!(header(&servers, "workspace::remote"), format!("Bearer {VALUE}"));
assert!(std::fs::read_to_string(&file).unwrap().contains(VALUE));
assert_eq!(files_containing(&tmp.path().join("data"), VALUE), Vec::<PathBuf>::new());
+1 -1
Переглянути файл
@@ -38,7 +38,7 @@ fn images_on_a_share_are_read_only_where_a_project_is_open() {
runtime: runtime.handle().clone(),
project_environment: false,
});
let read = |path: PathBuf| runtime.block_on(fs_read_image(&host, path));
let read = |path: PathBuf| runtime.block_on(fs_read_image(&host, "main", path));
let in_project = over_smb("127.0.0.1", &root.join("docs/a.png"));
let beside_project = over_smb("127.0.0.1", &local.join("outside.png"));
+1 -1
Переглянути файл
@@ -139,7 +139,7 @@ async fn database_connect_asks_only_the_invoking_window_and_uses_normal_connecti
assert_eq!(window, "main");
assert!(!f.plugins.answer_command("second", &request, ide_host::plugins::CommandAnswer::Value(None)));
tokio::time::sleep(Duration::from_millis(350)).await; // Password entry can outlive the 250 ms command budget.
ops::db::db_connect(&f.host, "main", source.to_string()).await.unwrap();
ops::db::connect(&f.host, "main", &source).await.unwrap();
f.plugins.answer_command("main", &request, ide_host::plugins::CommandAnswer::Value(None));
run.await.unwrap().unwrap();
assert!(!f.host.project("main").unwrap().db.connected().is_empty());
+20 -21
Переглянути файл
@@ -276,18 +276,17 @@ async fn wait_for_source(events: &Events, window: &str, source: &str, predicate:
}
}
async fn replace(host: &Host, window: &str, info: &ide_workspace::DocumentInfo, text: &str) -> u32 {
fn replace(host: &Host, window: &str, info: &ide_workspace::DocumentInfo, text: &str) -> u32 {
let project = host.project(window).unwrap();
let snapshot = project.documents.snapshot(info.id).unwrap();
let len = snapshot.text.encode_utf16().count() as u32;
ops::doc::doc_edit(
ops::doc::edit(
host,
window,
info.id,
snapshot.version,
ChangeSet { changes: vec![TextChange { from: 0, to: len, insert: text.into() }] },
)
.await
.unwrap()
}
@@ -304,18 +303,18 @@ async fn typing_is_debounced_versioned_and_scoped_to_document_project_and_window
set_editor_providers(Some(&plugins));
let left = host.open_light("left", &path).unwrap();
host.open_light("right", &path).unwrap();
let a = ops::doc::doc_open(&host, "left", path.clone()).await.unwrap();
let b = ops::doc::doc_open(&host, "right", path.clone()).await.unwrap();
let second_tab = ops::doc::doc_open(&host, "right", path.clone()).await.unwrap();
let a = ops::doc::open(&host, "left", path.clone()).await.unwrap();
let b = ops::doc::open(&host, "right", path.clone()).await.unwrap();
let second_tab = ops::doc::open(&host, "right", path.clone()).await.unwrap();
assert_eq!(b.id, second_tab.id);
wait_for(&events, "left", |items| items.is_empty()).await;
wait_for(&events, "right", |items| items.is_empty()).await;
let calls: u64 = plugins.run_command(ID, "calls", None, Invocation::default()).unwrap().unwrap().parse().unwrap();
events.lock().clear();
replace(&host, "left", &a, "BAD").await;
replace(&host, "left", &a, "BAD");
tokio::time::sleep(Duration::from_millis(100)).await;
let version = replace(&host, "left", &a, "😀BAD").await;
let version = replace(&host, "left", &a, "😀BAD");
tokio::time::sleep(Duration::from_millis(150)).await;
assert!(latest(&events, "left", SOURCE).is_none(), "300ms after the latest edit");
wait_for(&events, "left", |items| !items.is_empty()).await;
@@ -331,40 +330,40 @@ async fn typing_is_debounced_versioned_and_scoped_to_document_project_and_window
plugins.run_command(ID, "publish", path.to_str(), Invocation::default()).unwrap();
let manual_window = events.lock().iter().find_map(|(window, event)| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "plugin:test.diagnostics" && !items.is_empty()).then(|| window.clone())).unwrap();
assert_eq!(latest(&events, &manual_window, "plugin:test.diagnostics").unwrap()[0].message, "Manual problem");
replace(&host, "left", &a, "clean again").await;
replace(&host, "left", &a, "clean again");
wait_for(&events, "left", |items| items.is_empty()).await;
assert_eq!(latest(&events, &manual_window, "plugin:test.diagnostics").unwrap()[0].message, "Manual problem");
events.lock().clear();
replace(&host, "left", &a, "slow BAD").await;
replace(&host, "left", &a, "slow BAD");
tokio::time::sleep(Duration::from_millis(350)).await;
replace(&host, "left", &a, "latest clean").await;
replace(&host, "left", &a, "latest clean");
wait_for(&events, "left", |items| items.is_empty()).await;
assert!(
!events.lock().iter().any(|(_, e)| matches!(e, IdeEvent::Diagnostics { items, .. } if !items.is_empty())),
"superseded in-flight answers never publish"
);
replace(&host, "right", &b, "BAD right").await;
replace(&host, "right", &b, "BAD right");
wait_for(&events, "right", |items| !items.is_empty()).await;
ops::doc::doc_close(&host, "right", b.id).await.unwrap();
ops::doc::close(&host, "right", b.id).unwrap();
assert!(!latest(&events, "right", SOURCE).unwrap().is_empty(), "another pane still owns this document");
ops::doc::doc_close(&host, "right", second_tab.id).await.unwrap();
ops::doc::close(&host, "right", second_tab.id).unwrap();
wait_for(&events, "right", |items| items.is_empty()).await;
replace(&host, "left", &a, "BAD left").await;
replace(&host, "left", &a, "BAD left");
wait_for(&events, "left", |items| !items.is_empty()).await;
plugins.set_enabled(ID, false).unwrap();
wait_for(&events, "left", |items| items.is_empty()).await;
plugins.set_enabled(ID, true).unwrap();
events.lock().clear();
replace(&host, "left", &a, "slow BAD closing").await;
replace(&host, "left", &a, "slow BAD closing");
tokio::time::sleep(Duration::from_millis(350)).await;
host.close_project("left");
// Keep the old Project alive deliberately: window reuse must still cancel it.
assert_eq!(left.documents.snapshot(a.id).unwrap().text, "slow BAD closing");
host.open_light("left", &path).unwrap();
let reopened = ops::doc::doc_open(&host, "left", path.clone()).await.unwrap();
let reopened = ops::doc::open(&host, "left", path.clone()).await.unwrap();
wait_for(&events, "left", |items| items.is_empty()).await;
assert!(!events.lock().iter().any(|(_, e)| matches!(e, IdeEvent::Diagnostics { items, .. } if !items.is_empty())));
// Project plugins receive only snapshots from the project that owns their declaration.
@@ -376,7 +375,7 @@ async fn typing_is_debounced_versioned_and_scoped_to_document_project_and_window
plugins.set_project_policy(Arc::new(|_| true));
plugins.sync_project(&root);
plugins.grant("project.diagnostics", &Consent::all()).unwrap();
replace(&host, "left", &reopened, "BAD in project").await;
replace(&host, "left", &reopened, "BAD in project");
wait_for(&events, "left", |items| !items.is_empty()).await;
let project_source = "plugin-provider:project.diagnostics";
wait_for_source(&events, "left", project_source, |items| !items.is_empty()).await;
@@ -385,7 +384,7 @@ async fn typing_is_debounced_versioned_and_scoped_to_document_project_and_window
let other_path = elsewhere.join("other.txt");
std::fs::write(&other_path, "BAD outside").unwrap();
host.open_light("elsewhere", &other_path).unwrap();
ops::doc::doc_open(&host, "elsewhere", other_path).await.unwrap();
ops::doc::open(&host, "elsewhere", other_path).await.unwrap();
wait_for(&events, "elsewhere", |items| !items.is_empty()).await;
assert!(latest(&events, "elsewhere", project_source).is_none());
plugins.restrict_project(&root);
@@ -404,7 +403,7 @@ async fn typing_is_debounced_versioned_and_scoped_to_document_project_and_window
plugins.run_command("test.slow", "calls", None, Invocation::default()).unwrap();
let calls = plugins.run_command(ID, "calls", None, Invocation::default()).unwrap();
events.lock().clear();
replace(&host, "left", &reopened, "BAD completed before crash").await;
replace(&host, "left", &reopened, "BAD completed before crash");
tokio::time::sleep(Duration::from_millis(200)).await;
let waiter = {
let plugins = plugins.clone();
@@ -427,7 +426,7 @@ async fn typing_is_debounced_versioned_and_scoped_to_document_project_and_window
latest(&events, "left", SOURCE).is_none_or(|items| items.is_empty()),
"a crash invalidates completed answers"
);
ops::doc::doc_close(&host, "left", reopened.id).await.unwrap();
ops::doc::close(&host, "left", reopened.id).unwrap();
host.shutdown().await;
set_editor_providers(None);
}
Loaded 100 of 344 files, more files were not shown because too many files have changed in this diff. Show more