дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-17 15:15:40 +02:00
Порівняти коміти
87
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
ea6638b05e | ||
|
|
a91421c6e0 | ||
|
|
973f0a18a8 | ||
|
|
fb64f0cd26 | ||
|
|
34f2e18ff1 | ||
|
|
83a949ffe9 | ||
|
|
af8bd1afcd | ||
|
|
ce12f68613 | ||
|
|
77996f17e7 | ||
|
|
bacdd3e5c3 | ||
|
|
cb7bddec14 | ||
|
|
407561e59a | ||
|
|
e34e925b8f | ||
|
|
04ab9e8999 | ||
|
|
4a9927c256 | ||
|
|
084be4fb51 | ||
|
|
5c0ff2a918 | ||
|
|
c65acc902e | ||
|
|
ec0a681b72 | ||
|
|
5895022904 | ||
|
|
215023e85c | ||
|
|
aab53f89b3 | ||
|
|
519f1d43f4 | ||
|
|
88368033be | ||
|
|
d952827557 | ||
|
|
bb3fd570a6 | ||
|
|
92119e2040 | ||
|
|
93d7f76b20 | ||
|
|
f53a7ec42c | ||
|
|
be384e460a | ||
|
|
f86c5e3460 | ||
|
|
0fb574e815 | ||
|
|
43f9ec99f6 | ||
|
|
e86e2e8e5c | ||
|
|
811b98dd4b | ||
|
|
76377b6eec | ||
|
|
61ba70394f | ||
|
|
bbc5412605 | ||
|
|
3032bf108f | ||
|
|
bde17e4f47 | ||
|
|
af55109b27 | ||
|
|
3663556a2e | ||
|
|
217bd29860 | ||
|
|
25d6e8ac7c | ||
|
|
280760a5d4 | ||
|
|
b3008be32b | ||
|
|
577193d387 | ||
|
|
449db6baa7 | ||
|
|
ea1f1e54d0 | ||
|
|
4201aad9f9 | ||
|
|
678407f4c0 | ||
|
|
7392bd2547 | ||
|
|
b1f73e3920 | ||
|
|
e8b12dfb51 | ||
|
|
fd828c0ade | ||
|
|
ebc879dc8b | ||
|
|
7096a1c374 | ||
|
|
a1d4d6fb7f | ||
|
|
7596e95b76 | ||
|
|
cc471029d2 | ||
|
|
ee8afe39a2 | ||
|
|
5f606219b2 | ||
|
|
0590a255e8 | ||
|
|
32d5232010 | ||
|
|
382f5d71fa | ||
|
|
0cd7d9c30e | ||
|
|
dfbe87161b | ||
|
|
7a351fe4b0 | ||
|
|
153a184eac | ||
|
|
868f5b18d0 | ||
|
|
8d87b0de6e | ||
|
|
c791f2c34c | ||
|
|
a52e416ad5 | ||
|
|
a7464bf631 | ||
|
|
26810fbcbd | ||
|
|
72b17683c9 | ||
|
|
e916af15d4 | ||
|
|
88eeb57000 | ||
|
|
ba5c56ade8 | ||
|
|
88a5602239 | ||
|
|
907ed1d85f | ||
|
|
7f229acbd9 | ||
|
|
41bae970e0 | ||
|
|
44b5515432 | ||
|
|
64d5618cc7 | ||
|
|
1a21efa4aa | ||
|
|
72cf2f488e |
No files matched your search
@@ -98,6 +98,9 @@ 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'
|
||||
|
||||
@@ -1,119 +0,0 @@
|
||||
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
|
||||
@@ -1,7 +1,7 @@
|
||||
name: Release build
|
||||
|
||||
# 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.
|
||||
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release
|
||||
# (run by release.yml).
|
||||
on:
|
||||
workflow_call:
|
||||
inputs:
|
||||
@@ -224,18 +224,17 @@ jobs:
|
||||
return;
|
||||
}
|
||||
// Bundle suffix → updater platform keys, as tauri-action names them.
|
||||
// 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 windows = (arch, msi, 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"]],
|
||||
...(nightly ? [] : [[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]]]),
|
||||
[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]],
|
||||
[/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
|
||||
[/_amd64\.deb$/, ["linux-x86_64-deb"]],
|
||||
...(nightly ? [] : [[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]]]),
|
||||
[/\.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$/),
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
name: Release
|
||||
on:
|
||||
push:
|
||||
tags: ["v*", "!v*-nightly.*"]
|
||||
tags: ["v*"]
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
tag:
|
||||
@@ -23,7 +23,6 @@ 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
|
||||
@@ -62,7 +61,7 @@ jobs:
|
||||
core.setOutput("id", existing.id);
|
||||
return;
|
||||
}
|
||||
// Nightly builds are prereleases: the notes span stable release to stable release.
|
||||
// Prereleases are skipped: 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,
|
||||
|
||||
+5
-1
@@ -9,7 +9,8 @@ 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`
|
||||
(thin typed IPC adapters), `events.rs`. No domain logic here.
|
||||
(desktop-only commands; the adapters of `ide-host` commands are derived), `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.
|
||||
@@ -33,6 +34,9 @@ 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
|
||||
|
||||
Створено
+58
-45
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
|
||||
|
||||
[[package]]
|
||||
name = "ide-agent"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4169,7 +4169,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-analysis"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ast-grep-core",
|
||||
"ide-core",
|
||||
@@ -4183,7 +4183,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-android"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4194,7 +4194,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-build"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"chardetng",
|
||||
@@ -4212,7 +4212,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-cli"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"serde",
|
||||
@@ -4226,7 +4226,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-clipboard"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
@@ -4235,9 +4235,20 @@ 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.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4254,7 +4265,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-coverage"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-run",
|
||||
@@ -4268,7 +4279,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-dap"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"futures",
|
||||
@@ -4297,7 +4308,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-db"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"bb8",
|
||||
@@ -4333,7 +4344,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-docker"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4346,7 +4357,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4367,7 +4378,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-fonts"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-text",
|
||||
@@ -4379,7 +4390,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-github"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vcs",
|
||||
@@ -4392,7 +4403,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-heap"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4410,7 +4421,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-host"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4424,6 +4435,7 @@ dependencies = [
|
||||
"ide-agent",
|
||||
"ide-analysis",
|
||||
"ide-build",
|
||||
"ide-command",
|
||||
"ide-core",
|
||||
"ide-coverage",
|
||||
"ide-dap",
|
||||
@@ -4483,7 +4495,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-http"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
@@ -4502,7 +4514,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-index"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4524,7 +4536,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jdwp"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-jvm-inspect",
|
||||
"proptest",
|
||||
@@ -4536,7 +4548,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jsonrpc"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"encoding_rs",
|
||||
"futures",
|
||||
@@ -4553,7 +4565,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-attach"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"tempfile",
|
||||
@@ -4562,7 +4574,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-inspect"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"serde",
|
||||
@@ -4573,7 +4585,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-language"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4631,7 +4643,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-lsp"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4659,7 +4671,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-mcp"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"dunce",
|
||||
@@ -4678,7 +4690,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-notebook"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"ide-core",
|
||||
@@ -4701,7 +4713,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-plugin"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4724,7 +4736,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-profiler"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-jvm-attach",
|
||||
@@ -4738,7 +4750,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-remote"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"futures",
|
||||
@@ -4758,7 +4770,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-run"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4782,7 +4794,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-scaffold"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-tools",
|
||||
@@ -4798,7 +4810,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-sdk"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"flate2",
|
||||
@@ -4821,7 +4833,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-search"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"encoding_rs",
|
||||
@@ -4842,7 +4854,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-spell"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"parking_lot",
|
||||
@@ -4855,7 +4867,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-ssh"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"flate2",
|
||||
@@ -4880,7 +4892,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-streams"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4893,7 +4905,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-syntax"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4908,7 +4920,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-terminal"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"libc",
|
||||
@@ -4921,7 +4933,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-text"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4934,7 +4946,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-tools"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"hex",
|
||||
@@ -4955,7 +4967,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vcs"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4976,7 +4988,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vfs"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"chardetng",
|
||||
"dunce",
|
||||
@@ -5002,7 +5014,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-web"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"ide-core",
|
||||
@@ -5018,7 +5030,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-workspace"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -6647,7 +6659,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "openidea"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -6661,6 +6673,7 @@ dependencies = [
|
||||
"ide-build",
|
||||
"ide-cli",
|
||||
"ide-clipboard",
|
||||
"ide-command",
|
||||
"ide-core",
|
||||
"ide-coverage",
|
||||
"ide-dap",
|
||||
|
||||
+8
-1
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
|
||||
exclude = ["sdk", "plugins"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
edition = "2024"
|
||||
rust-version = "1.96"
|
||||
license = "Apache-2.0"
|
||||
@@ -42,6 +42,7 @@ 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" }
|
||||
@@ -124,6 +125,12 @@ 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"
|
||||
|
||||
@@ -72,9 +72,8 @@ async fn run_once(
|
||||
config::add_client_options(&launch.id, &mut options);
|
||||
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
|
||||
let mut levels = BTreeMap::new();
|
||||
if new.get("configOptions").is_some_and(Value::is_array)
|
||||
&& let Some(model) = model_option.and_then(|o| o.current.as_ref())
|
||||
{
|
||||
let has_config = new.get("configOptions").is_some_and(Value::is_array);
|
||||
if has_config && let Some(model) = model_option.and_then(|o| o.current.as_ref()) {
|
||||
levels.insert(model.clone(), levels_for_model_from_slice(&options));
|
||||
}
|
||||
if let Some(selected) = selected_model
|
||||
@@ -88,7 +87,7 @@ async fn run_once(
|
||||
updates.config.lock().session = Some(session.to_owned());
|
||||
let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?;
|
||||
let settings = if let Some(settings) = selected_settings(&response, selected) {
|
||||
settings
|
||||
Some(settings)
|
||||
} else {
|
||||
tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async {
|
||||
loop {
|
||||
@@ -106,9 +105,15 @@ async fn run_once(
|
||||
}
|
||||
})
|
||||
.await
|
||||
.map_err(|_| "The agent did not report settings for the selected model".to_owned())?
|
||||
.ok()
|
||||
};
|
||||
match settings {
|
||||
Some(settings) => levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings)),
|
||||
// An agent on the legacy `models` field that says nothing more: the model has
|
||||
// no settings of its own, and switching to it must not fail.
|
||||
None if !has_config => levels.insert(selected.to_owned(), Vec::new()),
|
||||
None => return Err("The agent did not report settings for the selected model".to_owned()),
|
||||
};
|
||||
levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings));
|
||||
}
|
||||
let commands = updates
|
||||
.commands
|
||||
|
||||
@@ -774,6 +774,33 @@ async fn selected_model_uses_legacy_set_model_and_authoritative_notifications()
|
||||
assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_legacy_model_without_settings_has_no_levels_instead_of_failing() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness
|
||||
.next()
|
||||
.await
|
||||
.reply
|
||||
.send(Ok(json!({
|
||||
"sessionId": "discovery-only",
|
||||
"models": { "currentModelId": "default", "availableModels": [
|
||||
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
|
||||
] }
|
||||
})))
|
||||
.unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_model");
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert!(catalog.error.is_none(), "{:?}", catalog.error);
|
||||
assert_eq!(catalog.thought_levels.get("second"), Some(&Vec::new()));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -222,13 +222,26 @@ impl Shared {
|
||||
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
|
||||
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
|
||||
let mut off = mcp::servers_off(&configured, overrides);
|
||||
if builtin_off {
|
||||
off.push(BUILTIN_SERVER.to_owned());
|
||||
}
|
||||
let off = Self::mcp_off(&configured, provider, overrides);
|
||||
McpForSession { servers, off }
|
||||
}
|
||||
|
||||
fn mcp_servers_off_for_session(&self, provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
|
||||
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
Self::mcp_off(&configured, provider, overrides)
|
||||
}
|
||||
|
||||
fn mcp_off(configured: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
|
||||
let mut off = mcp::servers_off(configured, provider, overrides);
|
||||
if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
|
||||
off.push(BUILTIN_SERVER.to_owned());
|
||||
off.push(mcp::BUILTIN_MCP_NAME.to_owned());
|
||||
off.sort();
|
||||
off.dedup();
|
||||
}
|
||||
off
|
||||
}
|
||||
|
||||
fn known_config(&self, provider: &str) -> Vec<AgentConfigOption> {
|
||||
let config = self.paths.catalogs.cached(self, provider).config;
|
||||
self.config_for_new_task(config, provider)
|
||||
@@ -922,29 +935,50 @@ impl AgentManager {
|
||||
Ok(item)
|
||||
}
|
||||
|
||||
/// Sends queued message `queued` next, cancelling the current turn if there is one.
|
||||
pub fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
|
||||
/// 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<()> {
|
||||
let task = self.task(id)?;
|
||||
let idle = {
|
||||
let (item, busy) = {
|
||||
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);
|
||||
if s.busy {
|
||||
s.task.queue.insert(0, item);
|
||||
None
|
||||
} else {
|
||||
let busy = s.busy;
|
||||
if !busy {
|
||||
s.busy = true;
|
||||
Some(item)
|
||||
}
|
||||
(item, busy)
|
||||
};
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
match idle {
|
||||
Some(item) => {
|
||||
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
|
||||
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 });
|
||||
}
|
||||
None => {
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
task.send_now.store(true, Ordering::Release);
|
||||
task.cancel();
|
||||
}
|
||||
@@ -1618,6 +1652,26 @@ impl AgentManager {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Recycles idle resumable live sessions (or schedules reload after the running turn) when
|
||||
/// global, workspace, or built-in IDE MCP server settings change.
|
||||
pub fn notify_mcp_servers_changed(&self) {
|
||||
let tasks: Vec<Arc<Task>> = self.tasks.read().values().cloned().collect();
|
||||
for task in tasks {
|
||||
let (archived, busy, has_bg) = {
|
||||
let s = task.state.lock();
|
||||
(s.task.status == AgentStatus::Archived, s.busy, !s.background_tasks.is_empty())
|
||||
};
|
||||
if archived {
|
||||
continue;
|
||||
}
|
||||
if busy || has_bg || !task.permissions.lock().is_empty() {
|
||||
task.mcp_reload_pending.store(true, Ordering::Release);
|
||||
} else {
|
||||
task.recycle_resumable_session();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops every agent (project closed).
|
||||
pub fn shutdown(&self) {
|
||||
for task in self.tasks.read().values() {
|
||||
@@ -2218,9 +2272,16 @@ impl Task {
|
||||
saved: Option<String>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
|
||||
spec.args.push("--disable-mcp-server".into());
|
||||
spec.args.push(name);
|
||||
}
|
||||
}
|
||||
self.stderr.lock().clear();
|
||||
self.config_sent.lock().clear();
|
||||
let weak = Arc::downgrade(self);
|
||||
@@ -2981,7 +3042,7 @@ fn blocks(prompt: &AgentPrompt, contents: &[Option<String>]) -> Vec<Value> {
|
||||
});
|
||||
}
|
||||
for i in &prompt.images {
|
||||
out.push(json!({ "type": "image", "mimeType": i.mime_type, "data": i.data }));
|
||||
out.push(json!({ "type": "image", "mimeType": i.media_type(), "data": i.data }));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
@@ -10,7 +10,7 @@ use crate::{
|
||||
};
|
||||
use ide_core::IpcPath;
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::collections::{BTreeMap, BTreeSet, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
@@ -89,24 +89,61 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
|
||||
/// The configured servers off for this session: off by default and not switched on for it, or
|
||||
/// switched off for it. Named so an agent that also loads its own configuration can keep a
|
||||
/// same-named server of it off too. Workspace entries take precedence, as in [`acp_mcp_servers`].
|
||||
pub(crate) fn servers_off(all: &[McpServer], overrides: &BTreeMap<String, bool>) -> Vec<String> {
|
||||
let mut seen = HashSet::new();
|
||||
let ordered =
|
||||
all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
|
||||
let configured: Vec<String> = ordered
|
||||
.filter(|s| seen.insert(s.name.as_str()))
|
||||
.filter(|s| !overrides.get(&s.name).copied().unwrap_or(s.enabled))
|
||||
.map(|s| s.name.clone())
|
||||
.collect();
|
||||
// A server switched off that the IDE doesn't configure may still be the agent's own.
|
||||
let switched = overrides
|
||||
pub(crate) fn servers_off(all: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
|
||||
let mut seen_configured = HashSet::new();
|
||||
let mut enabled_names = HashSet::new();
|
||||
let mut off = BTreeSet::new();
|
||||
|
||||
let ordered = all
|
||||
.iter()
|
||||
.filter(|(name, on)| !**on && name.as_str() != BUILTIN_MCP_NAME && !seen.contains(name.as_str()))
|
||||
.map(|(name, _)| name.clone());
|
||||
let mut off: Vec<String> = configured.into_iter().chain(switched).collect();
|
||||
off.sort();
|
||||
off.dedup();
|
||||
off
|
||||
.filter(|s| s.scope == McpScope::Workspace && !s.unapproved)
|
||||
.chain(all.iter().filter(|s| s.scope == McpScope::User));
|
||||
|
||||
for srv in ordered {
|
||||
if !seen_configured.insert(srv.name.as_str()) {
|
||||
continue;
|
||||
}
|
||||
let explicit = overrides.get(&srv.name).copied();
|
||||
let matches = explicit == Some(true) || matches_agent(&srv.agents, provider);
|
||||
let active = explicit.unwrap_or(srv.enabled) && matches;
|
||||
if active {
|
||||
enabled_names.insert(srv.name.as_str());
|
||||
} else {
|
||||
off.insert(srv.name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
for srv in all.iter().filter(|s| s.scope == McpScope::Workspace && s.unapproved) {
|
||||
if !enabled_names.contains(srv.name.as_str()) {
|
||||
off.insert(srv.name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
// A server switched off that the IDE doesn't configure may still be the agent's own.
|
||||
for (name, &on) in overrides {
|
||||
if !on && name.as_str() != BUILTIN_MCP_NAME && !enabled_names.contains(name.as_str()) {
|
||||
off.insert(name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
off.into_iter().collect()
|
||||
}
|
||||
|
||||
/// Names of MCP servers present in Codex's own TOML configuration files (`~/.codex/config.toml`
|
||||
/// and `<workspace_root>/.codex/config.toml`).
|
||||
pub(crate) fn codex_external_server_names(home_dir: Option<&Path>, workspace_root: &Path) -> BTreeSet<String> {
|
||||
let mut names = BTreeSet::new();
|
||||
let mut paths = Vec::new();
|
||||
if let Some(home) = home_dir {
|
||||
paths.push(home.join(".codex").join("config.toml"));
|
||||
}
|
||||
paths.push(workspace_root.join(".codex").join("config.toml"));
|
||||
for path in paths {
|
||||
if let Ok(text) = std::fs::read_to_string(&path) {
|
||||
names.extend(parse_codex_toml_servers(&text).into_keys());
|
||||
}
|
||||
}
|
||||
names
|
||||
}
|
||||
|
||||
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
|
||||
@@ -1058,6 +1095,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn servers_off_follow_the_effective_state() {
|
||||
let mut claude_only = configured("claude-only", McpScope::User, true);
|
||||
claude_only.agents = vec!["claude".into()];
|
||||
let mut unapproved_ws = configured("unapproved-ws", McpScope::Workspace, false);
|
||||
unapproved_ws.unapproved = true;
|
||||
|
||||
let all = [
|
||||
configured("default-off", McpScope::User, false),
|
||||
configured("switched-on", McpScope::User, false),
|
||||
@@ -1066,6 +1108,8 @@ mod tests {
|
||||
// The workspace entry decides for its name.
|
||||
configured("both", McpScope::User, true),
|
||||
configured("both", McpScope::Workspace, false),
|
||||
claude_only,
|
||||
unapproved_ws,
|
||||
];
|
||||
let overrides = BTreeMap::from([
|
||||
("switched-on".to_owned(), true),
|
||||
@@ -1073,8 +1117,11 @@ mod tests {
|
||||
("agent-own".to_owned(), false),
|
||||
(BUILTIN_MCP_NAME.to_owned(), false),
|
||||
]);
|
||||
assert_eq!(servers_off(&all, &overrides), ["agent-own", "both", "default-off", "switched-off"]);
|
||||
assert_eq!(servers_off(&all[2..4], &BTreeMap::new()), Vec::<String>::new());
|
||||
assert_eq!(
|
||||
servers_off(&all, "copilot", &overrides),
|
||||
["agent-own", "both", "claude-only", "default-off", "switched-off", "unapproved-ws"]
|
||||
);
|
||||
assert_eq!(servers_off(&all[2..4], "copilot", &BTreeMap::new()), Vec::<String>::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -281,6 +281,22 @@ 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")]
|
||||
|
||||
@@ -1671,6 +1671,17 @@ fn session_mcp_servers_become_thread_configuration() {
|
||||
json!({"mcp_servers":{"OpenIDEA":{"command":"/app/openidea","args":["--mcp-stdio","--project","/project"],"env":{"K":"V"}}}})
|
||||
)
|
||||
);
|
||||
let external = std::collections::BTreeSet::from(["linear".to_owned()]);
|
||||
assert_eq!(
|
||||
super::translate::mcp_config_with_external(
|
||||
&json!({
|
||||
"mcpServers": [],
|
||||
"_meta": { "openidea": { "mcpServersOff": ["linear", "not-in-codex"] } }
|
||||
}),
|
||||
&external,
|
||||
),
|
||||
Some(json!({ "mcp_servers": { "linear": { "enabled": false } } }))
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
|
||||
@@ -923,8 +923,18 @@ fn str_of(v: &Value, key: &str) -> Option<String> {
|
||||
|
||||
/// Session-scoped MCP configuration, carried in thread/start, resume and fork.
|
||||
pub(super) fn mcp_config(params: &Value) -> Option<Value> {
|
||||
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(std::path::PathBuf::from);
|
||||
let cwd = params.get("cwd").and_then(Value::as_str).map_or_else(|| std::path::Path::new("."), std::path::Path::new);
|
||||
let external = crate::mcp::codex_external_server_names(home.as_deref(), cwd);
|
||||
mcp_config_with_external(params, &external)
|
||||
}
|
||||
|
||||
pub(super) fn mcp_config_with_external(
|
||||
params: &Value,
|
||||
external_names: &std::collections::BTreeSet<String>,
|
||||
) -> Option<Value> {
|
||||
let mut servers = serde_json::Map::new();
|
||||
for server in params.get("mcpServers")?.as_array()? {
|
||||
for server in params.get("mcpServers").and_then(Value::as_array).into_iter().flatten() {
|
||||
if server.get("type").and_then(Value::as_str).is_some_and(|t| t != "stdio") {
|
||||
continue;
|
||||
}
|
||||
@@ -946,5 +956,16 @@ pub(super) fn mcp_config(params: &Value) -> Option<Value> {
|
||||
"args":server.get("args").cloned().unwrap_or_else(||json!([])),"env":env}),
|
||||
);
|
||||
}
|
||||
for name in params
|
||||
.pointer("/_meta/openidea/mcpServersOff")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(Value::as_str)
|
||||
{
|
||||
if !servers.contains_key(name) && external_names.contains(name) {
|
||||
servers.insert(name.to_owned(), json!({ "enabled": false }));
|
||||
}
|
||||
}
|
||||
(!servers.is_empty()).then(|| json!({"mcp_servers":servers}))
|
||||
}
|
||||
@@ -19,6 +19,7 @@ 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};
|
||||
@@ -296,6 +297,25 @@ 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>);
|
||||
@@ -411,6 +431,7 @@ impl CopilotShim {
|
||||
"session/set_config_option" => self.set_config(¶ms).await,
|
||||
"session/prompt" => self.prompt(¶ms, false).await,
|
||||
"_openidea/steer" => self.prompt(¶ms, true).await,
|
||||
"_openidea/stop_task" => self.stop_task(¶ms).await,
|
||||
"session/close" => self.close_session(¶ms).await,
|
||||
_ => Err(error(codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
|
||||
}
|
||||
@@ -425,7 +446,7 @@ impl CopilotShim {
|
||||
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
|
||||
"mcpCapabilities": { "http": true, "sse": true, "stdio": true },
|
||||
"sessionCapabilities": { "close": {}, "list": {} },
|
||||
"_meta": { "openidea": { "steer": true } },
|
||||
"_meta": { "openidea": { "steer": true, "backgroundTasks": true } },
|
||||
},
|
||||
"agentInfo": {
|
||||
"name": "copilot",
|
||||
@@ -471,6 +492,9 @@ impl CopilotShim {
|
||||
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
|
||||
req["mcpServers"] = mcp;
|
||||
}
|
||||
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
|
||||
req["disabledMcpServers"] = disabled;
|
||||
}
|
||||
|
||||
let created = self.call("session.create", req).await?;
|
||||
let session_id = created
|
||||
@@ -489,16 +513,7 @@ impl CopilotShim {
|
||||
}
|
||||
|
||||
let options = models::config_options(&catalog, &settings);
|
||||
self.state.lock().sessions.insert(
|
||||
session_id.clone(),
|
||||
SessionEntry {
|
||||
settings,
|
||||
translator: EventTranslator::default(),
|
||||
prompt: None,
|
||||
early_cancel: None,
|
||||
temp_files: Vec::new(),
|
||||
},
|
||||
);
|
||||
self.state.lock().sessions.insert(session_id.clone(), SessionEntry::new(settings));
|
||||
self.publish_commands(&session_id, cwd);
|
||||
Ok(json!({
|
||||
"sessionId": session_id,
|
||||
@@ -527,6 +542,9 @@ impl CopilotShim {
|
||||
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
|
||||
req["mcpServers"] = mcp;
|
||||
}
|
||||
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
|
||||
req["disabledMcpServers"] = disabled;
|
||||
}
|
||||
|
||||
let resumed = self.call("session.resume", req).await?;
|
||||
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
|
||||
@@ -542,16 +560,7 @@ 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 {
|
||||
settings,
|
||||
translator: EventTranslator::default(),
|
||||
prompt: None,
|
||||
early_cancel: None,
|
||||
temp_files: Vec::new(),
|
||||
},
|
||||
);
|
||||
self.state.lock().sessions.insert(actual_id.clone(), SessionEntry::new(settings));
|
||||
self.publish_commands(&actual_id, cwd);
|
||||
Ok(json!({
|
||||
"sessionId": actual_id,
|
||||
@@ -653,7 +662,11 @@ impl CopilotShim {
|
||||
let (text, attachments, temp_files) = build_prompt_payload(&session_id, blocks);
|
||||
|
||||
if steer {
|
||||
let is_running = self.state.lock().sessions.get(&session_id).is_some_and(|e| e.prompt.is_some());
|
||||
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))
|
||||
};
|
||||
if !is_running {
|
||||
cleanup_files(&temp_files);
|
||||
return Err(error(codes::INVALID_PARAMS, "no turn running to steer"));
|
||||
@@ -661,14 +674,25 @@ 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!({}));
|
||||
@@ -685,6 +709,7 @@ impl CopilotShim {
|
||||
let mode = entry.settings.mode.wire();
|
||||
if !early {
|
||||
entry.prompt = Some(done_tx);
|
||||
entry.main_busy = true;
|
||||
}
|
||||
(mode, early)
|
||||
};
|
||||
@@ -734,19 +759,24 @@ impl CopilotShim {
|
||||
}
|
||||
|
||||
fn cancel(&self, session_id: &str) {
|
||||
let has_turn = {
|
||||
let (has_turn, ended) = {
|
||||
let mut st = self.state.lock();
|
||||
if let Some(entry) = st.sessions.get_mut(session_id) {
|
||||
if entry.prompt.is_none() {
|
||||
match st.sessions.get_mut(session_id) {
|
||||
Some(entry) if entry.prompt.is_none() => {
|
||||
entry.early_cancel = Some(Instant::now());
|
||||
false
|
||||
} else {
|
||||
true
|
||||
(false, None)
|
||||
}
|
||||
} else {
|
||||
false
|
||||
// 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),
|
||||
}
|
||||
};
|
||||
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();
|
||||
@@ -790,10 +820,23 @@ 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);
|
||||
@@ -803,11 +846,44 @@ 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) {
|
||||
|
||||
@@ -6,6 +6,7 @@ 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!({
|
||||
@@ -340,6 +341,12 @@ 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 {
|
||||
@@ -355,12 +362,36 @@ impl Handler for FakeCopilotServer {
|
||||
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
|
||||
"skills.discover" => Ok(json!({ "skills": [] })),
|
||||
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
|
||||
"session.resume" => Ok(json!({ "sessionId": params["sessionId"] })),
|
||||
"session.model.getCurrent" => Ok(json!({ "modelId": "gemini-4-carbon" })),
|
||||
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
|
||||
"session.mode.set" => Ok(json!({})),
|
||||
"session.permissions.setApproveAll" => {
|
||||
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();
|
||||
@@ -423,7 +454,8 @@ 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()) });
|
||||
let server =
|
||||
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
|
||||
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
|
||||
let server_clone = server.clone();
|
||||
let client = attach(updates.clone(), move |events| {
|
||||
@@ -538,3 +570,118 @@ async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_t
|
||||
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
|
||||
);
|
||||
}
|
||||
|
||||
#[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 updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
|
||||
let server_clone = server.clone();
|
||||
let client = attach(updates, 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 _: Value = client.request("initialize", json!({}), None).await.unwrap();
|
||||
let disabled = json!(["datadog", "github-mcp-server", "linear", "playwright", "slack-official"]);
|
||||
let _: Value = client
|
||||
.request(
|
||||
"session/new",
|
||||
json!({
|
||||
"cwd": "/tmp",
|
||||
"mcpServers": [],
|
||||
"_meta": { "openidea": { "mcpServersOff": disabled } }
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let _: Value = client
|
||||
.request(
|
||||
"session/load",
|
||||
json!({
|
||||
"sessionId": "cop-sess-1",
|
||||
"cwd": "/tmp",
|
||||
"mcpServers": [],
|
||||
"_meta": { "openidea": { "mcpServersOff": disabled } }
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let calls = server.calls.lock();
|
||||
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
|
||||
assert_eq!(create_params["disabledMcpServers"], disabled);
|
||||
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"));
|
||||
}
|
||||
@@ -522,6 +522,14 @@ pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
|
||||
(!out.is_empty()).then_some(Value::Object(out))
|
||||
}
|
||||
|
||||
/// Extracts `_meta.openidea.mcpServersOff` into Copilot's `disabledMcpServers` string array.
|
||||
pub(super) fn wire_disabled_mcp_servers(params: &Value) -> Option<Value> {
|
||||
let list = params.pointer("/_meta/openidea/mcpServersOff")?.as_array()?;
|
||||
let names: Vec<Value> =
|
||||
list.iter().filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(|s| json!(s))).collect();
|
||||
(!names.is_empty()).then_some(Value::Array(names))
|
||||
}
|
||||
|
||||
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
|
||||
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
|
||||
let mut seen = HashSet::new();
|
||||
@@ -568,6 +576,28 @@ 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;
|
||||
|
||||
@@ -1214,25 +1214,15 @@ 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());
|
||||
|
||||
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"]);
|
||||
// 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();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
// Stopping a turn keeps the queue for later.
|
||||
mgr.prompt(&task.id, text("wait"), false).await.unwrap();
|
||||
@@ -1247,6 +1237,40 @@ 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();
|
||||
@@ -1311,6 +1335,25 @@ 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 {
|
||||
|
||||
@@ -47,13 +47,20 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
|
||||
fs::write(
|
||||
&script,
|
||||
format!(
|
||||
r#"gradle.projectsEvaluated {{
|
||||
r#"import org.gradle.util.GradleVersion
|
||||
|
||||
gradle.projectsEvaluated {{
|
||||
def p = gradle.rootProject.project({})
|
||||
def resources = p.tasks.named('processResources')
|
||||
p.tasks.register('openideaUpdateResources') {{
|
||||
dependsOn resources
|
||||
doLast {{ new File({}).setText(resources.get().destinationDir.absolutePath, 'UTF-8') }}
|
||||
def update = {{ t ->
|
||||
t.dependsOn 'processResources'
|
||||
// Resolved here so the action holds no task or project (configuration cache).
|
||||
def dir = p.tasks.getByName('processResources').destinationDir
|
||||
def manifest = new File({})
|
||||
t.doLast {{ manifest.setText(dir.absolutePath, 'UTF-8') }}
|
||||
}}
|
||||
// `register` is Gradle 4.9+.
|
||||
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaUpdateResources', update)
|
||||
else p.tasks.create('openideaUpdateResources', update)
|
||||
}}
|
||||
"#,
|
||||
literal(&p.path),
|
||||
@@ -172,7 +179,16 @@ mod tests {
|
||||
assert_eq!(gradle.command, "/tools/gradlew");
|
||||
assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
|
||||
let script = fs::read_to_string(cache.join("resources.init.gradle")).unwrap();
|
||||
assert!(script.contains("processResources") && script.contains("destinationDir.absolutePath"));
|
||||
assert!(
|
||||
script.contains("processResources")
|
||||
&& script.contains(".destinationDir\n")
|
||||
&& script.contains("setText(dir.absolutePath")
|
||||
);
|
||||
// `register` is Gradle 4.9+ (#3864).
|
||||
assert!(script.contains("else p.tasks.create('openideaUpdateResources', update)"), "{script}");
|
||||
// The configuration cache can't serialize a task or project the action refers to.
|
||||
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
|
||||
assert!(!action.contains("p.") && !action.contains("tasks"), "{action}");
|
||||
assert!(!script.contains("build/resources/main")); // The task owns custom output locations.
|
||||
}
|
||||
|
||||
|
||||
@@ -10,11 +10,14 @@ 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,
|
||||
}
|
||||
@@ -132,6 +135,7 @@ 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)
|
||||
{
|
||||
@@ -142,7 +146,7 @@ pub fn module_classpath(
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
|
||||
let cached = CachedClasspath { fingerprint, classpath: classpath.clone() };
|
||||
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
|
||||
if let Err(error) = cache_classpath(&path, &cached) {
|
||||
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
|
||||
}
|
||||
@@ -208,11 +212,11 @@ fn classpath(
|
||||
if dir == target.module {
|
||||
continue;
|
||||
}
|
||||
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());
|
||||
}
|
||||
// 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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -337,13 +341,19 @@ mod tests {
|
||||
root,
|
||||
"pom.xml",
|
||||
r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>
|
||||
<packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,
|
||||
<packaging>pom</packaging><modules><module>shared</module><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></project>"#,
|
||||
<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>"#,
|
||||
);
|
||||
write(
|
||||
root,
|
||||
@@ -354,6 +364,7 @@ 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)
|
||||
}
|
||||
|
||||
@@ -436,7 +447,9 @@ 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();
|
||||
@@ -451,9 +464,16 @@ 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}");
|
||||
}
|
||||
|
||||
/// A launch uses runtime dependencies, while tests additionally see test-scope ones.
|
||||
/// Launches request Maven's matching scope without adding reactor test outputs.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn launch_module_classpath_uses_the_matching_dependency_scope() {
|
||||
@@ -465,15 +485,29 @@ 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/test.jar' > \"$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/fixture-tests.jar:/repo/fixture/target/test-classes' > \"$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}");
|
||||
@@ -482,7 +516,15 @@ mod tests {
|
||||
|
||||
let test =
|
||||
module_classpath(root, &model, &root.join("app"), true, None, &cache, &CancellationToken::new()).unwrap();
|
||||
assert!(test.contains("/repo/test.jar"), "{test}");
|
||||
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}");
|
||||
let args = fs::read_to_string(root.join("args.txt")).unwrap();
|
||||
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
|
||||
}
|
||||
@@ -491,7 +533,7 @@ mod tests {
|
||||
/// build input changes; the probe does not run packaging plugins.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn launch_classpath_cache_follows_the_runner_jdk() {
|
||||
fn launch_classpath_cache_follows_the_runner_jdk_and_format() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
@@ -513,6 +555,7 @@ 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");
|
||||
@@ -526,6 +569,30 @@ 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());
|
||||
@@ -533,6 +600,7 @@ 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}");
|
||||
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "xx");
|
||||
calls.push('x');
|
||||
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
|
||||
}
|
||||
}
|
||||
@@ -30,7 +30,8 @@ def processedResources = { Project p, s ->
|
||||
def describe = { Project p ->
|
||||
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
|
||||
if (p.gradle.parent != null) m.build = identity(p.rootProject)
|
||||
def sets = p.extensions.findByName('sourceSets')
|
||||
// Gradle 4.x has it as a convention property, not an extension.
|
||||
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
|
||||
if (sets != null) {
|
||||
// Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
|
||||
// and sets whose folders the `idea` plugin lists as test sources.
|
||||
@@ -51,9 +52,12 @@ def describe = { Project p ->
|
||||
}
|
||||
}
|
||||
try {
|
||||
// `java` is Gradle 4.10+ (a convention before), its toolchain 6.7+.
|
||||
def java = p.extensions.findByName('java')
|
||||
def lv = java?.toolchain?.languageVersion?.getOrNull()
|
||||
m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
|
||||
def lv = null
|
||||
try { lv = java?.toolchain?.languageVersion?.getOrNull() } catch (ignored) {}
|
||||
def target = java != null ? java.targetCompatibility : p.findProperty('targetCompatibility')
|
||||
m.java = lv != null ? lv.asInt() : (target?.majorVersion as Integer)
|
||||
} catch (ignored) {}
|
||||
println '@openidea-model\t' + JsonOutput.toJson(m)
|
||||
}
|
||||
|
||||
@@ -172,13 +172,25 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
|
||||
fs::write(
|
||||
&script,
|
||||
format!(
|
||||
r#"gradle.projectsEvaluated {{
|
||||
r#"import org.gradle.util.GradleVersion
|
||||
|
||||
gradle.projectsEvaluated {{
|
||||
def p = gradle.rootProject.project({})
|
||||
def warTask = p.tasks.named('war')
|
||||
p.tasks.register('openideaTomcatArtifact') {{
|
||||
dependsOn warTask
|
||||
doLast {{ new File({}).setText(warTask.get().archiveFile.get().asFile.absolutePath, 'UTF-8') }}
|
||||
def artifact = {{ t ->
|
||||
t.dependsOn 'war'
|
||||
// Resolved here so the action holds no task or project (configuration cache).
|
||||
def war = p.tasks.getByName('war')
|
||||
// `archiveFile` is Gradle 5.1+, `archivePath` is gone in 8.0.
|
||||
def archive = war.hasProperty('archiveFile') ? war.archiveFile : war.archivePath
|
||||
def manifest = new File({})
|
||||
t.doLast {{
|
||||
def file = archive instanceof File ? archive : archive.get().asFile
|
||||
manifest.setText(file.absolutePath, 'UTF-8')
|
||||
}}
|
||||
}}
|
||||
// `register` is Gradle 4.9+.
|
||||
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaTomcatArtifact', artifact)
|
||||
else p.tasks.create('openideaTomcatArtifact', artifact)
|
||||
}}
|
||||
"#,
|
||||
groovy_literal(path),
|
||||
@@ -270,7 +282,7 @@ mod tests {
|
||||
assert_eq!(a.len(), 1);
|
||||
let plan = build(tmp.path(), &model, &a[0].id, &tmp.path().join("base")).unwrap();
|
||||
assert!(plan.args.contains(&":openideaTomcatArtifact".into()));
|
||||
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("archiveFile.get()"));
|
||||
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("? war.archiveFile :"));
|
||||
assert!(!crate::gradle::has_war_plugin("// plugins { war }"));
|
||||
}
|
||||
|
||||
@@ -297,7 +309,14 @@ mod tests {
|
||||
assert!(plan.args.contains(&format!("{}:openideaTomcatArtifact", module.trim_end_matches(':'))));
|
||||
let script = fs::read_to_string(cache.join("war.init.gradle")).unwrap();
|
||||
assert!(script.contains(&format!("rootProject.project('{}')", module)));
|
||||
assert!(script.contains("archiveFile.get().asFile.absolutePath, 'UTF-8'"));
|
||||
assert!(script.contains("manifest.setText(file.absolutePath, 'UTF-8')"));
|
||||
// `archiveFile` is Gradle 5.1+, `register` 4.9+ (#3864).
|
||||
assert!(
|
||||
script.contains(": war.archivePath") && script.contains("else p.tasks.create('openideaTomcatArtifact'")
|
||||
);
|
||||
// The configuration cache can't serialize a task or project the action refers to.
|
||||
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
|
||||
assert!(!action.contains("p.") && !action.contains("war."), "{action}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -348,6 +348,35 @@ mod imp {
|
||||
paths
|
||||
}
|
||||
|
||||
/// `Preferred DropEffect`: a `DWORD` saying whether the files were copied or cut.
|
||||
/// Explorer writes it with every file list, and paste targets that move files
|
||||
/// between machines (Remote Desktop's clipboard redirection, #3863) read it.
|
||||
fn drop_effect_format() -> u32 {
|
||||
let name: Vec<u16> = "Preferred DropEffect\0".encode_utf16().collect();
|
||||
unsafe { RegisterClipboardFormatW(name.as_ptr()) }
|
||||
}
|
||||
|
||||
/// `DROPEFFECT_COPY`.
|
||||
const DROPEFFECT_COPY: u32 = 1;
|
||||
|
||||
/// An `HGLOBAL` holding a copy of `bytes`. Null when the allocation failed.
|
||||
fn global_bytes(bytes: &[u8]) -> Handle {
|
||||
unsafe {
|
||||
let memory = GlobalAlloc(GMEM_MOVEABLE, bytes.len());
|
||||
if memory.is_null() {
|
||||
return ptr::null_mut();
|
||||
}
|
||||
let data = GlobalLock(memory);
|
||||
if data.is_null() {
|
||||
GlobalFree(memory);
|
||||
return ptr::null_mut();
|
||||
}
|
||||
ptr::copy_nonoverlapping(bytes.as_ptr(), data as *mut u8, bytes.len());
|
||||
GlobalUnlock(memory);
|
||||
memory
|
||||
}
|
||||
}
|
||||
|
||||
/// An `HGLOBAL` holding `text` as UTF-16 with a terminating NUL, and its
|
||||
/// byte size. Null when the allocation failed.
|
||||
fn global_text(text: &str) -> (Handle, usize) {
|
||||
@@ -430,6 +459,13 @@ mod imp {
|
||||
if !taken {
|
||||
GlobalFree(memory);
|
||||
}
|
||||
let effect = drop_effect_format();
|
||||
if effect != 0 {
|
||||
let effect_memory = global_bytes(&DROPEFFECT_COPY.to_le_bytes());
|
||||
if !effect_memory.is_null() && SetClipboardData(effect, effect_memory).is_null() {
|
||||
GlobalFree(effect_memory);
|
||||
}
|
||||
}
|
||||
let (text_memory, _) = global_text(&text);
|
||||
if !text_memory.is_null() {
|
||||
// The text alone still pastes somewhere useful.
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
[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
|
||||
@@ -0,0 +1,92 @@
|
||||
// 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
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,884 @@
|
||||
//! 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`",
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -147,6 +147,19 @@ 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>,
|
||||
|
||||
@@ -167,10 +167,11 @@ const GRADLE: &[&str] = &["gradle", "gradlew"];
|
||||
/// Gradle's own JVM and the compiler's source encoding are untouched.
|
||||
pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\
|
||||
// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.
|
||||
import org.gradle.util.GradleVersion
|
||||
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
|
||||
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
|
||||
allprojects {
|
||||
tasks.withType(JavaExec).configureEach {
|
||||
defaultCharacterEncoding = 'UTF-8'
|
||||
}
|
||||
each(tasks.withType(JavaExec)) { t -> t.defaultCharacterEncoding = 'UTF-8' }
|
||||
}
|
||||
";
|
||||
|
||||
@@ -621,10 +622,12 @@ mod tests {
|
||||
#[test]
|
||||
fn gradle_script_respects_the_builds_own_file_encoding() {
|
||||
let s = GRADLE_FILE_ENCODING_SCRIPT;
|
||||
assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");
|
||||
assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");
|
||||
assert!(s.contains("each(tasks.withType(JavaExec))"), "{s}");
|
||||
assert!(s.contains("t.defaultCharacterEncoding = 'UTF-8'"), "{s}");
|
||||
assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");
|
||||
assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");
|
||||
// Gradle before 4.9 has no `configureEach` (#3864).
|
||||
assert!(s.contains("? tasks.configureEach(action) : tasks.all(action)"), "{s}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -6,11 +6,16 @@ use ide_run::wrap::{self, program_name};
|
||||
use std::path::Path;
|
||||
|
||||
const GRADLE_INIT: &str = r#"// Written by OpenIDEA for Run with Coverage.
|
||||
allprojects {
|
||||
plugins.withId('java') {
|
||||
apply plugin: 'jacoco'
|
||||
tasks.withType(Test).configureEach { t -> t.finalizedBy(tasks.named('jacocoTestReport')) }
|
||||
tasks.named('jacocoTestReport') { r -> r.reports { xml.required.set(true) } }
|
||||
import org.gradle.util.GradleVersion
|
||||
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
|
||||
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
|
||||
allprojects { p ->
|
||||
p.plugins.withId('java') {
|
||||
p.apply plugin: 'jacoco'
|
||||
each(p.tasks.withType(Test)) { t -> t.finalizedBy('jacocoTestReport') }
|
||||
def xml = p.tasks.getByName('jacocoTestReport').reports.xml
|
||||
// `Report.required` is Gradle 6.1+, `enabled` is gone in 8.0.
|
||||
if (xml.hasProperty('required')) xml.required.set(true) else xml.enabled = true
|
||||
}
|
||||
}
|
||||
"#;
|
||||
@@ -391,7 +396,10 @@ mod tests {
|
||||
let p = prepare(dir.path(), &cfg("gradle", "./gradlew", &[":app:test", "--tests", "*Calc"]), dir.path());
|
||||
let (l, report) = launch(&p);
|
||||
assert_eq!(l.args[0], "--init-script");
|
||||
assert!(std::fs::read_to_string(&l.args[1]).unwrap().contains("jacoco"));
|
||||
let script = std::fs::read_to_string(&l.args[1]).unwrap();
|
||||
assert!(script.contains("p.apply plugin: 'jacoco'"), "{script}");
|
||||
// `Report.required` is Gradle 6.1+, `configureEach` 4.9+ (#3864).
|
||||
assert!(script.contains("else xml.enabled = true") && script.contains(": tasks.all(action)"), "{script}");
|
||||
assert!(matches!(report, CoverageReportSpec::Jacoco { .. }));
|
||||
}
|
||||
|
||||
|
||||
@@ -1624,6 +1624,7 @@ impl DebugManager {
|
||||
// DAP: a response without the flag continued every thread.
|
||||
let all = body.get("allThreadsContinued").and_then(Value::as_bool).unwrap_or(true);
|
||||
session.suspended.resumed(ticket, thread_id, all);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: all });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1672,6 +1673,7 @@ impl DebugManager {
|
||||
step_settled(&session, sent)?;
|
||||
// A step runs its thread; other threads stopped by their own events stay stopped.
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1783,6 +1785,7 @@ impl DebugManager {
|
||||
.await;
|
||||
step_settled(&session, sent)?;
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -116,6 +116,8 @@ pub(crate) struct Session {
|
||||
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
|
||||
pub stream_tracer: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::StreamTracer>>>,
|
||||
pub(crate) stream_trace: parking_lot::Mutex<Option<crate::stream_trace::ActiveTrace>>,
|
||||
/// The last trace that finished, until the stop its records were read in ends.
|
||||
pub(crate) stream_trace_done: parking_lot::Mutex<Option<crate::stream_trace::DoneTrace>>,
|
||||
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
|
||||
pub(crate) quirks: kotlin_lsp::Quirks,
|
||||
pub(crate) unity_startup_activity: Mutex<Instant>,
|
||||
@@ -281,6 +283,7 @@ impl Session {
|
||||
jvm_memory: tokio::sync::Mutex::default(),
|
||||
stream_tracer: parking_lot::Mutex::new(None),
|
||||
stream_trace: parking_lot::Mutex::new(None),
|
||||
stream_trace_done: parking_lot::Mutex::new(None),
|
||||
quirks: kotlin_lsp::Quirks::default(),
|
||||
unity_startup_activity: Mutex::new(Instant::now()),
|
||||
}
|
||||
@@ -774,6 +777,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
// DAP: an event without the flag continues its thread alone. The UI keeps treating
|
||||
// it as all threads; the suspension, which holds only threads that stopped, need not.
|
||||
s.suspended.continued(int("threadId"), all.unwrap_or(false));
|
||||
crate::stream_trace::release_done(s);
|
||||
s.emit(DebugEvent::Continued {
|
||||
thread_id: int("threadId").unwrap_or(0),
|
||||
all_threads_continued: all.unwrap_or(true),
|
||||
|
||||
@@ -88,6 +88,32 @@ pub enum TraceUnavailable {
|
||||
},
|
||||
}
|
||||
|
||||
/// A trace that finished. Its records keep their objects from being collected until the stop they
|
||||
/// were read in ends; then the UI no longer shows them and [`release_done`] lets them go.
|
||||
pub(crate) struct DoneTrace {
|
||||
tracer: Arc<dyn StreamTracer>,
|
||||
target: VmTarget,
|
||||
id: TraceId,
|
||||
}
|
||||
|
||||
/// The stop a finished trace was read in ended (a resume, a step, a `continued` event).
|
||||
pub(crate) fn release_done(s: &Session) {
|
||||
let Some(done) = s.stream_trace_done.lock().take() else { return };
|
||||
let ended = s.ended.clone();
|
||||
let session = s.id.0;
|
||||
tokio::spawn(async move {
|
||||
tokio::select! {
|
||||
biased;
|
||||
() = ended.cancelled() => {}
|
||||
result = done.tracer.release(&done.target, done.id) => {
|
||||
if let Err(e) = result {
|
||||
tracing::debug!(session, trace = done.id, "releasing a finished stream trace: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// The session's running trace; `id` is `None` until `arm` answers.
|
||||
pub(crate) struct ActiveTrace {
|
||||
tracer: Arc<dyn StreamTracer>,
|
||||
@@ -181,10 +207,30 @@ pub(crate) async fn run(
|
||||
if !s.suspended.get() {
|
||||
return unavailable(TraceUnavailable::NotSuspended);
|
||||
}
|
||||
let mut trace =
|
||||
Trace { mgr, s, tracer: &*tracer, target: &target, thread_id, progress, id: None, last: Counts::default() };
|
||||
// The bundle releases the previous trace itself when this one arms.
|
||||
s.stream_trace_done.lock().take();
|
||||
static TOKENS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
|
||||
let token =
|
||||
format!("{}-{}-{}", std::process::id(), s.id.0, TOKENS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
|
||||
let mut trace = Trace {
|
||||
mgr,
|
||||
s,
|
||||
tracer: &*tracer,
|
||||
target: &target,
|
||||
thread_id,
|
||||
progress,
|
||||
token,
|
||||
arm_sent: false,
|
||||
id: None,
|
||||
last: Counts::default(),
|
||||
};
|
||||
match trace.drive(plan, cancel).await {
|
||||
Ok(run) => run,
|
||||
Ok(run) => {
|
||||
if let (TraceRun::Done { .. }, Some(id)) = (&run, trace.id) {
|
||||
*s.stream_trace_done.lock() = Some(DoneTrace { tracer: tracer.clone(), target: target.clone(), id });
|
||||
}
|
||||
run
|
||||
}
|
||||
Err(run) => {
|
||||
// A stop from now on is the user's to see.
|
||||
set_running(s, false);
|
||||
@@ -231,6 +277,9 @@ struct Trace<'a, P> {
|
||||
target: &'a VmTarget,
|
||||
thread_id: i64,
|
||||
progress: &'a P,
|
||||
/// Names the trace to the bundle before `arm` answers (see [`StreamTracer::release_armed`]).
|
||||
token: String,
|
||||
arm_sent: bool,
|
||||
/// Set once `arm` answers.
|
||||
id: Option<TraceId>,
|
||||
last: Counts,
|
||||
@@ -241,8 +290,9 @@ impl<P: Fn(TraceProgress) + Send + Sync> Trace<'_, P> {
|
||||
async fn drive(&mut self, plan: &Value, cancel: &CancellationToken) -> Result<TraceRun, TraceRun> {
|
||||
let (s, tracer, target) = (self.s, self.tracer, self.target);
|
||||
self.report(TracePhase::Arming);
|
||||
self.arm_sent = true;
|
||||
let id = self
|
||||
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET))
|
||||
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET, &self.token))
|
||||
.await?
|
||||
.map_err(|e| if s.ended.is_cancelled() { ended() } else { refused(e) })?;
|
||||
self.id = Some(id);
|
||||
@@ -313,14 +363,20 @@ impl<P: Fn(TraceProgress) + Send + Sync> Trace<'_, P> {
|
||||
/// After a trace that ended early. Left to the bundle, an armed trace would keep every
|
||||
/// breakpoint off and a parked one its thread suspended behind java-debug's back; the bundle
|
||||
/// undoes either, or does so once a terminal still running returns. Not after a finished
|
||||
/// trace: the records it unpins are the values the result shows.
|
||||
/// trace: the records it unpins are the values the result shows ([`release_done`] does, once
|
||||
/// that stop ends). An `arm` that never answered (it timed out) may still have armed: released
|
||||
/// by its token.
|
||||
async fn release(&self) {
|
||||
let Some(id) = self.id else { return };
|
||||
if self.s.ended.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
if let Ok(Err(e)) = self.until_ended(self.tracer.release(self.target, id)).await {
|
||||
tracing::debug!(session = self.s.id.0, trace = id, "stream trace release: {e}");
|
||||
let work = match self.id {
|
||||
Some(id) => self.tracer.release(self.target, id),
|
||||
None if self.arm_sent => self.tracer.release_armed(self.target, &self.token),
|
||||
None => return,
|
||||
};
|
||||
if let Ok(Err(e)) = self.until_ended(work).await {
|
||||
tracing::debug!(session = self.s.id.0, trace = ?self.id, "stream trace release: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -55,6 +55,7 @@ impl StreamTracer for FakeTracer {
|
||||
_thread_id: i64,
|
||||
_plan: &'a Value,
|
||||
_budget: u32,
|
||||
_token: &'a str,
|
||||
) -> InspectFuture<'a, TraceId> {
|
||||
self.record("arm", target);
|
||||
let error = self.arm_error.lock().clone();
|
||||
@@ -96,6 +97,11 @@ impl StreamTracer for FakeTracer {
|
||||
self.record("release", target);
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
|
||||
fn release_armed<'a>(&'a self, target: &'a VmTarget, _token: &'a str) -> InspectFuture<'a, ()> {
|
||||
self.record("releaseArmed", target);
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
}
|
||||
|
||||
fn collected() -> TraceCollected {
|
||||
@@ -443,6 +449,36 @@ async fn a_finished_trace_is_not_released() {
|
||||
assert!(!tracer.names().contains(&"release"), "{:?}", tracer.names());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_finished_trace_is_released_once_the_program_runs_on() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
|
||||
|
||||
h.manager.resume(id, 1).await.unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !tracer.names().contains(&"release") {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("the finished trace was not released");
|
||||
assert_eq!(tracer.names().iter().filter(|n| **n == "release").count(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_arm_without_a_reply_is_released_by_its_token() {
|
||||
// The bundle may still finish arming after the reply timed out: its breakpoints would stay off.
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
|
||||
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
|
||||
assert_eq!(tracer.names(), ["arm", "releaseArmed"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn refused_stop_leaves_the_outcome_to_wait() {
|
||||
let h = harness(java_debug());
|
||||
|
||||
@@ -179,7 +179,9 @@ fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
|
||||
}
|
||||
|
||||
fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
|
||||
let mut args: Vec<String> = (!file.is_empty()).then(|| format!("--file={file}")).into_iter().collect();
|
||||
// `~/.psqlrc` could switch databases or change settings before the dump runs.
|
||||
let mut args = vec!["--no-psqlrc".to_owned()];
|
||||
args.extend((!file.is_empty()).then(|| format!("--file={file}")));
|
||||
args.extend(flag(o.single_transaction, "--single-transaction"));
|
||||
args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1"));
|
||||
args
|
||||
@@ -317,7 +319,7 @@ mod tests {
|
||||
let options = DbPsqlOptions { single_transaction: true, stop_on_error: true };
|
||||
assert_eq!(
|
||||
args(DbToolJob::Psql { file: "/tmp/shop.sql".into(), options }),
|
||||
["--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"]
|
||||
["--no-psqlrc", "--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"]
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -237,7 +237,7 @@ pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(Strin
|
||||
args.push(format!("--username={}", source.user.trim()));
|
||||
}
|
||||
if !source.database.is_empty() {
|
||||
args.push(format!("--dbname={}", source.database));
|
||||
args.push(format!("--dbname={}", dbname_arg(&source.database)));
|
||||
}
|
||||
// Without a terminal a password prompt would wait forever: fail instead.
|
||||
args.push("--no-password".into());
|
||||
@@ -271,6 +271,16 @@ pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(Strin
|
||||
(args, env)
|
||||
}
|
||||
|
||||
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
|
||||
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
|
||||
fn dbname_arg(name: &str) -> String {
|
||||
if name.contains('=') || name.starts_with("postgresql://") || name.starts_with("postgres://") {
|
||||
format!("dbname='{}'", name.replace('\\', "\\\\").replace('\'', "\\'"))
|
||||
} else {
|
||||
name.to_owned()
|
||||
}
|
||||
}
|
||||
|
||||
/// How a tool is started: connection arguments, then the job's, and the environment.
|
||||
pub struct Prepared {
|
||||
pub args: Vec<String>,
|
||||
@@ -404,6 +414,18 @@ mod tests {
|
||||
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_database_named_like_connection_parameters_stays_a_name() {
|
||||
for (name, arg) in [
|
||||
("host=evil.example dbname=p", r"--dbname=dbname='host=evil.example dbname=p'"),
|
||||
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
|
||||
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
|
||||
] {
|
||||
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
|
||||
assert!(args.contains(&arg.to_owned()), "{args:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_port_and_optional_fields() {
|
||||
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
|
||||
|
||||
@@ -24,6 +24,16 @@ 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 {
|
||||
@@ -55,6 +65,7 @@ impl DockerEndpoint {
|
||||
args
|
||||
}
|
||||
Self::Context { name } => vec!["--context".into(), name.trim().to_owned()],
|
||||
Self::Ssh { config } => vec!["--host".into(), unresolved_ssh(config)],
|
||||
}
|
||||
}
|
||||
|
||||
@@ -101,6 +112,11 @@ 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
|
||||
}
|
||||
@@ -111,8 +127,13 @@ 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 or context")) } else { Ok(()) }
|
||||
if empty {
|
||||
Err(IdeError::invalid("the Docker connection needs a socket, host, context or SSH configuration"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -325,6 +346,17 @@ 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());
|
||||
|
||||
@@ -142,7 +142,7 @@ pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
|
||||
}
|
||||
const FMT: &str = "{{json .}}";
|
||||
let (containers, images, volumes, networks) = std::thread::scope(|s| {
|
||||
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", FMT], QUICK));
|
||||
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", PS_FORMAT], QUICK));
|
||||
let i = s.spawn(|| run(ep, &["image", "ls", "--no-trunc", "--format", FMT], QUICK));
|
||||
let v = s.spawn(|| run(ep, &["volume", "ls", "--format", FMT], QUICK));
|
||||
let n = s.spawn(|| run(ep, &["network", "ls", "--no-trunc", "--format", FMT], QUICK));
|
||||
@@ -483,6 +483,7 @@ 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))
|
||||
}
|
||||
|
||||
@@ -226,6 +226,16 @@ fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> +
|
||||
})
|
||||
}
|
||||
|
||||
/// The `docker ps --format` template: only the fields [`RawContainer`] reads. `{{json .}}`
|
||||
/// would also include `Size`, which makes the daemon compute every container's writable
|
||||
/// layer and can take tens of seconds.
|
||||
pub const PS_FORMAT: &str = concat!(
|
||||
r#"{"ID":{{json .ID}},"Names":{{json .Names}},"Image":{{json .Image}},"#,
|
||||
r#""Command":{{json .Command}},"State":{{json .State}},"Status":{{json .Status}},"#,
|
||||
r#""Ports":{{json .Ports}},"CreatedAt":{{json .CreatedAt}},"Labels":{{json .Labels}},"#,
|
||||
r#""Mounts":{{json .Mounts}},"Networks":{{json .Networks}}}"#,
|
||||
);
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct RawContainer {
|
||||
@@ -247,7 +257,7 @@ fn split_csv(raw: &str) -> Vec<String> {
|
||||
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
|
||||
}
|
||||
|
||||
/// `docker ps -a --no-trunc --format '{{json .}}'`.
|
||||
/// `docker ps -a --no-trunc --format` [`PS_FORMAT`] (or `'{{json .}}'`).
|
||||
pub fn parse_containers(text: &str) -> Vec<DockerContainer> {
|
||||
let mut out: Vec<DockerContainer> = lines::<RawContainer>(text)
|
||||
.map(|r| {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
//! Parsing of recorded `docker … --format '{{json .}}'` output.
|
||||
|
||||
use ide_docker::{
|
||||
parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images, parse_networks,
|
||||
parse_volumes,
|
||||
PS_FORMAT, parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images,
|
||||
parse_networks, parse_volumes,
|
||||
};
|
||||
|
||||
const PS: &str = include_str!("fixtures/ps.jsonl");
|
||||
@@ -10,6 +10,27 @@ const IMAGES: &str = include_str!("fixtures/images.jsonl");
|
||||
const VOLUMES: &str = include_str!("fixtures/volumes.jsonl");
|
||||
const NETWORKS: &str = include_str!("fixtures/networks.jsonl");
|
||||
|
||||
/// Fills `{{json .Field}}` placeholders of a `--format` template from a `{{json .}}` line.
|
||||
fn render(template: &str, line: &str) -> String {
|
||||
let fields: serde_json::Map<String, serde_json::Value> = serde_json::from_str(line).unwrap();
|
||||
let mut out = template.to_owned();
|
||||
while let Some(start) = out.find("{{json .") {
|
||||
let end = start + out[start..].find("}}").unwrap() + 2;
|
||||
let key = &out[start + "{{json .".len()..end - 2];
|
||||
let value = fields.get(key).unwrap_or_else(|| panic!("fixture lacks {key}"));
|
||||
out.replace_range(start..end, &value.to_string());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ps_format_carries_everything_the_parser_reads_but_size() {
|
||||
assert!(!PS_FORMAT.contains("Size"), "Size makes the daemon compute container sizes");
|
||||
let rendered: Vec<String> = PS.lines().filter(|l| l.starts_with('{')).map(|l| render(PS_FORMAT, l)).collect();
|
||||
assert_eq!(rendered.len(), 2);
|
||||
assert_eq!(parse_containers(&rendered.join("\n")), parse_containers(PS));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn containers_with_compose_labels() {
|
||||
let c = parse_containers(PS);
|
||||
|
||||
@@ -11,6 +11,7 @@ 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,6 +1,7 @@
|
||||
//! `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};
|
||||
@@ -102,7 +103,7 @@ async fn run(base: PathBuf) -> i32 {
|
||||
if let Some(plugins) = &plugins {
|
||||
plugins.register(&mut dispatcher);
|
||||
}
|
||||
dispatcher.add(SYNC_COMMAND, move |c| {
|
||||
dispatcher.add(SYNC_COMMAND, TrustClass::Trusted, move |c| {
|
||||
let remote = plugin_languages.clone();
|
||||
async move {
|
||||
let report = remote.sync(c.arg("languages")?);
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
//! 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,
|
||||
}
|
||||
@@ -4,6 +4,7 @@
|
||||
//! 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;
|
||||
@@ -23,7 +24,7 @@ pub mod rpc;
|
||||
pub mod shell_env;
|
||||
pub mod trust;
|
||||
|
||||
pub use project::{Project, apply_git_executable, apply_workspace_edit, history_retention};
|
||||
pub use project::{Project, apply_git_executable, history_retention};
|
||||
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId, SharedSink};
|
||||
use ide_language::{LanguageRegistry, Syntax};
|
||||
@@ -91,6 +92,8 @@ 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
|
||||
@@ -161,6 +164,7 @@ 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,
|
||||
@@ -191,6 +195,12 @@ impl Host {
|
||||
};
|
||||
host.apply_proxy();
|
||||
host.apply_added_jdks();
|
||||
// Before any project starts jdtls; the deleting itself can take a while.
|
||||
let unused =
|
||||
ide_sdk::jdtls_workspaces::take_unused(&host.local_data_dir, ide_sdk::jdtls_workspaces::UNUSED_FOR);
|
||||
if !unused.is_empty() {
|
||||
std::thread::spawn(move || ide_sdk::jdtls_workspaces::remove(unused));
|
||||
}
|
||||
ops::agent::move_user_mcp_values(&host);
|
||||
host
|
||||
}
|
||||
|
||||
@@ -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: crate::ops::Emit<SearchEvent> = {
|
||||
let emit = {
|
||||
let files = files.clone();
|
||||
Arc::new(move |event| {
|
||||
crate::ops::Channel::new(move |event: SearchEvent| {
|
||||
if let SearchEvent::File { file } = event {
|
||||
files.lock().push(file);
|
||||
}
|
||||
})
|
||||
};
|
||||
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
|
||||
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
|
||||
tokio::pin!(search);
|
||||
tokio::select! {
|
||||
r = &mut search => r?,
|
||||
|
||||
@@ -57,7 +57,7 @@ The maximum accepted limit is 5000 lines.",
|
||||
probe.size
|
||||
)));
|
||||
}
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
|
||||
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
|
||||
Ok(Output::text(render_slice(&text, offset as usize, limit as usize, window)?))
|
||||
},
|
||||
)
|
||||
|
||||
@@ -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::read_text(&call.host(), call.window(), path).await?;
|
||||
let text = crate::ops::fs::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::read_text(&call.host(), call.window(), path.clone()).await?;
|
||||
let text = crate::ops::fs::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)))?;
|
||||
|
||||
@@ -9,7 +9,7 @@ pub use requests::Requests;
|
||||
mod files;
|
||||
mod http;
|
||||
mod page;
|
||||
mod reports;
|
||||
pub mod reports;
|
||||
mod scope;
|
||||
mod search;
|
||||
mod symbols;
|
||||
@@ -19,7 +19,9 @@ mod util;
|
||||
use crate::Host;
|
||||
use ide_core::{CancellationToken, IdeError};
|
||||
use ide_mcp::{ToolCallError, ToolRegistry};
|
||||
pub use reports::{FileProblems, FocusedEditor, Reports};
|
||||
pub use reports::{
|
||||
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
|
||||
};
|
||||
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
//! 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};
|
||||
@@ -134,6 +135,37 @@ 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::*;
|
||||
@@ -154,3 +186,10 @@ 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,
|
||||
);
|
||||
@@ -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::close_stdin(&host, id)?;
|
||||
crate::ops::run::run_close_stdin(&host, id)?;
|
||||
} else {
|
||||
run.agent_stopping();
|
||||
crate::ops::run::stop(&host, &run.window(), id)?;
|
||||
crate::ops::run::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::stop(&host, &run.window(), id)?;
|
||||
crate::ops::run::run_stop(&host, &run.window(), id)?;
|
||||
if force {
|
||||
// A second Stop kills the tree.
|
||||
crate::ops::run::stop(&host, &run.window(), id)?;
|
||||
crate::ops::run::run_stop(&host, &run.window(), id)?;
|
||||
}
|
||||
let end = run.wait(deadline, None, run.log_len(), &call.cancel).await?;
|
||||
let mut extra = Map::new();
|
||||
|
||||
@@ -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::list(host).into_iter().find(|r| r.id == id) {
|
||||
Err(_) => match crate::ops::run::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::stop(&host, call.window(), id);
|
||||
let _ = crate::ops::run::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::Emit<OutputChunk> {
|
||||
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Channel<OutputChunk> {
|
||||
let f = Mutex::new(move |t: &str| f(t));
|
||||
Arc::new(move |chunk: OutputChunk| match &chunk {
|
||||
crate::ops::Channel::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::start(&call.host(), call.window(), config, emit).await?;
|
||||
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).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::start(&call.host(), call.window(), config, emit).await {
|
||||
let info = match crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await {
|
||||
Ok(info) => info,
|
||||
Err(e) => {
|
||||
let _ = std::fs::remove_file(&output_path);
|
||||
|
||||
@@ -25,12 +25,17 @@ impl Scope {
|
||||
} else {
|
||||
call.root().join(given)
|
||||
});
|
||||
let roots: Vec<PathBuf> =
|
||||
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
|
||||
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
|
||||
if !ide_vfs::content_path_allowed(&path, &roots) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
let path = dunce::canonicalize(&path).unwrap_or(path);
|
||||
if !path.is_dir() {
|
||||
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
|
||||
}
|
||||
let roots = std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots());
|
||||
if !roots.into_iter().any(|root| path.starts_with(root)) {
|
||||
if !roots.iter().any(|root| path.starts_with(root)) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
Ok(Self(Some(path)))
|
||||
|
||||
@@ -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::read_text(&host, call.window(), path.clone()).await.ok();
|
||||
let text = crate::ops::fs::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::read_text(&host, call.window(), file.path.0.clone())
|
||||
crate::ops::fs::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::read_text(&host, call.window(), path.clone()).await else { continue };
|
||||
let Ok(text) = crate::ops::fs::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: crate::ops::Emit<SearchEvent> = {
|
||||
let emit = {
|
||||
let (files, done) = (files.clone(), done.clone());
|
||||
Arc::new(move |event| match event {
|
||||
crate::ops::Channel::new(move |event: SearchEvent| match event {
|
||||
SearchEvent::File { file } => files.lock().push(file),
|
||||
SearchEvent::Done { summary } => *done.lock() = Some(summary),
|
||||
})
|
||||
};
|
||||
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
|
||||
let search = crate::ops::search::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::read_dir(
|
||||
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::fs_read_dir(
|
||||
&self.host,
|
||||
&self.window,
|
||||
dir.to_path_buf(),
|
||||
@@ -883,14 +883,20 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let host = call.host();
|
||||
let project = call.project().clone();
|
||||
let indexing_before = project.index.status().indexing;
|
||||
let pool = if scope.is_all() && dir.dir().is_none() {
|
||||
limit + 1
|
||||
} else {
|
||||
((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL)
|
||||
};
|
||||
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
|
||||
let found = {
|
||||
let (project, q) = (project.clone(), q.clone());
|
||||
host.blocking(move || Ok(project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool))).await?
|
||||
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
|
||||
host.blocking(move || {
|
||||
Ok(match dir {
|
||||
// Filtered in the index: a pool cut before the filter could miss every match.
|
||||
Some(dir) => project
|
||||
.index
|
||||
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
|
||||
.unwrap_or_default(),
|
||||
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
|
||||
})
|
||||
})
|
||||
.await?
|
||||
};
|
||||
let mut items: Vec<SearchItem> = found
|
||||
.into_iter()
|
||||
@@ -910,10 +916,14 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let budget = MEDIUM_TIMEOUT.saturating_sub(started.elapsed());
|
||||
let (symbols, out_of_time) = workspace_symbols(&call, &q, budget).await;
|
||||
timed_out = out_of_time;
|
||||
let mut roots = project.content_roots();
|
||||
roots.extend(crate::mcp::tool::attached_projects(call.root()));
|
||||
for (name, container, location) in symbols {
|
||||
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
|
||||
// Project files obey `scope` and `paths`; library symbols are what was asked for.
|
||||
let inside = location.uri.is_none() && !Path::new(&path).is_absolute();
|
||||
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
|
||||
// are what was asked for.
|
||||
let inside = location.uri.is_none()
|
||||
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
|
||||
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
//! 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, Emit};
|
||||
use super::Channel;
|
||||
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,
|
||||
@@ -11,6 +10,7 @@ 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,38 +18,47 @@ use std::collections::HashSet;
|
||||
use std::sync::{LazyLock, Mutex};
|
||||
|
||||
/// Streams the project's agent events to this window; returns every task.
|
||||
pub fn subscribe(host: &Host, window: &str, on_event: Emit<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe(on_event))
|
||||
#[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 providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_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(®istry_paths(host), &mut providers);
|
||||
Ok(providers)
|
||||
}
|
||||
|
||||
/// Refreshes the selected agent's model catalog without sending a prompt.
|
||||
pub fn refresh_models(
|
||||
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_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`.
|
||||
pub fn set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_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; empty clears them.
|
||||
pub fn set_env(
|
||||
/// 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(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
@@ -88,7 +97,8 @@ 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)`.
|
||||
pub async fn registry_list(host: &Host, _window: &str, request: RequestId) -> IdeResult<AgentRegistry> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_registry_list(host: &Host, request: RequestId) -> IdeResult<AgentRegistry> {
|
||||
let paths = registry_paths(host);
|
||||
let cancel = host.begin_request(request);
|
||||
let result =
|
||||
@@ -130,15 +140,15 @@ impl Drop for Installing {
|
||||
}
|
||||
|
||||
/// Installs the registry's current version of agent `id` (also to update it), streaming
|
||||
/// progress through `on_event`; the agent then shows in `agent_providers`. Cancel with
|
||||
/// `cancel_request(request)`.
|
||||
pub async fn registry_install(
|
||||
/// progress through `on_event`. Cancel with `cancel_request(request)`.
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_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);
|
||||
@@ -189,7 +199,8 @@ pub async fn registry_install(
|
||||
}
|
||||
|
||||
/// Removes a registry agent: its agent file and installed files.
|
||||
pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_registry_remove(host: &Host, 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() {
|
||||
@@ -200,7 +211,8 @@ pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResul
|
||||
|
||||
/// 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).
|
||||
pub async fn commands(
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_commands(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
@@ -210,26 +222,36 @@ pub async fn commands(
|
||||
}
|
||||
|
||||
/// Entries of `task`'s conversation, or of its subagent `subagent`'s.
|
||||
pub fn entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_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. Reads
|
||||
/// transcripts from disk on the blocking pool.
|
||||
pub async fn external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
|
||||
/// 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.
|
||||
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.
|
||||
pub async fn import_session(host: &Host, window: &str, provider: String, session_id: String) -> IdeResult<AgentTask> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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)?
|
||||
}
|
||||
|
||||
pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> IdeResult<AgentTask> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_create(host: &Host, window: &str, 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();
|
||||
@@ -240,98 +262,123 @@ pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> Ide
|
||||
}
|
||||
|
||||
/// Sends a message; while the agent works it is queued, or with `now` it interrupts the turn.
|
||||
pub async fn prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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).
|
||||
pub fn unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_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.
|
||||
pub fn send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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)
|
||||
host.project(window)?.agents.send_queued_now(&task, &queued).await
|
||||
}
|
||||
|
||||
/// Changes a session setting (model, mode, thinking effort…).
|
||||
pub async fn set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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`).
|
||||
pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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.
|
||||
pub async fn rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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, without opening a session.
|
||||
pub async fn probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
|
||||
/// 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> {
|
||||
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.
|
||||
pub fn cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_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.
|
||||
pub async fn stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_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: None` cancels it.
|
||||
pub fn respond(host: &Host, window: &str, task: String, permission: u32, option: Option<String>) -> IdeResult<()> {
|
||||
/// 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<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.respond(&task, permission, option)
|
||||
}
|
||||
|
||||
pub fn archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.archive(&task)
|
||||
}
|
||||
|
||||
pub fn unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.unarchive(&task)
|
||||
}
|
||||
|
||||
pub fn rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.rename(&task, &title)
|
||||
}
|
||||
|
||||
pub async fn delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.delete(&task, remove_worktree).await
|
||||
}
|
||||
|
||||
pub async fn changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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.
|
||||
pub async fn grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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).
|
||||
pub async fn base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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.
|
||||
pub async fn rollback_changes(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_rollback_changes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
@@ -344,7 +391,8 @@ pub async fn 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.
|
||||
pub async fn accept_changes(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_accept_changes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
@@ -457,6 +505,7 @@ fn persist_mcp_map(
|
||||
host.global_settings.set(ide_workspace::settings::SettingsScope::Global, "agents.mcpServers", value)?;
|
||||
for p in host.projects() {
|
||||
p.settings.reload();
|
||||
p.agents.notify_mcp_servers_changed();
|
||||
p.sink.emit(event.clone());
|
||||
if kept == Kept::LocalFile {
|
||||
host.agent_secrets.notify_kept_locally(&p.sink);
|
||||
@@ -466,6 +515,7 @@ fn persist_mcp_map(
|
||||
McpScope::Workspace => {
|
||||
let p = project.ok_or_else(|| IdeError::invalid("Open a project to configure workspace MCP servers"))?;
|
||||
p.settings.set(ide_workspace::settings::SettingsScope::Project, "agents.mcpServers", value)?;
|
||||
p.agents.notify_mcp_servers_changed();
|
||||
p.sink.emit(event);
|
||||
}
|
||||
}
|
||||
@@ -533,20 +583,31 @@ pub(crate) fn session_mcp_servers(
|
||||
use ide_workspace::settings::SettingsScope;
|
||||
let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
|
||||
fill_mcp_values(secrets, &mut user);
|
||||
let mut workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
|
||||
workspace.retain(|name, srv| approvals.approved(root, name, srv));
|
||||
ide_agent::mcp::servers_from_settings(&user, &workspace)
|
||||
let raw_workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
|
||||
let workspace = approvals.apply(root, raw_workspace.clone());
|
||||
let mut out = ide_agent::mcp::servers_from_settings(&user, &workspace);
|
||||
for srv in &mut out {
|
||||
if srv.scope == McpScope::Workspace
|
||||
&& let Some(raw) = raw_workspace.get(&srv.name)
|
||||
{
|
||||
srv.unapproved = !approvals.approved(root, &srv.name, raw);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// 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>> {
|
||||
/// 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.
|
||||
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. A Workspace
|
||||
/// server saved here is one the user turned on.
|
||||
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
|
||||
/// 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.
|
||||
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| {
|
||||
@@ -555,8 +616,9 @@ pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<V
|
||||
}
|
||||
|
||||
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
|
||||
/// single server object). Workspace servers explicitly saved here by the user are approved.
|
||||
pub fn mcp_save_json(
|
||||
/// single server object).
|
||||
#[command(trust = always)]
|
||||
pub fn agent_mcp_save_json(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
scope: McpScope,
|
||||
@@ -564,6 +626,7 @@ pub fn 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,
|
||||
@@ -579,7 +642,8 @@ pub fn mcp_save_json(
|
||||
}
|
||||
|
||||
/// Enables or disables an MCP server and returns the updated list.
|
||||
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_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())
|
||||
@@ -591,15 +655,17 @@ pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) ->
|
||||
}
|
||||
|
||||
/// Removes a User or Workspace MCP server and returns the updated list.
|
||||
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_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;
|
||||
/// they stay off until the user turns them on.
|
||||
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
/// 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.
|
||||
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);
|
||||
@@ -608,7 +674,8 @@ pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
}
|
||||
|
||||
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
|
||||
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_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 || {
|
||||
@@ -619,14 +686,15 @@ pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<Mc
|
||||
}
|
||||
|
||||
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
|
||||
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
|
||||
pub async fn mcp_import_selected(
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_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(
|
||||
@@ -643,7 +711,8 @@ pub async fn mcp_import_selected(
|
||||
}
|
||||
|
||||
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
|
||||
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_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)
|
||||
@@ -823,8 +892,9 @@ 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 `task`.
|
||||
pub fn set_mcp_overrides(
|
||||
/// Updates per-session MCP server enable/disable overrides on `task`.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_set_mcp_overrides(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
@@ -833,85 +903,6 @@ pub fn 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());
|
||||
@@ -1020,3 +1011,49 @@ 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,
|
||||
);
|
||||
@@ -6,7 +6,7 @@
|
||||
use crate::Host;
|
||||
use crate::Project;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use super::doc::blocking;
|
||||
use ide_analysis::{
|
||||
@@ -122,6 +122,7 @@ 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,
|
||||
@@ -195,6 +196,7 @@ 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,
|
||||
@@ -217,7 +219,8 @@ pub async fn analysis_locate_duplicates(
|
||||
}
|
||||
|
||||
/// Languages Search Structurally supports (those with a bundled grammar).
|
||||
pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<StructuralLanguage>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn structural_languages(host: &Host) -> IdeResult<Vec<StructuralLanguage>> {
|
||||
let syntax = host.syntax();
|
||||
let mut out: Vec<StructuralLanguage> = host
|
||||
.languages
|
||||
@@ -231,7 +234,8 @@ pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<S
|
||||
}
|
||||
|
||||
/// Checks a structural search template (and language) while the user types.
|
||||
pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQuery) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn structural_validate(host: &Host, query: StructuralQuery) -> IdeResult<()> {
|
||||
let syntax = host.syntax();
|
||||
blocking(move || ide_analysis::validate_structural(&syntax, &query)).await
|
||||
}
|
||||
@@ -239,6 +243,7 @@ pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQu
|
||||
/// 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,
|
||||
@@ -265,18 +270,11 @@ pub async fn structural_search(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 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
|
||||
});
|
||||
}
|
||||
ide_command::domain!(
|
||||
analysis:
|
||||
analysis_locate_duplicates,
|
||||
inspect_code,
|
||||
structural_languages,
|
||||
structural_search,
|
||||
structural_validate,
|
||||
);
|
||||
@@ -4,8 +4,8 @@ mod workspace;
|
||||
|
||||
use super::dependencies::{MavenCentralArtifacts, MavenCentralGroups, MavenCentralVersions};
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use crate::{Host, Project, apply_workspace_edit};
|
||||
use crate::{Host, Project};
|
||||
use ide_command::command;
|
||||
|
||||
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
|
||||
use ide_build::maven::PomGoto;
|
||||
@@ -126,6 +126,7 @@ 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)?;
|
||||
@@ -202,13 +203,15 @@ async fn set_gradle_projects(host: &Host, window: &str, paths: Vec<String>, link
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// Links independent builds without changing their Gradle scripts.
|
||||
#[command(trust = trusted)]
|
||||
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
|
||||
}
|
||||
|
||||
/// Stops importing the selected independent builds; files and saved run configurations stay intact.
|
||||
#[command(trust = trusted)]
|
||||
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
|
||||
}
|
||||
|
||||
@@ -216,6 +219,7 @@ 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,
|
||||
@@ -419,7 +423,8 @@ fn declaring_pom(
|
||||
}
|
||||
|
||||
/// The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
|
||||
/// build has downloaded it (`ide_sdk::libraries::published_version_catalog`).
|
||||
/// build has downloaded it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn gradle_published_catalog(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -434,8 +439,8 @@ pub async fn gradle_published_catalog(
|
||||
.map_err(join_err)
|
||||
}
|
||||
|
||||
/// The resolved dependency tree of the Gradle project `gradle_path` (`:`, `:app`) for
|
||||
/// `configuration`, from Gradle's `dependencies` report; cancellable with `cancel_request(request)`.
|
||||
/// The resolved dependency tree of a Gradle project for one configuration (Dependency Analyzer).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn gradle_dependencies(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -445,6 +450,7 @@ 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();
|
||||
@@ -518,6 +524,7 @@ 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,
|
||||
@@ -534,14 +541,15 @@ pub async fn maven_dependency_declaration(
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// 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
|
||||
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
|
||||
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
|
||||
/// 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.
|
||||
/// entry providing the dependency's / plugin's version, along the parent chain.
|
||||
#[command(trust = trusted)]
|
||||
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);
|
||||
@@ -572,12 +580,8 @@ 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`: 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.
|
||||
/// in the value of in the POM `doc`, from the local repository and Maven Central.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_dependency_completion(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -585,6 +589,10 @@ 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();
|
||||
@@ -654,6 +662,7 @@ 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,
|
||||
@@ -671,7 +680,7 @@ pub async fn maven_exclude_dependency(
|
||||
files: vec![FileEdit::Edit { path: path.clone().into(), edits: vec![edit], version: None }],
|
||||
..Default::default()
|
||||
};
|
||||
apply_workspace_edit(&project.documents, &edit)?;
|
||||
project.documents.apply_workspace_edit(&edit)?;
|
||||
}
|
||||
Some(Exclusion::Present) => {}
|
||||
None => return Err(IdeError::not_found(format!("{dependency} is not declared in {}", path.display()))),
|
||||
@@ -778,6 +787,7 @@ 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,
|
||||
@@ -876,12 +886,19 @@ 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(result)
|
||||
Ok::<_, IdeError>(result)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
result?
|
||||
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)
|
||||
}
|
||||
|
||||
/// Build › Compile File: compiles one Java source of a linked Maven module with
|
||||
@@ -889,6 +906,7 @@ 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,
|
||||
@@ -917,79 +935,16 @@ 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(result)
|
||||
Ok::<_, IdeError>(result)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
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
|
||||
});
|
||||
let outcome = result??;
|
||||
if outcome.system == ide_build::compile::BuildSystem::Maven {
|
||||
project.lsp.sync_maven_generated_sources(&project.root).await;
|
||||
}
|
||||
Ok(outcome)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -1316,3 +1271,19 @@ 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,
|
||||
);
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Raw file bytes for the image viewer and hex view (see `ide_vfs::bytes`).
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use crate::ops::doc::blocking;
|
||||
use ide_core::IdeResult;
|
||||
@@ -8,27 +8,24 @@ use ide_vfs::{ByteRange, FileProbe};
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// Size and text/binary classification, from the file's head only.
|
||||
pub async fn fs_probe(_host: &Host, _window: &str, path: PathBuf) -> IdeResult<FileProbe> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_probe(path: PathBuf) -> IdeResult<FileProbe> {
|
||||
blocking(move || ide_vfs::probe(&path)).await
|
||||
}
|
||||
|
||||
/// Up to `len` bytes from `offset` (capped per call), base64-encoded.
|
||||
pub async fn fs_read_range(_host: &Host, _window: &str, path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_read_range(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. 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> {
|
||||
/// 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.
|
||||
let opened: Vec<PathBuf> = host.projects().iter().map(|project| project.root.clone()).collect();
|
||||
blocking(move || ide_vfs::read_data_url(&path, &opened)).await
|
||||
}
|
||||
|
||||
/// 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 });
|
||||
}
|
||||
ide_command::domain!(bytes: fs_probe, fs_read_image, fs_read_range);
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Run with Coverage: launch plans and coverage reports.
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use ide_core::{IdeError, IdeResult, IpcPath};
|
||||
use ide_coverage::{CoveragePrepared, CoverageReportSpec, CoverageSuite};
|
||||
@@ -15,6 +15,7 @@ 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)?;
|
||||
@@ -27,21 +28,19 @@ 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, JaCoCo XML or a SimpleCov resultset,
|
||||
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile or JaCoCo XML,
|
||||
/// 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
|
||||
}
|
||||
|
||||
/// 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 });
|
||||
}
|
||||
ide_command::domain!(coverage: coverage_collect, coverage_import, coverage_prepare);
|
||||
@@ -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 crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
|
||||
use ide_db::split::SqlStatement;
|
||||
use ide_db::{
|
||||
@@ -24,172 +24,15 @@ pub struct StatementOutcome {
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
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>> {
|
||||
#[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).
|
||||
host.project(window)?.db.sources()
|
||||
}
|
||||
|
||||
/// Replaces the project's data sources with `sources`.
|
||||
pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
|
||||
#[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`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.save_sources(sources).await?;
|
||||
let root = host.project(window)?.root.clone();
|
||||
@@ -199,222 +42,279 @@ pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.set_password(id, password, save).await
|
||||
db.set_password(&id, password, save).await
|
||||
}
|
||||
|
||||
/// Test Connection: connects with unsaved settings and returns the server version.
|
||||
pub async fn test(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_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
|
||||
}
|
||||
|
||||
/// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
|
||||
pub async fn test_tunnel(
|
||||
/// Data Source › SSH/SSL › Test SSH Tunnel.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_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
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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`).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.set_ssh_secret(id, secret, save).await
|
||||
db.set_ssh_secret(&id, secret, save).await
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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`).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.trust_ssh_host(id).await
|
||||
db.trust_ssh_host(&id).await
|
||||
}
|
||||
|
||||
/// The data sources with an open connection.
|
||||
pub fn connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
|
||||
// The data sources with an open connection.
|
||||
Ok(host.project(window)?.db.connected())
|
||||
}
|
||||
|
||||
/// Connects (fails with `permissionDenied` when the password is missing or wrong).
|
||||
pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
|
||||
#[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).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.pool(id).await.map(|_| ())
|
||||
db.pool(&id).await.map(|_| ())
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.set_manual_commit(id, manual).await
|
||||
db.set_manual_commit(&id, manual).await
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.finish_transaction(id, commit).await
|
||||
db.finish_transaction(&id, commit).await
|
||||
}
|
||||
|
||||
/// Closes the connection of data source `id`.
|
||||
pub async fn disconnect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
// Closes the connection of data source `id`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.disconnect(id).await;
|
||||
db.disconnect(&id).await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
#[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>`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.databases(id).await
|
||||
db.databases(&id).await
|
||||
}
|
||||
|
||||
/// The schemas of `database` of Snowflake data source `id` with their tables and views.
|
||||
pub async fn database_catalog(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_database_catalog(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
database: &str,
|
||||
id: String,
|
||||
database: String,
|
||||
) -> 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
|
||||
}
|
||||
|
||||
/// 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>> {
|
||||
#[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.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.saved_catalog(id).await
|
||||
db.saved_catalog(&id).await
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.retain_catalog(id, databases).await
|
||||
db.retain_catalog(&id, databases).await
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
#[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.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.session_context(id).await
|
||||
db.session_context(&id).await
|
||||
}
|
||||
|
||||
/// The schemas of data source `id`.
|
||||
pub async fn schemas(host: &Host, window: &str, id: &str) -> IdeResult<Vec<String>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_schemas(host: &Host, window: &str, id: String) -> IdeResult<Vec<String>> {
|
||||
// The schemas of data source `id`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.schemas(id).await
|
||||
db.schemas(&id).await
|
||||
}
|
||||
|
||||
/// The tables and views of `schema`.
|
||||
pub async fn tables(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<Vec<TableInfo>> {
|
||||
#[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`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.tables(id, schema).await
|
||||
db.tables(&id, &schema).await
|
||||
}
|
||||
|
||||
/// 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(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_table_details(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
schema: &str,
|
||||
kind: DbObjectKind,
|
||||
name: &str,
|
||||
) -> IdeResult<String> {
|
||||
id: String,
|
||||
schema: String,
|
||||
table: String,
|
||||
) -> IdeResult<TableDetails> {
|
||||
// Columns, keys and indexes of `table`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.object_ddl(id, schema, kind, name).await
|
||||
db.table_details(&id, &schema, &table).await
|
||||
}
|
||||
|
||||
/// Explain Plan: the execution plan of `statement` on `id`, without running it.
|
||||
pub async fn explain(
|
||||
#[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,
|
||||
kind: DbObjectKind,
|
||||
name: String,
|
||||
) -> 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
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_explain(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
statement: &str,
|
||||
schema: Option<&str>,
|
||||
id: String,
|
||||
statement: String,
|
||||
schema: Option<String>,
|
||||
) -> 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).await;
|
||||
let result = db.explain(&id, &statement, &cancel, schema.as_deref()).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// The statements data source `id` ran, newest first (Browse Query History).
|
||||
pub async fn history(host: &Host, window: &str, id: &str) -> IdeResult<Vec<HistoryEntry>> {
|
||||
#[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).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.history(id).await
|
||||
db.history(&id).await
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.remove_history(id, texts).await
|
||||
db.remove_history(&id, texts).await
|
||||
}
|
||||
|
||||
/// Tables, columns and foreign keys for SQL completion.
|
||||
pub async fn completion(host: &Host, window: &str, id: &str) -> IdeResult<CompletionModel> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_completion(host: &Host, window: &str, id: String) -> IdeResult<CompletionModel> {
|
||||
// Tables, columns and foreign keys for SQL completion.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.completion(id).await
|
||||
db.completion(&id).await
|
||||
}
|
||||
|
||||
/// 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;
|
||||
#[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;
|
||||
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)]
|
||||
pub async fn execute(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_execute(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
id: String,
|
||||
statements: Vec<SqlStatement>,
|
||||
skip: u32,
|
||||
// Clients before pagination send no `skip`.
|
||||
#[default] skip: u32,
|
||||
max_rows: u32,
|
||||
schema: Option<&str>,
|
||||
schema: Option<String>,
|
||||
) -> 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).await {
|
||||
match db
|
||||
.execute_from(&id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema.as_deref())
|
||||
.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);
|
||||
@@ -435,57 +335,62 @@ pub async fn execute(
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// One page of the rows of `table` (the table editor).
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn table_page(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_table_page(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
id: String,
|
||||
schema: String,
|
||||
table: String,
|
||||
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
|
||||
}
|
||||
|
||||
/// Submits the table editor's changes in one transaction; returns the rows changed.
|
||||
pub async fn apply_edits(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_apply_edits(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
id: String,
|
||||
schema: String,
|
||||
table: String,
|
||||
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)
|
||||
}
|
||||
|
||||
/// 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");
|
||||
#[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");
|
||||
if !file.exists() {
|
||||
std::fs::write(&file, "")?;
|
||||
}
|
||||
Ok(file.into())
|
||||
}
|
||||
|
||||
/// 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)?;
|
||||
/// 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)?;
|
||||
let default = dir.join("console.sql");
|
||||
let mut numbered: Vec<(u32, PathBuf)> = std::fs::read_dir(&dir)?
|
||||
.filter_map(|e| {
|
||||
@@ -564,3 +469,40 @@ 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,
|
||||
);
|
||||
@@ -4,12 +4,13 @@ mod kotlin_tests;
|
||||
mod output;
|
||||
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
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" {
|
||||
@@ -272,44 +273,38 @@ 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
|
||||
}
|
||||
|
||||
pub async fn debug_threads(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_threads(host: &Host, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
|
||||
host.debugger.threads(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_stack_trace(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
) -> IdeResult<Vec<StackFrame>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_stack_trace(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<Vec<StackFrame>> {
|
||||
host.debugger.stack_trace(session, thread_id).await
|
||||
}
|
||||
|
||||
pub async fn debug_scopes(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_scopes(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
|
||||
host.debugger.scopes(session, frame_id).await
|
||||
}
|
||||
|
||||
pub async fn debug_variables(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
reference: i64,
|
||||
) -> IdeResult<Vec<Variable>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_variables(host: &Host, 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,
|
||||
@@ -317,40 +312,38 @@ pub async fn debug_evaluate(
|
||||
host.debugger.evaluate(session, frame_id, expression).await
|
||||
}
|
||||
|
||||
pub async fn debug_resume(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_resume(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
host.debugger.resume(session, thread_id).await
|
||||
}
|
||||
|
||||
pub async fn debug_pause(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_pause(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
host.debugger.pause(session, thread_id).await
|
||||
}
|
||||
|
||||
/// Types `text` into the session's program (a `runInTerminal` program).
|
||||
pub async fn debug_send_input(host: &Host, _window: &str, session: DebugSessionId, text: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String) -> IdeResult<()> {
|
||||
host.debugger.send_input(session, &text)
|
||||
}
|
||||
|
||||
pub async fn debug_hot_reload(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.hot_reload(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_hot_restart(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.hot_restart(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_step(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
kind: StepKind,
|
||||
) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_step(host: &Host, 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,
|
||||
@@ -360,14 +353,15 @@ pub async fn debug_run_to(
|
||||
host.debugger.run_to(session, thread_id, path, line, force).await
|
||||
}
|
||||
|
||||
pub async fn debug_stop(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn debug_stop(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.stop(session).await
|
||||
}
|
||||
|
||||
/// The adapter's completions for an expression being typed in the frame `frame_id`.
|
||||
/// Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_completions(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
frame_id: Option<i64>,
|
||||
text: String,
|
||||
@@ -378,9 +372,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,
|
||||
@@ -390,31 +384,34 @@ pub async fn debug_evaluate_in(
|
||||
}
|
||||
|
||||
/// Last known verification states of a file's breakpoints (refetch on `breakpointsChanged`).
|
||||
pub fn debug_breakpoint_states(host: &Host, _window: &str, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn debug_breakpoint_states(host: &Host, 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,
|
||||
@@ -426,28 +423,24 @@ pub async fn debug_set_variable(
|
||||
}
|
||||
|
||||
/// Force Step Over: step over with every breakpoint suspended until the step ends.
|
||||
pub async fn debug_force_step_over(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_force_step_over(host: &Host, 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,
|
||||
@@ -456,13 +449,15 @@ pub async fn debug_step_in_target(
|
||||
}
|
||||
|
||||
/// Reset Frame (Drop Frame).
|
||||
pub async fn debug_restart_frame(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_restart_frame(host: &Host, 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>,
|
||||
@@ -470,61 +465,65 @@ 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
|
||||
}
|
||||
|
||||
pub async fn debug_js_start_profile(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
/// Starts recording a debugged page's CPU profile.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_js_start_profile(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.js_start_profile(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_js_stop_profile(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
) -> IdeResult<ide_core::IpcPath> {
|
||||
/// 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> {
|
||||
host.debugger.js_stop_profile(session).await.map(Into::into)
|
||||
}
|
||||
|
||||
pub fn debug_capabilities(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn debug_capabilities(host: &Host, 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,
|
||||
@@ -534,20 +533,23 @@ pub async fn debug_data_breakpoint_info(
|
||||
}
|
||||
|
||||
/// Attach to Process: the user's processes a debugger can attach to.
|
||||
pub async fn debug_attachable_processes(_host: &Host, _window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn debug_attachable_processes() -> 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
|
||||
/// (`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).
|
||||
/// A loopback port that is free right now, for a debug agent the launch line starts.
|
||||
#[command(trust = trusted)]
|
||||
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)?;
|
||||
@@ -561,26 +563,29 @@ 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(
|
||||
host: &Host,
|
||||
ide: &Host,
|
||||
window: &str,
|
||||
request: ide_core::RequestId,
|
||||
jvm_host: String,
|
||||
host: String,
|
||||
port: u16,
|
||||
) -> IdeResult<u16> {
|
||||
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);
|
||||
ide.require_trust(window)?;
|
||||
let token = ide.begin_request(request);
|
||||
let result = jdwp::listen_for_jvm(&host, port, token).await;
|
||||
ide.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// HotSwap (Reload Changed Classes) in a java-debug session.
|
||||
pub async fn debug_redefine_classes(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<HotSwapResult> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_redefine_classes(host: &Host, session: DebugSessionId) -> IdeResult<HotSwapResult> {
|
||||
host.debugger.redefine_classes(session).await
|
||||
}
|
||||
|
||||
/// The debuggee JVM's loaded classes, or why they cannot be read.
|
||||
/// The debuggee JVM's loaded classes (instances and shallow bytes), or why they cannot be read.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_jvm_memory_classes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -591,6 +596,7 @@ 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,
|
||||
@@ -602,7 +608,8 @@ 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 listed by [`debug_jvm_memory_instances`].
|
||||
/// The fields (or array elements) of an instance in the stopped JVM.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_jvm_memory_fields(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -614,6 +621,7 @@ 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,
|
||||
@@ -625,166 +633,6 @@ 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::*;
|
||||
@@ -918,3 +766,49 @@ 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,
|
||||
);
|
||||
@@ -1,5 +1,6 @@
|
||||
//! Repository version lookups for manifest inspections and completion.
|
||||
use crate::{Host, rpc::Dispatcher};
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
|
||||
use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo, go, maven, npm};
|
||||
use std::collections::BTreeMap;
|
||||
@@ -193,7 +194,7 @@ fn go_source(project: &crate::Project, config_dir: &Path, path: &Path) -> IdeRes
|
||||
Ok(GoModules { root, env })
|
||||
}
|
||||
|
||||
/// `offset` limits a completion request to its version string; inspections omit it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn dependency_versions(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -201,6 +202,7 @@ 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();
|
||||
@@ -249,12 +251,6 @@ 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::*;
|
||||
@@ -361,3 +357,5 @@ mod tests {
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(dependencies: dependency_versions);
|
||||
@@ -1,4 +1,5 @@
|
||||
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};
|
||||
@@ -31,212 +32,204 @@ fn local(paths: Vec<IpcPath>) -> Vec<PathBuf> {
|
||||
paths.into_iter().map(|p| p.to_path_buf()).collect()
|
||||
}
|
||||
|
||||
/// 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)?;
|
||||
#[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)?;
|
||||
Ok(ide_remote::coverage(&project.settings.effective(), &project.root, &local(paths)))
|
||||
}
|
||||
|
||||
/// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_upload(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
paths: Vec<IpcPath>,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// 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 (mut report, done) = progress(project.sink.clone(), "Uploading", token.clone());
|
||||
let r = state
|
||||
let r = host
|
||||
.remote
|
||||
.upload(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
|
||||
.await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// Download from…: the remote counterparts of files and folders.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_download(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
paths: Vec<IpcPath>,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// Download from…: the remote counterparts of files and folders.
|
||||
let project = host.project(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
|
||||
let r = state
|
||||
let r = host
|
||||
.remote
|
||||
.download(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
|
||||
.await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// Deletes the remote counterparts of files and folders.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_delete_remote(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
paths: Vec<IpcPath>,
|
||||
server: Option<String>,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
state.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
|
||||
// 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
|
||||
}
|
||||
|
||||
/// Sync with Deployed: local and remote files under `path`, side by side.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_compare(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
path: IpcPath,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<SyncEntry>> {
|
||||
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);
|
||||
// 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);
|
||||
r
|
||||
}
|
||||
|
||||
/// Applies the Sync with Deployed choices.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_sync(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
steps: Vec<SyncStep>,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// Applies the Sync with Deployed choices.
|
||||
let project = host.project(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let (mut report, done) = progress(project.sink.clone(), "Synchronizing", token.clone());
|
||||
let r = state
|
||||
let r = host
|
||||
.remote
|
||||
.sync(&project.settings.effective(), &project.root, server.as_deref(), &steps, token, &mut report)
|
||||
.await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// Where `path` is deployed (remote path, web URL); `None` when not mapped.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_info(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
path: IpcPath,
|
||||
server: Option<String>,
|
||||
) -> IdeResult<Option<DeployedPath>> {
|
||||
let project = state.project(window)?;
|
||||
state.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
|
||||
// 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
|
||||
}
|
||||
|
||||
/// 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 = 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
|
||||
}
|
||||
|
||||
/// 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_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
|
||||
}
|
||||
|
||||
/// 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 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())
|
||||
}
|
||||
|
||||
/// 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 = 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)
|
||||
}
|
||||
|
||||
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_delete(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
|
||||
host.remote.remote_delete(&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_mkdir(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
|
||||
host.remote.remote_mkdir(&connection, &path).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)]
|
||||
pub async fn remote_rename(host: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
|
||||
host.remote.remote_rename(&connection, &from, &to).await
|
||||
}
|
||||
|
||||
/// Remote Host › Download to…: remote files and folders into a local folder, each under its
|
||||
/// own name.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn remote_download_into(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
connection: FsConnection,
|
||||
paths: Vec<String>,
|
||||
target: IpcPath,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// 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 (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
|
||||
let r = state.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
|
||||
let r = host.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// `password`: an FTP password typed in the settings but not applied yet.
|
||||
#[command(trust = always)]
|
||||
pub async fn deploy_test_connection(
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
connection: FsConnection,
|
||||
path: String,
|
||||
password: Option<String>,
|
||||
) -> IdeResult<()> {
|
||||
state.remote.test_connection_with(&connection, &path, password).await
|
||||
// `password`: an FTP password typed in the settings but not applied yet.
|
||||
host.remote.test_connection_with(&connection, &path, password).await
|
||||
}
|
||||
|
||||
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
|
||||
});
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -1,9 +1,13 @@
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{ChangeSet, DocId, IdeResult};
|
||||
use ide_workspace::DocumentInfo;
|
||||
use std::path::PathBuf;
|
||||
|
||||
pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
|
||||
/// 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> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let info = project.documents.open(&path)?;
|
||||
@@ -16,22 +20,30 @@ pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<Documen
|
||||
.await
|
||||
}
|
||||
|
||||
pub fn close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.project(window)?.documents.close(doc);
|
||||
Ok(())
|
||||
#[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
|
||||
}
|
||||
|
||||
/// Opens an editable untitled buffer (a new-file tab); it reaches the disk
|
||||
/// 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> {
|
||||
/// 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.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.open_untitled(name.as_deref())).await
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
/// 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.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let info = project.documents.save_as(doc, &path)?;
|
||||
@@ -43,25 +55,31 @@ pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> Id
|
||||
.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)
|
||||
/// 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
|
||||
}
|
||||
|
||||
pub async fn save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_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
|
||||
}
|
||||
|
||||
pub async fn save_all(host: &Host, window: &str) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_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
|
||||
}
|
||||
|
||||
/// Recovers external changes missed by the project's file watchers.
|
||||
pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
|
||||
#[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.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
if project.settings.effective().files.sync_on_focus {
|
||||
@@ -72,13 +90,27 @@ pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.snapshot(doc)).await
|
||||
}
|
||||
|
||||
mod commands;
|
||||
pub 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,
|
||||
);
|
||||
@@ -1,7 +1,5 @@
|
||||
#[allow(unused_imports)]
|
||||
use super::*;
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
|
||||
use ide_language::{FoldRange, SyntaxHighlights};
|
||||
use ide_text::LineEnding;
|
||||
@@ -16,6 +14,7 @@ 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?;
|
||||
@@ -35,6 +34,7 @@ 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,8 +46,7 @@ pub async fn doc_language(
|
||||
}
|
||||
|
||||
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
|
||||
/// 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.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_set_encoding(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -55,6 +54,8 @@ 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)?
|
||||
@@ -70,20 +71,24 @@ pub async fn doc_set_encoding(
|
||||
host.blocking(move || project.documents.set_encoding(doc, &encoding, reload)).await
|
||||
}
|
||||
|
||||
/// Adds or removes the BOM on a UTF-8 document; the change is written on save.
|
||||
#[command(trust = always)]
|
||||
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
|
||||
}
|
||||
|
||||
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)
|
||||
#[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
|
||||
}
|
||||
|
||||
/// 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();
|
||||
@@ -122,6 +127,7 @@ 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 || {
|
||||
@@ -156,6 +162,7 @@ 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 || {
|
||||
@@ -168,9 +175,10 @@ pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// Python class facts for the inheritance inspections: tree-sitter, no language server.
|
||||
#[command(trust = always)]
|
||||
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)?;
|
||||
@@ -179,6 +187,7 @@ 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 || {
|
||||
@@ -204,35 +213,30 @@ pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset:
|
||||
.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_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_content(host: &Host, window: &str, id: String) -> IdeResult<String> {
|
||||
host.project(window)?.history.content(&id)
|
||||
#[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
|
||||
}
|
||||
|
||||
/// 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")?) });
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -46,11 +46,11 @@ impl Fixture {
|
||||
}
|
||||
|
||||
async fn open(&self, path: &Path) -> DocumentInfo {
|
||||
open(&self.host, "main", path.to_path_buf()).await.unwrap()
|
||||
doc_open(&self.host, "main", path.to_path_buf()).await.unwrap()
|
||||
}
|
||||
|
||||
async fn sync(&self) {
|
||||
sync_from_disk(&self.host, "main").await.unwrap();
|
||||
doc_sync_from_disk(&self.host, "main").await.unwrap();
|
||||
}
|
||||
|
||||
fn document_events(&self) -> Vec<IdeEvent> {
|
||||
@@ -95,13 +95,14 @@ 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;
|
||||
edit(
|
||||
doc_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();
|
||||
@@ -196,7 +197,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 = open(&f.host, "other", f.outside.clone()).await.unwrap();
|
||||
let other_doc = 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");
|
||||
|
||||
@@ -1,17 +1,56 @@
|
||||
//! Docker run configurations: the environment their `docker` command line runs with.
|
||||
//! 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.
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_core::IdeResult;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use ide_docker::DockerEndpoint;
|
||||
use std::collections::BTreeMap;
|
||||
use ide_ssh::Tunnel;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// 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>> {
|
||||
/// 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.
|
||||
endpoint.validate()?;
|
||||
let endpoint = resolve(host, endpoint).await?;
|
||||
host.blocking(move || Ok(ide_docker::run_env(&endpoint))).await
|
||||
}
|
||||
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("docker_run_env", |c| async move { run_env(&c.host, c.arg("endpoint")?).await });
|
||||
}
|
||||
ide_command::domain!(docker: docker_run_env);
|
||||
@@ -2,19 +2,20 @@
|
||||
//! (and, on the remote server, the project's `remoteEnv`) without a restart.
|
||||
use crate::Host;
|
||||
use crate::environment::EnvReloaded;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::IdeResult;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// 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> {
|
||||
/// 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.
|
||||
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
|
||||
}
|
||||
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("env_reload", |c| async move { reload(&c.host, &c.window).await });
|
||||
}
|
||||
ide_command::domain!(env: env_reload);
|
||||
@@ -1,10 +1,12 @@
|
||||
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};
|
||||
|
||||
pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_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 })
|
||||
@@ -12,7 +14,8 @@ pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryK
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn compare_directories(
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_compare_directories(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
left: PathBuf,
|
||||
@@ -38,7 +41,8 @@ pub async fn compare_directories(
|
||||
result
|
||||
}
|
||||
|
||||
pub async fn copy_merge(
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_copy_merge(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
source_root: PathBuf,
|
||||
@@ -73,8 +77,9 @@ pub async fn copy_merge(
|
||||
/// Files of a deleted folder snapshotted in Local History.
|
||||
const DELETE_SNAPSHOT_LIMIT: usize = 2000;
|
||||
|
||||
/// 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>> {
|
||||
#[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.
|
||||
let project = host.project(window);
|
||||
host.blocking(move || {
|
||||
let excludes = project
|
||||
@@ -99,7 +104,8 @@ pub async fn read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec
|
||||
|
||||
/// Creates an empty file; inside a project, honours the EditorConfig
|
||||
/// `charset` (writes the BOM for `utf-8-bom` / UTF-16).
|
||||
pub fn create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn fs_create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
match host.project(window) {
|
||||
Ok(p) => {
|
||||
let defaults = p.documents.file_defaults();
|
||||
@@ -124,7 +130,8 @@ pub fn create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn create_file_bytes(host: &Host, window: &str, path: PathBuf, data: Vec<u8>) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_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)?;
|
||||
@@ -138,17 +145,25 @@ pub async fn create_file_bytes(host: &Host, window: &str, path: PathBuf, data: V
|
||||
.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.
|
||||
pub fn set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) -> IdeResult<bool> {
|
||||
#[command(trust = always)]
|
||||
pub fn fs_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),
|
||||
}
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
/// 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.
|
||||
let project = host.project(window).ok();
|
||||
let history = project.as_ref().map(|p| p.history.clone());
|
||||
host.blocking(move || {
|
||||
@@ -168,7 +183,8 @@ pub async fn delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_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)?;
|
||||
@@ -183,7 +199,8 @@ pub async fn copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeR
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_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)?;
|
||||
@@ -199,8 +216,10 @@ pub async fn rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> Id
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
/// 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> {
|
||||
let project = host.project(window).ok();
|
||||
host.blocking(move || match project {
|
||||
Some(p) => p.text_of(&path),
|
||||
@@ -251,3 +270,19 @@ 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,
|
||||
);
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
use crate::Host;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
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 into a new snapshot directory and analyzes the dump there; cancel with
|
||||
/// `request`. Anything but `Ready` leaves no directory behind.
|
||||
/// Dumps the session's JVM and analyzes the dump; cancel with `request`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_heap_capture(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -64,6 +64,7 @@ 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);
|
||||
@@ -119,8 +120,8 @@ async fn capture(
|
||||
})
|
||||
}
|
||||
|
||||
/// Analyzes the `.hprof` at `path` into a new snapshot directory; the file itself is never
|
||||
/// changed or deleted. Cancel with `request`.
|
||||
/// Analyzes an `.hprof` file; cancel with `request`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_heap_open(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -128,6 +129,7 @@ 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);
|
||||
@@ -297,14 +299,14 @@ fn reporter<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
/// The class table of a snapshot.
|
||||
#[command(trust = trusted)]
|
||||
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; see [`ide_heap::HeapIndex::dominated`] for what `parent` and
|
||||
/// `class_index` select.
|
||||
/// A page of the dominator tree: under `parent`, of type `classIndex`, or both.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_heap_dominators(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -314,11 +316,13 @@ 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; `None` when it is unreachable.
|
||||
/// The shortest path from `object` to a GC root; `null` when it is unreachable.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_heap_path(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -329,27 +333,30 @@ pub async fn debug_heap_path(
|
||||
host.blocking(move || Ok(snapshot.index().path_to_root(object))).await
|
||||
}
|
||||
|
||||
/// Class-by-class differences from `base` to `current`.
|
||||
#[command(trust = trusted)]
|
||||
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 (the UI has asked).
|
||||
/// Copies the snapshot's dump to `path`, replacing a file there.
|
||||
#[command(trust = trusted)]
|
||||
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
|
||||
}
|
||||
|
||||
/// Forgets the snapshot and deletes its directory once no query is using it.
|
||||
#[command(trust = trusted)]
|
||||
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
|
||||
}
|
||||
@@ -483,38 +490,17 @@ 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,
|
||||
);
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Local History beyond single files: folders, labels, restoring deleted files.
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use ide_core::IdeResult;
|
||||
use ide_workspace::DirectoryHistory;
|
||||
@@ -9,12 +9,14 @@ 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)
|
||||
@@ -22,6 +24,7 @@ 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 || {
|
||||
@@ -44,12 +47,4 @@ pub async fn history_restore(host: &Host, window: &str, path: PathBuf, id: Strin
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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 },
|
||||
);
|
||||
}
|
||||
ide_command::domain!(history: history_list_dir, history_put_label, history_restore);
|
||||
@@ -2,7 +2,7 @@
|
||||
pub(crate) mod cache;
|
||||
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
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 the workspace (when `build`), then resolves the runtime (or test)
|
||||
/// Builds according to `policy`, 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.
|
||||
/// Resources a Gradle build filters or renames are processed by Gradle, replacing the language server's plain copies.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn java_resolve_launch(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -25,6 +25,8 @@ 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;
|
||||
@@ -373,6 +375,7 @@ 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)?;
|
||||
@@ -381,6 +384,7 @@ 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,
|
||||
@@ -399,18 +403,6 @@ 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 {
|
||||
@@ -678,3 +670,5 @@ mod tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(java: java_build_workspace, java_debug_server, java_resolve_launch);
|
||||
@@ -1,5 +1,6 @@
|
||||
//! 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};
|
||||
@@ -59,6 +60,7 @@ fn read_presentation(
|
||||
Ok(presentation)
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn jvm_file_presentations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -132,3 +134,5 @@ mod tests {
|
||||
assert_eq!(presentation.kind, Some(ide_syntax::JvmTypeKind::Class));
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(jvm_icons: jvm_file_presentations);
|
||||
@@ -1,8 +1,7 @@
|
||||
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 crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{DocId, IdeError, IdeResult, Location, Pos, Range, RequestId, ServerId, TextEdit, WorkspaceEdit};
|
||||
use ide_lsp::types::*;
|
||||
@@ -60,6 +59,7 @@ async fn prepare_actions(
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_completion(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -224,6 +224,7 @@ 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,
|
||||
@@ -256,6 +257,7 @@ pub async fn lsp_inline_completion(
|
||||
}
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_resolve_completion(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -265,6 +267,7 @@ 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,
|
||||
@@ -294,6 +297,7 @@ 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;
|
||||
@@ -313,6 +317,7 @@ 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
|
||||
@@ -459,7 +464,8 @@ fn without_generated_helpers(locations: Vec<Location>) -> Vec<Location> {
|
||||
locations.into_iter().filter(|l| !generated(l)).collect()
|
||||
}
|
||||
|
||||
/// Gutter markers from plugins (`line-markers` providers) for `doc`.
|
||||
/// Gutter markers of plugin `line-markers` providers for an open document.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn plugin_line_markers(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -484,6 +490,7 @@ 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,
|
||||
@@ -553,6 +560,7 @@ 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,
|
||||
@@ -568,9 +576,10 @@ pub async fn lsp_implementation_locations(
|
||||
result
|
||||
}
|
||||
|
||||
/// 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)`.
|
||||
/// 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)]
|
||||
pub async fn lsp_goto_implementation(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -579,6 +588,7 @@ 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
|
||||
@@ -596,6 +606,7 @@ 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;
|
||||
@@ -603,8 +614,9 @@ pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> Ide
|
||||
host.project(window)?.lsp.virtual_document(&uri).await
|
||||
}
|
||||
|
||||
/// Whether this class belongs to the project's Maven local repository.
|
||||
#[command(trust = trusted)]
|
||||
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);
|
||||
@@ -620,7 +632,7 @@ pub async fn lsp_can_download_sources(host: &Host, window: &str, uri: String) ->
|
||||
.await
|
||||
}
|
||||
|
||||
/// Download with the project's Maven configuration, or attach an archive selected by the user.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_library_sources(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -629,6 +641,7 @@ 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);
|
||||
@@ -679,19 +692,21 @@ pub async fn lsp_library_sources(
|
||||
result
|
||||
}
|
||||
|
||||
/// Opens compiled classes through JDT, with project source taking priority on disk.
|
||||
#[command(trust = trusted)]
|
||||
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: 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
|
||||
/// 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
|
||||
/// 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,
|
||||
@@ -703,6 +718,7 @@ 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?;
|
||||
@@ -842,6 +858,7 @@ 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;
|
||||
@@ -852,6 +869,7 @@ 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,
|
||||
@@ -865,6 +883,7 @@ pub async fn lsp_workspace_symbols(
|
||||
result
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_code_actions(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1018,6 +1037,7 @@ 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,
|
||||
@@ -1038,7 +1058,8 @@ pub async fn lsp_code_action_query(
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/// Resolves a code action's edit without applying it.
|
||||
/// Resolves a code action's edit without applying it (intention preview).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_resolve_code_action(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1056,6 +1077,7 @@ 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() {
|
||||
@@ -1072,7 +1094,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 || apply_edit(&documents, &edit)).await?;
|
||||
blocking(move || documents.apply_workspace_edit(&edit)).await?;
|
||||
}
|
||||
open_plugin_action_target(&action, window);
|
||||
if let Some(command) = &action.command
|
||||
@@ -1122,6 +1144,7 @@ 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)?;
|
||||
@@ -1140,8 +1163,8 @@ pub async fn lsp_prepare_rename(host: &Host, window: &str, doc: DocId, pos: Pos)
|
||||
host.project(window)?.lsp.prepare_rename(doc, pos).await
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// The class at `pos` and the members Pull Members Up / Push Members Down can move.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_hierarchy_members(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1157,8 +1180,9 @@ pub async fn lsp_hierarchy_members(
|
||||
result
|
||||
}
|
||||
|
||||
/// Checks a class-hierarchy refactoring and computes its edit without applying it.
|
||||
/// Checks Pull Members Up / Push Members Down and computes the edit without applying it.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_hierarchy_refactor(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1191,7 +1215,7 @@ pub async fn lsp_hierarchy_refactor(
|
||||
.await
|
||||
}
|
||||
|
||||
/// The signature of the method at `pos`, for Change Signature.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_signature_info(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1199,6 +1223,7 @@ 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;
|
||||
@@ -1206,8 +1231,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,
|
||||
@@ -1218,6 +1243,7 @@ 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?;
|
||||
@@ -1248,8 +1274,7 @@ fn json_strings(values: Vec<serde_json::Value>) -> Vec<String> {
|
||||
values.iter().map(serde_json::Value::to_string).collect()
|
||||
}
|
||||
|
||||
/// 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.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_java_move_destinations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1258,6 +1283,8 @@ 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);
|
||||
@@ -1266,7 +1293,7 @@ pub async fn lsp_java_move_destinations(
|
||||
result.map(json_strings)
|
||||
}
|
||||
|
||||
/// The project's Java source types, for moving a member or type into a class.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_java_source_types(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1274,6 +1301,7 @@ 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;
|
||||
@@ -1281,8 +1309,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,
|
||||
@@ -1292,6 +1320,7 @@ 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);
|
||||
@@ -1307,7 +1336,7 @@ pub async fn lsp_java_move(
|
||||
.await
|
||||
}
|
||||
|
||||
/// The Java class to extract an interface from: its members and the packages for the interface.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_extract_interface_info(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1315,6 +1344,7 @@ 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;
|
||||
@@ -1322,9 +1352,8 @@ 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,
|
||||
@@ -1336,6 +1365,8 @@ 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);
|
||||
@@ -1351,6 +1382,8 @@ 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,
|
||||
@@ -1533,6 +1566,7 @@ fn merge_indexed_rename(
|
||||
renamed.edit.deduplicate();
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_format(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1543,6 +1577,7 @@ 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 {
|
||||
@@ -1562,6 +1597,7 @@ 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 {
|
||||
@@ -1581,6 +1617,7 @@ 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 {
|
||||
@@ -1600,6 +1637,7 @@ 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 {
|
||||
@@ -1630,6 +1668,7 @@ 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,
|
||||
@@ -1645,6 +1684,7 @@ pub async fn lsp_call_hierarchy(
|
||||
result
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_type_hierarchy(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1655,6 +1695,7 @@ 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,
|
||||
@@ -1664,15 +1705,27 @@ 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");
|
||||
@@ -1706,11 +1759,12 @@ 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);
|
||||
apply_edit(&project.documents, &edit)
|
||||
project.documents.apply_workspace_edit(&edit)
|
||||
})
|
||||
.await
|
||||
}
|
||||
@@ -1741,6 +1795,7 @@ 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 || {
|
||||
@@ -1750,11 +1805,13 @@ 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
|
||||
@@ -1762,6 +1819,7 @@ 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) =
|
||||
@@ -1832,7 +1890,7 @@ async fn run_plugin_server_command(
|
||||
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
|
||||
}
|
||||
|
||||
/// Resolves an interactive command without applying edits or executing it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_resolve_command(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1842,6 +1900,7 @@ 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;
|
||||
@@ -1849,7 +1908,7 @@ pub async fn lsp_resolve_command(
|
||||
result
|
||||
}
|
||||
|
||||
/// Applies an explicitly invoked action after the interactive answers have been validated.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_execute_code_action(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1858,6 +1917,7 @@ 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 {
|
||||
@@ -1869,7 +1929,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 || apply_edit(&documents, &edit))
|
||||
tokio::task::spawn_blocking(move || documents.apply_workspace_edit(&edit))
|
||||
.await
|
||||
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
|
||||
}
|
||||
@@ -1905,6 +1965,7 @@ 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)?;
|
||||
@@ -1941,6 +2002,7 @@ 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,
|
||||
@@ -1965,234 +2027,9 @@ pub async fn plugin_color_presentations(
|
||||
})
|
||||
.await
|
||||
}
|
||||
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
|
||||
});
|
||||
#[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())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -2915,3 +2752,61 @@ 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,
|
||||
);
|
||||
@@ -32,7 +32,7 @@ pub mod scaffold;
|
||||
pub mod sdk;
|
||||
pub mod search;
|
||||
pub mod spell;
|
||||
mod ssh;
|
||||
pub mod ssh;
|
||||
pub mod stream_trace;
|
||||
pub mod syntax;
|
||||
pub mod term;
|
||||
@@ -69,38 +69,54 @@ impl<T> Clone for Channel<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// 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);
|
||||
}
|
||||
// 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,
|
||||
);
|
||||
|
||||
impl Host {
|
||||
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use super::doc::blocking;
|
||||
use crate::Host;
|
||||
use crate::Project;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{DocId, IdeResult, IpcPath, LanguageId, Location, Pos};
|
||||
use ide_index::{ExtensionCount, FileMatch, IndexStatus, SymbolFilter, SymbolMatch};
|
||||
use ide_language::{FileReference, WebReference};
|
||||
@@ -45,30 +45,37 @@ 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())
|
||||
}
|
||||
|
||||
/// The project's file extensions, most common first.
|
||||
#[command(trust = always)]
|
||||
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,
|
||||
@@ -80,35 +87,40 @@ 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),
|
||||
/// at most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
|
||||
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder).
|
||||
#[command(trust = always)]
|
||||
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();
|
||||
@@ -145,12 +157,14 @@ pub async fn web_goto(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeRes
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// 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)]
|
||||
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();
|
||||
@@ -182,17 +196,19 @@ pub async fn nav_resolve_module(host: &Host, window: &str, name: String, from: I
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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()`).
|
||||
/// Index definitions named `name` within the roots `from` may navigate into (its own root
|
||||
/// plus its configured dependencies).
|
||||
#[command(trust = always)]
|
||||
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);
|
||||
@@ -207,11 +223,12 @@ pub async fn nav_index_definitions(
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// Every Python class in the project (attached dependency roots included) and its base names,
|
||||
/// for native inheritance gutter markers.
|
||||
#[command(trust = always)]
|
||||
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 || {
|
||||
@@ -284,6 +301,7 @@ 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,
|
||||
@@ -300,6 +318,7 @@ 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,
|
||||
@@ -316,6 +335,7 @@ 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();
|
||||
@@ -338,37 +358,23 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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
|
||||
});
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -2,12 +2,13 @@
|
||||
use crate::Host;
|
||||
pub use crate::notebook::NotebookOutputEvent;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult, RequestId};
|
||||
use ide_notebook::{NotebookEdit, NotebookSnapshot};
|
||||
use std::path::PathBuf;
|
||||
|
||||
pub async fn open(host: &Host, window: &str, path: String) -> IdeResult<NotebookSnapshot> {
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_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) };
|
||||
@@ -15,18 +16,21 @@ pub async fn open(host: &Host, window: &str, path: String) -> IdeResult<Notebook
|
||||
host.blocking(move || notebooks.open(&path)).await
|
||||
}
|
||||
|
||||
pub fn get(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
#[command(trust = always)]
|
||||
pub fn notebook_get(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
host.project(window)?.notebooks.get(&id)
|
||||
}
|
||||
|
||||
/// 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>> {
|
||||
#[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).
|
||||
let project = host.project(window)?;
|
||||
let path = project.notebooks.path_of(&id)?;
|
||||
Ok(project.lsp.notebook_cells(&path))
|
||||
}
|
||||
|
||||
pub async fn edit(
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_edit(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
@@ -37,22 +41,26 @@ pub async fn edit(
|
||||
host.blocking(move || notebooks.edit(&id, version, edit)).await
|
||||
}
|
||||
|
||||
pub async fn save(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_save(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
let notebooks = host.project(window)?.notebooks.clone();
|
||||
host.blocking(move || notebooks.save(&id)).await
|
||||
}
|
||||
|
||||
pub async fn undo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_undo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
let notebooks = host.project(window)?.notebooks.clone();
|
||||
host.blocking(move || notebooks.undo(&id, false)).await
|
||||
}
|
||||
|
||||
pub async fn redo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_redo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
let notebooks = host.project(window)?.notebooks.clone();
|
||||
host.blocking(move || notebooks.undo(&id, true)).await
|
||||
}
|
||||
|
||||
pub async fn reload(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_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 })
|
||||
@@ -60,7 +68,8 @@ pub async fn reload(host: &Host, window: &str, id: String) -> IdeResult<Notebook
|
||||
.map_err(|error| IdeError::internal(error.to_string()))?
|
||||
}
|
||||
|
||||
pub async fn restart(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn notebook_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 })
|
||||
@@ -68,14 +77,16 @@ pub async fn restart(host: &Host, window: &str, id: String) -> IdeResult<Noteboo
|
||||
.map_err(|error| IdeError::internal(error.to_string()))?
|
||||
}
|
||||
|
||||
pub async fn close(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_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()))?
|
||||
}
|
||||
|
||||
pub async fn interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn notebook_interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
let notebooks = host.project(window)?.notebooks.clone();
|
||||
tokio::spawn(async move { notebooks.interrupt(&id).await })
|
||||
.await
|
||||
@@ -83,7 +94,8 @@ pub async fn interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn execute(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn notebook_execute(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
@@ -136,30 +148,18 @@ impl Drop for RequestGuard<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
});
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -1,10 +1,11 @@
|
||||
use crate::{Host, Project};
|
||||
use ide_core::IdeResult;
|
||||
use ide_command::command;
|
||||
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;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[derive(Serialize, Deserialize, Type)]
|
||||
@@ -53,20 +54,36 @@ pub async fn open(host: &Arc<Host>, window: &str, path: &Path) -> IdeResult<Arc<
|
||||
host.blocking(move || h.open_project(&window, &path)).await
|
||||
}
|
||||
|
||||
pub fn current(host: &Host, window: &str) -> Option<ProjectInfo> {
|
||||
#[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> {
|
||||
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.
|
||||
pub fn settings(host: &Host, window: &str) -> Settings {
|
||||
#[command(trust = always, desktop_body = sync)]
|
||||
pub fn settings_get(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 a settings file of this window still names, if any
|
||||
/// (`settings` reports its stand-in): the "provided by a plugin now" notice targets these.
|
||||
/// 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)]
|
||||
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()),
|
||||
@@ -74,10 +91,66 @@ pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn roots(host: &Host, window: &str) -> IdeResult<ide_workspace::ProjectRoots> {
|
||||
/// `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> {
|
||||
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)?
|
||||
@@ -175,7 +248,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(host, window), project_scope, roots_changed: None });
|
||||
return Ok(SettingsApplied { settings: settings_get(host, window), project_scope, roots_changed: None });
|
||||
};
|
||||
// One canonical spelling per linked POM, including a project outside the opened root.
|
||||
if project_scope
|
||||
@@ -238,6 +311,11 @@ pub fn set_settings(
|
||||
if is_proxy {
|
||||
host.apply_proxy();
|
||||
}
|
||||
if key == "agents" || key == "agents.mcpServers" || key.starts_with("agents.mcpServers.") {
|
||||
for project in affected() {
|
||||
project.agents.notify_mcp_servers_changed();
|
||||
}
|
||||
}
|
||||
// A new interpreter / toolchain / server executable restarts the language servers it affects.
|
||||
// So do inspections that are compiler options (`ide-sdk` `configure_java_compiler`).
|
||||
let code_style = key == "editor"
|
||||
@@ -285,3 +363,20 @@ 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,
|
||||
);
|
||||
@@ -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 crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use ide_core::{IdeResult, RequestId, WorkspaceEdit};
|
||||
use ide_lsp::types::FileRenameEdits;
|
||||
@@ -15,6 +15,7 @@ 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,
|
||||
@@ -35,6 +36,7 @@ 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,
|
||||
@@ -55,6 +57,7 @@ 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();
|
||||
@@ -64,12 +67,14 @@ 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,
|
||||
@@ -98,23 +103,11 @@ pub async fn refactor_file_move_text_edits(
|
||||
result
|
||||
}
|
||||
|
||||
/// 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
|
||||
});
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -1,11 +1,33 @@
|
||||
use super::Emit;
|
||||
use super::{Channel, 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)?;
|
||||
@@ -183,9 +205,16 @@ fn settings_only(
|
||||
})
|
||||
}
|
||||
|
||||
/// 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>> {
|
||||
/// 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>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
configs
|
||||
@@ -200,8 +229,15 @@ pub fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> Id
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 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>> {
|
||||
/// 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>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
configs
|
||||
@@ -221,17 +257,17 @@ pub fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> Ide
|
||||
.collect()
|
||||
}
|
||||
|
||||
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(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn run_start(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
config: RunConfig,
|
||||
on_output: Emit<OutputChunk>,
|
||||
on_output: Channel<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;
|
||||
@@ -486,8 +522,9 @@ fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathB
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops a run (interrupt, then kill after Settings › Run's termination timeout).
|
||||
pub fn stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn run_stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
|
||||
// Interrupt, then kill after Settings › Run's termination timeout.
|
||||
if let Some(plugins) = host.plugin_host() {
|
||||
plugins.run_operation_stopped(id);
|
||||
}
|
||||
@@ -503,8 +540,10 @@ pub fn stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
|
||||
host.processes.stop_with_grace(id, grace)
|
||||
}
|
||||
|
||||
/// 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<()> {
|
||||
#[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();
|
||||
host.mcp_agent_runs.user_input(id, data);
|
||||
if host.remote.runs.contains(id) {
|
||||
return host.remote.runs.write_stdin(id, data);
|
||||
@@ -512,27 +551,31 @@ pub fn stdin(host: &Host, id: RunId, data: &str) -> IdeResult<()> {
|
||||
host.processes.write_stdin(id, data)
|
||||
}
|
||||
|
||||
pub fn resize(host: &Host, id: RunId, cols: u16, rows: u16) -> IdeResult<()> {
|
||||
/// 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<()> {
|
||||
if host.remote.runs.contains(id) {
|
||||
return host.remote.runs.resize(id, cols, rows);
|
||||
}
|
||||
host.processes.resize(id, cols, rows)
|
||||
}
|
||||
|
||||
pub fn close_stdin(host: &Host, id: RunId) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn run_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)
|
||||
}
|
||||
|
||||
pub fn list(host: &Host) -> Vec<RunInfo> {
|
||||
#[command(trust = always)]
|
||||
pub fn run_list(host: &Host) -> Vec<RunInfo> {
|
||||
let mut runs = host.processes.list();
|
||||
runs.extend(host.remote.runs.list());
|
||||
runs
|
||||
}
|
||||
|
||||
mod commands;
|
||||
pub mod commands;
|
||||
pub(crate) mod container;
|
||||
pub use commands::*;
|
||||
|
||||
@@ -563,3 +606,17 @@ 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,
|
||||
);
|
||||
@@ -1,11 +1,10 @@
|
||||
#[allow(unused_imports)]
|
||||
use super::*;
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
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")
|
||||
@@ -30,6 +29,7 @@ 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,6 +74,7 @@ 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,
|
||||
@@ -96,54 +97,61 @@ pub async fn run_application_publish(
|
||||
}
|
||||
|
||||
/// Configuration templates: per-type defaults applied to new configurations.
|
||||
pub fn run_templates(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn run_templates(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
|
||||
let root = host.project(window)?.root.clone();
|
||||
ide_run::load_templates(&root)
|
||||
crate::ops::doc::blocking(move || ide_run::load_templates(&root)).await
|
||||
}
|
||||
|
||||
pub fn run_save_templates(host: &Host, window: &str, templates: Vec<RunConfig>) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn run_save_templates(host: &Host, window: &str, templates: Vec<RunConfig>) -> IdeResult<()> {
|
||||
let root = host.project(window)?.root.clone();
|
||||
ide_run::save_templates(&root, &templates)
|
||||
crate::ops::doc::blocking(move || ide_run::save_templates(&root, &templates)).await
|
||||
}
|
||||
|
||||
/// Project files run configurations can be imported from (`.vscode/launch.json`).
|
||||
pub fn run_import_sources(host: &Host, window: &str) -> IdeResult<Vec<RunImportSource>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn run_import_sources(host: &Host, window: &str) -> IdeResult<Vec<RunImportSource>> {
|
||||
let root = host.project(window)?.root.clone();
|
||||
Ok(ide_run::import::available(&root))
|
||||
crate::ops::doc::blocking(move || Ok(ide_run::import::available(&root))).await
|
||||
}
|
||||
|
||||
/// Configurations read from `source`, not saved; names already in `existing` (the
|
||||
/// configurations being edited) are skipped.
|
||||
pub fn run_import_configs(
|
||||
/// Configurations read from `source`, not saved; names already in `existing` are skipped.
|
||||
#[command(trust = trusted)]
|
||||
pub async 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();
|
||||
ide_run::import_configs(&root, source, &existing)
|
||||
crate::ops::doc::blocking(move || ide_run::import_configs(&root, source, &existing)).await
|
||||
}
|
||||
|
||||
/// The environment runs inherit when "Include system environment variables" is on.
|
||||
pub fn run_system_env(_host: &Host, _window: &str) -> std::collections::BTreeMap<String, String> {
|
||||
#[command(trust = always)]
|
||||
pub fn run_system_env() -> std::collections::BTreeMap<String, String> {
|
||||
ide_run::system_env()
|
||||
}
|
||||
|
||||
/// 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}")))
|
||||
/// 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
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
/// 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`.
|
||||
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())
|
||||
@@ -153,9 +161,10 @@ pub async fn run_gradle_jvm_args_script(_host: &Host, _window: &str, jvm_args: V
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
/// 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`.
|
||||
if name.is_empty() || !name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') {
|
||||
return Err(IdeError::invalid(format!("invalid init script name {name:?}")));
|
||||
}
|
||||
@@ -170,6 +179,7 @@ pub async fn run_gradle_init_script(_host: &Host, _window: &str, name: String, t
|
||||
|
||||
/// 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,
|
||||
@@ -184,6 +194,7 @@ 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();
|
||||
@@ -192,6 +203,7 @@ 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,
|
||||
@@ -268,6 +280,7 @@ 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)?;
|
||||
@@ -287,6 +300,7 @@ 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") {
|
||||
@@ -355,6 +369,7 @@ 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)?;
|
||||
@@ -366,8 +381,7 @@ pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mod
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// 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.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn run_tomcat_sync(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -376,6 +390,8 @@ 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) {
|
||||
@@ -395,50 +411,24 @@ pub async fn run_tomcat_sync(
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// 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
|
||||
});
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -1,7 +1,8 @@
|
||||
//! File › New Project (`ide-scaffold`).
|
||||
//! 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.
|
||||
use crate::Host;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
|
||||
use ide_scaffold::{CreateRequest, Field, GeneratorInfo, Requirement, ScaffoldEvent, Values};
|
||||
@@ -11,20 +12,21 @@ fn join_err(e: impl std::fmt::Display) -> IdeError {
|
||||
}
|
||||
|
||||
/// The project generators File › New Project offers, in list order.
|
||||
pub fn scaffold_catalog(_host: &Host, _window: &str) -> Vec<GeneratorInfo> {
|
||||
#[command(trust = always)]
|
||||
pub fn scaffold_catalog() -> Vec<GeneratorInfo> {
|
||||
ide_scaffold::catalog()
|
||||
}
|
||||
|
||||
/// The fields a generator's project service adds for `values` (Spring Initializr's
|
||||
/// Boot versions and dependencies…); empty for other generators. Cancellable with
|
||||
/// The fields a generator's project service adds for `values`; 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
|
||||
@@ -34,25 +36,21 @@ pub async fn scaffold_options(
|
||||
}
|
||||
|
||||
/// The programs a generator needs for `values`, and whether they are installed.
|
||||
pub async fn scaffold_requirements(
|
||||
_host: &Host,
|
||||
_window: &str,
|
||||
generator: String,
|
||||
values: Values,
|
||||
) -> IdeResult<Vec<Requirement>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn scaffold_requirements(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 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.
|
||||
/// 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)]
|
||||
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| {
|
||||
@@ -67,16 +65,10 @@ pub async fn scaffold_create(
|
||||
Ok(dir.into())
|
||||
}
|
||||
|
||||
/// 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
|
||||
});
|
||||
}
|
||||
ide_command::domain!(
|
||||
scaffold:
|
||||
scaffold_catalog,
|
||||
scaffold_create,
|
||||
scaffold_options,
|
||||
scaffold_requirements,
|
||||
);
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Interpreters / toolchains (`ide-sdk`): discovery, Python virtualenvs and packages.
|
||||
use crate::Host;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
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(crate) mod container_python;
|
||||
pub 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,6 +34,7 @@ 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();
|
||||
@@ -61,9 +62,10 @@ pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<V
|
||||
.map_err(join_err)
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// The Python interpreters of the recently opened projects, each with its project.
|
||||
#[command(trust = trusted)]
|
||||
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();
|
||||
@@ -109,6 +111,7 @@ 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());
|
||||
@@ -118,6 +121,7 @@ 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)?;
|
||||
@@ -143,6 +147,7 @@ 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)?;
|
||||
@@ -152,6 +157,7 @@ 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,
|
||||
@@ -177,6 +183,8 @@ 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());
|
||||
@@ -207,12 +215,14 @@ pub struct ComposerInstallState {
|
||||
pub reason: ide_sdk::php::ComposerInstall,
|
||||
}
|
||||
|
||||
/// `None` in an untrusted project too: `composer install` runs the project's scripts.
|
||||
/// The Composer project `path` belongs to, when its dependencies need `composer install`.
|
||||
#[command(trust = trusted)]
|
||||
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);
|
||||
@@ -228,6 +238,7 @@ 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,
|
||||
@@ -292,6 +303,7 @@ 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,
|
||||
@@ -308,6 +320,7 @@ 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,
|
||||
@@ -330,6 +343,7 @@ pub async fn sdk_python_create_venv(
|
||||
result?
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_packages(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -346,6 +360,7 @@ 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,
|
||||
@@ -375,9 +390,10 @@ pub async fn sdk_python_pip(
|
||||
result?
|
||||
}
|
||||
|
||||
/// 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…).
|
||||
/// The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home.
|
||||
#[command(trust = trusted)]
|
||||
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))
|
||||
})
|
||||
@@ -385,67 +401,6 @@ 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::*;
|
||||
@@ -560,3 +515,21 @@ 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,
|
||||
);
|
||||
@@ -7,6 +7,7 @@
|
||||
|
||||
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;
|
||||
@@ -100,7 +101,8 @@ 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 run target's, with its snapshot.
|
||||
/// The project interpreter when it is a Docker or Compose run target's, with its snapshot.
|
||||
#[command(trust = trusted)]
|
||||
pub fn sdk_container_python(host: &Host, window: &str) -> IdeResult<Option<ContainerPython>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
@@ -129,9 +131,10 @@ fn describe(host: &Host, root: &Path, settings: &Settings) -> Option<ContainerPy
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// Copies the container's Python libraries again (after the image changed).
|
||||
#[command(trust = trusted)]
|
||||
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?;
|
||||
@@ -296,3 +299,5 @@ 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);
|
||||
@@ -1,5 +1,6 @@
|
||||
use super::Emit;
|
||||
use super::Channel;
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeResult, RequestId};
|
||||
use ide_search::{FileMatches, ProjectFileSet, SearchQuery, SearchSummary};
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -23,12 +24,13 @@ 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)`.
|
||||
pub async fn start(
|
||||
#[command(trust = always)]
|
||||
pub async fn search_start(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
mut query: SearchQuery,
|
||||
on_event: Emit<SearchEvent>,
|
||||
on_event: Channel<SearchEvent>,
|
||||
) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
// Excluded roots (Project Structure marks and detected `target`, `node_modules`, …) and
|
||||
@@ -39,11 +41,13 @@ pub async fn start(
|
||||
let syntax = host.syntax();
|
||||
let summary = host
|
||||
.blocking(move || {
|
||||
search_project(&project, &syntax, &query, &cancel, &|file| events(SearchEvent::File { file }))
|
||||
search_project(&project, &syntax, &query, &cancel, &|file| {
|
||||
let _ = events.send(SearchEvent::File { file });
|
||||
})
|
||||
})
|
||||
.await;
|
||||
host.end_request(request);
|
||||
on_event(SearchEvent::Done { summary: summary? });
|
||||
let _ = on_event.send(SearchEvent::Done { summary: summary? });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -173,5 +177,7 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
mod commands;
|
||||
pub mod commands;
|
||||
pub use commands::*;
|
||||
|
||||
ide_command::domain!(search: search_start);
|
||||
@@ -1,8 +1,6 @@
|
||||
#[allow(unused_imports)]
|
||||
use super::*;
|
||||
use crate::Host;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeResult, Pos, RequestId, TextEdit};
|
||||
use ide_search::{ReplaceEvent, ReplaceHost, ReplacePreview, ReplaceTarget, SearchQuery};
|
||||
use ide_workspace::Documents;
|
||||
@@ -51,6 +49,7 @@ 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,
|
||||
@@ -79,6 +78,7 @@ 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,36 +98,9 @@ pub async fn replace_preview(
|
||||
}
|
||||
|
||||
/// Validates a query (e.g. regex syntax) while the user types.
|
||||
pub fn search_validate(_host: &Host, _window: &str, query: SearchQuery) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn search_validate(query: SearchQuery) -> IdeResult<()> {
|
||||
ide_search::validate_query(&query)
|
||||
}
|
||||
|
||||
/// 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")?) });
|
||||
}
|
||||
ide_command::domain!(search_commands: replace_in_files, replace_preview, search_validate);
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Proofreading › Typo: spell checking of open documents.
|
||||
use crate::Host;
|
||||
use crate::Project;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use super::doc::blocking;
|
||||
use ide_core::settings::SpellingSettings;
|
||||
@@ -36,6 +36,7 @@ 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,
|
||||
@@ -65,6 +66,7 @@ pub async fn spell_check(
|
||||
end: r.end,
|
||||
kind: match r.kind {
|
||||
SpellingKind::Comment => RegionKind::Comment,
|
||||
SpellingKind::String if r.raw => RegionKind::RawString,
|
||||
SpellingKind::String => RegionKind::String,
|
||||
SpellingKind::Name => RegionKind::Name,
|
||||
},
|
||||
@@ -104,6 +106,7 @@ 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 || {
|
||||
@@ -113,10 +116,4 @@ pub async fn spell_suggest(host: &Host, window: &str, word: String) -> IdeResult
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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 });
|
||||
}
|
||||
ide_command::domain!(spell: spell_check, spell_suggest);
|
||||
@@ -2,28 +2,59 @@
|
||||
//! 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::rpc::Dispatcher;
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::IdeResult;
|
||||
use ide_core::remote_settings::SshConfiguration;
|
||||
|
||||
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(())
|
||||
});
|
||||
/// 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
|
||||
}
|
||||
|
||||
/// 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,
|
||||
);
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
use crate::Host;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
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, 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.
|
||||
/// The stream chains around `frame`'s line; `top`: it is the thread's top frame.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_stream_chains(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -111,17 +111,16 @@ 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())
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// Traces chain `chain_index` of [`debug_stream_chains`], whose `range` the UI showed, while the
|
||||
/// program runs it; cancelling `request` stops recording.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_stream_trace(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -133,6 +132,9 @@ 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 };
|
||||
@@ -195,12 +197,14 @@ async fn trace(
|
||||
})
|
||||
}
|
||||
|
||||
/// Ends the running trace's terminal operation (Abort Operation); `None` when no trace runs.
|
||||
/// Ends the running trace's terminal operation; `None` when no trace runs.
|
||||
#[command(trust = trusted)]
|
||||
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
|
||||
}
|
||||
@@ -379,6 +383,10 @@ fn ready(
|
||||
},
|
||||
};
|
||||
let mut linked = link_trace(plan, &recording, collected.skipped_breakpoints);
|
||||
// A stream made parallel before the chain's statement, which the bundle found so at run time.
|
||||
if collected.sequentialized && !plan.sequentialize {
|
||||
linked.banners.push(TraceBanner::Sequentialized);
|
||||
}
|
||||
if resumed_stops > 0 {
|
||||
linked.banners.push(TraceBanner::BreakpointsResumed { count: resumed_stops });
|
||||
}
|
||||
@@ -434,29 +442,12 @@ 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,
|
||||
);
|
||||
@@ -442,3 +442,20 @@ fn chain_info_steps_keep_modifiers() {
|
||||
let found = chains_at(service(), &snap, &frame(1), true, true, &CancellationToken::new()).unwrap();
|
||||
assert_eq!(found[0].info.steps, ["filter", "unordered", "map"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ready_says_a_stream_found_parallel_at_run_time_ran_sequentially() {
|
||||
let java = LanguageId::new("java");
|
||||
let snap = Snapshot::text(&java, SOURCE);
|
||||
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
|
||||
let Candidate { info, chain } = found.into_iter().next().unwrap();
|
||||
let chain = chain.unwrap();
|
||||
let plan = real_run_plan(&chain).unwrap();
|
||||
assert!(!plan.sequentialize);
|
||||
|
||||
let collected = TraceCollected { sequentialized: true, ..spike_collected() };
|
||||
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, collected, 9, 0) else {
|
||||
panic!("not ready");
|
||||
};
|
||||
assert!(banners.contains(&TraceBanner::Sequentialized), "{banners:?}");
|
||||
}
|
||||
@@ -8,7 +8,7 @@
|
||||
//! `unavailable`.
|
||||
use crate::Host;
|
||||
use crate::Project;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use super::doc::blocking;
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, LanguageId, Pos, Range, RequestId};
|
||||
@@ -46,11 +46,13 @@ 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,
|
||||
@@ -63,6 +65,7 @@ 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,
|
||||
@@ -74,6 +77,7 @@ 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,
|
||||
@@ -85,6 +89,7 @@ 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,
|
||||
@@ -96,6 +101,7 @@ 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,
|
||||
@@ -108,6 +114,7 @@ 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,
|
||||
@@ -137,6 +144,7 @@ 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,
|
||||
@@ -147,29 +155,14 @@ pub async fn syntax_structural_ranges(
|
||||
on_doc(host, window, doc, request, move |s, snap, c| s.structural_ranges(snap, pos, c)).await
|
||||
}
|
||||
|
||||
/// 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
|
||||
});
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -1,5 +1,6 @@
|
||||
use super::Emit;
|
||||
use super::{Channel, Emit};
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeResult, TerminalId};
|
||||
use ide_terminal::{TerminalInfo, TerminalOptions};
|
||||
|
||||
@@ -7,7 +8,8 @@ mod images;
|
||||
|
||||
const MAX_IMAGE_BYTES: usize = 20 * 1024 * 1024;
|
||||
|
||||
pub async fn store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime: String) -> IdeResult<String> {
|
||||
#[command(trust = always)]
|
||||
pub async fn term_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)"));
|
||||
}
|
||||
@@ -18,11 +20,14 @@ pub async fn store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime: Strin
|
||||
host.blocking(move || images::store(&data_dir, &data, &mime)).await
|
||||
}
|
||||
|
||||
pub fn spawn(
|
||||
/// 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(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
mut options: TerminalOptions,
|
||||
on_output: Emit<String>,
|
||||
on_output: Channel<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.
|
||||
@@ -41,7 +46,14 @@ pub fn 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| on_output(chunk)))?;
|
||||
let info = host.terminals.spawn(
|
||||
options,
|
||||
key,
|
||||
host.window_sink(window),
|
||||
Box::new(move |chunk| {
|
||||
let _ = on_output.send(chunk);
|
||||
}),
|
||||
)?;
|
||||
if let Some(line) = activation {
|
||||
let _ = host.terminals.write(info.id, &format!(" {line}\r"));
|
||||
}
|
||||
@@ -133,22 +145,40 @@ impl ide_terminal::TerminalChannel for SshTerminal {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn write(host: &Host, id: TerminalId, data: &str) -> IdeResult<()> {
|
||||
host.terminals.write(id, data)
|
||||
#[command(trust = always)]
|
||||
pub fn term_write(host: &Host, id: TerminalId, data: String) -> IdeResult<()> {
|
||||
host.terminals.write(id, &data)
|
||||
}
|
||||
|
||||
pub fn resize(host: &Host, id: TerminalId, cols: u16, rows: u16) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn term_resize(host: &Host, id: TerminalId, cols: u16, rows: u16) -> IdeResult<()> {
|
||||
host.terminals.resize(id, cols, rows)
|
||||
}
|
||||
|
||||
pub fn kill(host: &Host, id: TerminalId) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn term_kill(host: &Host, id: TerminalId) -> IdeResult<()> {
|
||||
host.terminals.kill(id)
|
||||
}
|
||||
|
||||
pub fn is_busy(host: &Host, id: TerminalId) -> IdeResult<bool> {
|
||||
/// 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> {
|
||||
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::*;
|
||||
@@ -171,11 +201,23 @@ mod tests {
|
||||
project_environment: false,
|
||||
});
|
||||
let id = TerminalId::next();
|
||||
let error = store_image(&host, id, vec![0; MAX_IMAGE_BYTES + 1], "image/png".into()).await.unwrap_err();
|
||||
let error = term_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 = store_image(&host, id, vec![0; MAX_IMAGE_BYTES], "image/png".into()).await.unwrap_err();
|
||||
let error = term_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,
|
||||
);
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Language server / debug adapter installer and JDK downloads (`ide-tools`).
|
||||
use crate::Host;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use ide_core::{IdeError, IdeResult, RequestId};
|
||||
use ide_sdk::Sdk;
|
||||
@@ -56,6 +56,7 @@ 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);
|
||||
@@ -64,6 +65,7 @@ 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,
|
||||
@@ -91,6 +93,7 @@ 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);
|
||||
@@ -100,6 +103,7 @@ 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);
|
||||
@@ -109,17 +113,14 @@ pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResu
|
||||
}
|
||||
|
||||
/// JDK distributions Download JDK offers.
|
||||
pub fn jdk_download_vendors(_host: &Host, _window: &str) -> Vec<JdkVendor> {
|
||||
#[command(trust = always)]
|
||||
pub fn jdk_download_vendors() -> Vec<JdkVendor> {
|
||||
ide_tools::jdk::vendors()
|
||||
}
|
||||
|
||||
/// Java versions `vendor` publishes; cancellable with `cancel_request(request)`.
|
||||
pub async fn jdk_download_releases(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
vendor: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<JdkReleases> {
|
||||
#[command(trust = always)]
|
||||
pub async fn jdk_download_releases(host: &Host, 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);
|
||||
@@ -128,7 +129,8 @@ pub async fn jdk_download_releases(
|
||||
}
|
||||
|
||||
/// Where Download JDK puts JDKs unless told otherwise.
|
||||
pub fn jdk_download_location(host: &Host, _window: &str) -> IdeResult<ide_core::IpcPath> {
|
||||
#[command(trust = always)]
|
||||
pub fn jdk_download_location(host: &Host) -> IdeResult<ide_core::IpcPath> {
|
||||
Ok(ide_tools::jdk::jdks_dir(&host.local_data_dir).into())
|
||||
}
|
||||
|
||||
@@ -136,10 +138,9 @@ pub fn jdk_download_location(host: &Host, _window: &str) -> IdeResult<ide_core::
|
||||
/// [`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.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
#[command(trust = always)]
|
||||
pub async fn jdk_download(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
vendor: String,
|
||||
version: u32,
|
||||
location: Option<PathBuf>,
|
||||
@@ -171,8 +172,8 @@ pub async fn jdk_download(
|
||||
Ok(sdk)
|
||||
}
|
||||
|
||||
/// The Java version the jdtls this window launches needs; `None` while it isn't
|
||||
/// installed or doesn't tell.
|
||||
/// The Java version the window's jdtls needs; `None` while it isn't installed or doesn't tell.
|
||||
#[command(trust = always)]
|
||||
pub async fn jdtls_required_java(host: &Host, window: &str) -> IdeResult<Option<u32>> {
|
||||
let settings = match host.project(window) {
|
||||
Ok(project) => project.settings.effective(),
|
||||
@@ -188,30 +189,15 @@ 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)
|
||||
}
|
||||
|
||||
/// 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
|
||||
});
|
||||
}
|
||||
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,
|
||||
);
|
||||
@@ -1,9 +1,11 @@
|
||||
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.
|
||||
pub async fn status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let settings = project.settings.effective();
|
||||
@@ -22,9 +24,10 @@ pub async fn status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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>> {
|
||||
/// 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.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let settings = project.settings.effective();
|
||||
@@ -43,7 +46,7 @@ pub async fn status_paths(host: &Host, window: &str, paths: Vec<std::path::PathB
|
||||
.await
|
||||
}
|
||||
|
||||
mod commands;
|
||||
pub mod commands;
|
||||
pub use commands::*;
|
||||
|
||||
/// Refuses (with `refusal`) to remove or move the worktree that holds the open project.
|
||||
@@ -84,3 +87,5 @@ 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
@@ -1,9 +1,10 @@
|
||||
//! 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).
|
||||
@@ -46,10 +47,12 @@ pub async fn serves_page(url: &str) -> bool {
|
||||
response.status().is_success() && html
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
/// 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.
|
||||
let root = host.project(window).ok().map(|p| p.root.clone());
|
||||
host.web.url_for(root.as_deref(), file).await
|
||||
host.web.url_for(root.as_deref(), &path).await
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -105,3 +108,5 @@ mod tests {
|
||||
assert!(!serves_page("not a url").await);
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(web: web_url);
|
||||
@@ -1,23 +1,48 @@
|
||||
//! Plugin command requests shared by local IPC and remote RPC.
|
||||
//! Plugin window commands shared by local IPC and remote RPC.
|
||||
|
||||
use super::PluginHost;
|
||||
use ide_core::{IdeResult, RequestId};
|
||||
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 ide_plugin::Invocation;
|
||||
use ide_workspace::settings::SettingsScope;
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub async fn run_command(
|
||||
host: &crate::Host,
|
||||
plugins: Arc<PluginHost>,
|
||||
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,
|
||||
plugin_id: String,
|
||||
command_id: String,
|
||||
arg: Option<String>,
|
||||
invocation: Invocation,
|
||||
editor: Option<PluginEditor>,
|
||||
paths: Option<Vec<PathBuf>>,
|
||||
settings_scope: Option<SettingsScope>,
|
||||
command_chain: Option<Vec<String>>,
|
||||
request: Option<RequestId>,
|
||||
) -> IdeResult<Option<String>> {
|
||||
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 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 result = host
|
||||
.blocking(move || {
|
||||
plugins.run_command_with_cancel(&plugin_id, &command_id, arg.as_deref(), invocation, cancel.as_ref())
|
||||
@@ -28,3 +53,251 @@ pub async fn 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,
|
||||
);
|
||||
@@ -3,20 +3,23 @@
|
||||
//! 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 the plugins' before-commit checks `checks` on what `selection` commits,
|
||||
/// until request `request` is cancelled.
|
||||
pub async fn commit_checks(
|
||||
/// Runs plugins' before-commit checks on what `selection` commits, until
|
||||
/// `request` is cancelled.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn plugin_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))
|
||||
@@ -26,3 +29,5 @@ pub async fn commit_checks(
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
ide_command::domain!(plugins_commit: plugin_commit_checks);
|
||||
@@ -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::list(host).into_iter().find(|r| r.id == run && r.config_id == owned.id);
|
||||
let info = crate::ops::run::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"));
|
||||
};
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
use super::PluginHost;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use ide_plugin::Invocation;
|
||||
use std::{path::PathBuf, sync::Arc};
|
||||
@@ -9,13 +10,15 @@ pub struct NavigationFiles {
|
||||
pub extensions: Vec<String>,
|
||||
}
|
||||
|
||||
/// File discovery is separate from clicking: the UI schedules small background
|
||||
/// batches after initial index completion and updates only changed files later.
|
||||
#[command(trust = trusted)]
|
||||
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);
|
||||
@@ -40,9 +43,10 @@ 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<()> {
|
||||
@@ -51,9 +55,10 @@ 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,
|
||||
@@ -61,6 +66,7 @@ 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();
|
||||
@@ -140,24 +146,28 @@ pub async fn plugin_navigation_index(
|
||||
result
|
||||
}
|
||||
|
||||
/// The HTTP routes `plugin_id` reports for this window's project.
|
||||
#[command(trust = trusted)]
|
||||
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 || {
|
||||
@@ -169,15 +179,17 @@ 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 || {
|
||||
@@ -191,3 +203,13 @@ 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,
|
||||
);
|
||||
@@ -11,25 +11,21 @@
|
||||
//! 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`, `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`
|
||||
//! 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`
|
||||
//! 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, PluginEditor, PluginEvent, PluginHost, PluginSource, SecretStore};
|
||||
use super::{Consent, HostWorkspace, PluginEvent, PluginHost, PluginSource, SecretStore};
|
||||
use crate::catalogue::TrustClass;
|
||||
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::{Invocation, Limits};
|
||||
use ide_workspace::settings::SettingsScope;
|
||||
use ide_plugin::Limits;
|
||||
use parking_lot::Mutex;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
@@ -47,49 +43,6 @@ 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 {
|
||||
@@ -482,10 +435,10 @@ impl RemotePlugins {
|
||||
result
|
||||
}
|
||||
|
||||
/// The run-time commands of remote windows plus [`SYNC_PACKAGES`].
|
||||
/// [`SYNC_PACKAGES`]; the plugin commands of remote windows are `#[command]`s.
|
||||
pub fn register(self: &Arc<Self>, d: &mut Dispatcher) {
|
||||
let this = self.clone();
|
||||
d.add(SYNC_PACKAGES, move |c| {
|
||||
d.add(SYNC_PACKAGES, TrustClass::Trusted, move |c| {
|
||||
let this = this.clone();
|
||||
async move {
|
||||
let packages: Vec<RemotePackage> = c.arg("packages")?;
|
||||
@@ -493,363 +446,9 @@ 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()))?
|
||||
}
|
||||
|
||||
@@ -1,9 +1,12 @@
|
||||
//! 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")]
|
||||
@@ -151,6 +154,27 @@ 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))
|
||||
}
|
||||
@@ -194,3 +218,5 @@ 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);
|
||||
Loaded 100 of 521 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача