дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-19 08:05:40 +02:00
Порівняти коміти
1
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
b3dc32c5ec |
No files matched your search
@@ -32,12 +32,7 @@ jobs:
|
||||
pull-requests: read
|
||||
outputs:
|
||||
rust: ${{ steps.classify.outputs.rust }}
|
||||
server: ${{ steps.classify.outputs.server }}
|
||||
plugins: ${{ steps.classify.outputs.plugins }}
|
||||
deny: ${{ steps.classify.outputs.deny }}
|
||||
frontend: ${{ steps.classify.outputs.frontend }}
|
||||
e2e: ${{ steps.classify.outputs.e2e }}
|
||||
catalog: ${{ steps.classify.outputs.catalog }}
|
||||
steps:
|
||||
- id: classify
|
||||
env:
|
||||
@@ -45,55 +40,26 @@ jobs:
|
||||
PR: ${{ github.event.pull_request.number }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
jobs="rust server plugins deny frontend e2e catalog"
|
||||
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
|
||||
for job in $jobs; do echo "$job=true" >> "$GITHUB_OUTPUT"; done
|
||||
echo "rust=true" >> "$GITHUB_OUTPUT"
|
||||
echo "frontend=true" >> "$GITHUB_OUTPUT"
|
||||
exit 0
|
||||
fi
|
||||
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
|
||||
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
|
||||
cat files.txt
|
||||
# A change to CI itself runs everything.
|
||||
ci='^\.github/(workflows/ci\.yml|actions/)'
|
||||
docs='^(docs/|\.agents/|\.claude/|\.idea/|\.github/ISSUE_TEMPLATE/|\.github/pull_request_template\.md$|[^/]+\.md$|LICENSE$|NOTICE$)'
|
||||
# Frontend-only paths. The Rust code embeds a few files under src/; those stay out.
|
||||
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|evals/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
|
||||
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
|
||||
embedded='^src/(bindings\.ts|styles/tokens\.css|features/plugins/views/frame-bridge\.js|platform/keymaps/)'
|
||||
# Plugin web pages are their own pnpm projects, checked by the Plugins job only.
|
||||
plugin_web='^plugins/official/[^/]+/web-src/'
|
||||
# Paths the frontend checks never read...
|
||||
backend='^(crates/|src-tauri/|sdk/|wit/|java/|fixtures/|Cargo\.(toml|lock)$|deny\.toml$|rustfmt\.toml$|rust-toolchain(\.toml)?$|\.cargo/)'
|
||||
# ...except these, which frontend tests and e2e fixtures load.
|
||||
read_by_web='^(fixtures/(folding|django-app)/|crates/ide-plugin/tests/fixtures/|crates/ide-db/(src|tests/fixtures)/snowflake/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
|
||||
# What the browser app and its e2e tests are built from.
|
||||
app='^(src/|e2e/|public/|index\.html$|vite\.config\.ts$|tsconfig\.json$|playwright\.config\.ts$|package\.json$|pnpm-(lock|workspace)\.yaml$|crates/ide-plugin/tests/fixtures/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
|
||||
# The plugin workspaces: the SDK, the plugins, their interface and the host's fixture plugins.
|
||||
plugin_ws='^(sdk/|plugins/|wit/|crates/ide-plugin/tests/fixtures/|rust-toolchain(\.toml)?$)'
|
||||
# Never compiled into the openidea-server binary.
|
||||
not_server='^(src-tauri/|sdk/|fixtures/|crates/[^/]+/(tests|benches)/)'
|
||||
deps='(^|/)Cargo\.(toml|lock)$|^deny\.toml$'
|
||||
# The text catalog test reads the string literals of every Rust source.
|
||||
rust_source='^(crates|src-tauri/src)/.*\.rs$'
|
||||
|
||||
any() { grep -Eq "$1" files.txt; }
|
||||
outside() { [ -n "$(grep -Ev "$1" files.txt || true)" ]; }
|
||||
set_job() { echo "$1=$2" | tee -a "$GITHUB_OUTPUT"; }
|
||||
|
||||
if any "$ci"; then
|
||||
for job in $jobs; do set_job "$job" true; done
|
||||
exit 0
|
||||
fi
|
||||
on() { if "${@:2}"; then set_job "$1" true; else set_job "$1" false; fi; }
|
||||
rust_build() { outside "$1" || any "$embedded"; }
|
||||
web_checks() { outside "$docs|$plugin_web|$backend" || any "$read_by_web"; }
|
||||
catalog_only() { ! web_checks && any "$rust_source"; }
|
||||
on rust rust_build "$docs|$web|$plugin_web"
|
||||
on server rust_build "$docs|$web|$plugin_web|$not_server"
|
||||
on plugins any "$plugin_ws"
|
||||
on deny any "$deps"
|
||||
on frontend web_checks
|
||||
on e2e any "$app"
|
||||
on catalog catalog_only
|
||||
# A job runs when any changed file falls outside the paths that can't affect it.
|
||||
rust=false
|
||||
if grep -Ev "$docs|$web" files.txt | grep -q . || grep -Eq "$embedded" files.txt; then rust=true; fi
|
||||
frontend=false
|
||||
if grep -Ev "$docs" files.txt | grep -q .; then frontend=true; fi
|
||||
echo "rust=$rust frontend=$frontend"
|
||||
echo "rust=$rust" >> "$GITHUB_OUTPUT"
|
||||
echo "frontend=$frontend" >> "$GITHUB_OUTPUT"
|
||||
|
||||
rust:
|
||||
name: Rust (${{ matrix.os }})
|
||||
@@ -145,7 +111,7 @@ jobs:
|
||||
server:
|
||||
name: Remote server (linux musl)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.server == 'true'
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
timeout-minutes: 40
|
||||
runs-on: ubuntu-22.04
|
||||
steps:
|
||||
@@ -163,7 +129,7 @@ jobs:
|
||||
plugins:
|
||||
name: Plugins (SDK, official, fixtures)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.plugins == 'true'
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-22.04
|
||||
env:
|
||||
@@ -215,7 +181,7 @@ jobs:
|
||||
deny:
|
||||
name: Cargo deny
|
||||
needs: changes
|
||||
if: needs.changes.outputs.deny == 'true'
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
timeout-minutes: 15
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
@@ -244,26 +210,10 @@ jobs:
|
||||
- run: pnpm test
|
||||
- run: pnpm build
|
||||
|
||||
# A backend-only change can still drop a string the text catalog uses: run that one test.
|
||||
catalog:
|
||||
name: Text catalog
|
||||
needs: changes
|
||||
if: needs.changes.outputs.catalog == 'true'
|
||||
timeout-minutes: 15
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v5
|
||||
- uses: pnpm/action-setup@v5
|
||||
with: { version: 11 }
|
||||
- uses: actions/setup-node@v5
|
||||
with: { node-version: 22, cache: pnpm }
|
||||
- run: pnpm install --frozen-lockfile
|
||||
- run: pnpm vitest run src/platform/locales/textCatalog.test.ts
|
||||
|
||||
e2e:
|
||||
name: E2E (${{ matrix.shard }}/2)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.e2e == 'true'
|
||||
if: needs.changes.outputs.frontend == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-24.04
|
||||
strategy:
|
||||
|
||||
@@ -15,7 +15,6 @@ on:
|
||||
- "crates/**"
|
||||
- "languages/**"
|
||||
- "fixtures/**"
|
||||
- "java/**"
|
||||
- "Cargo.toml"
|
||||
- "Cargo.lock"
|
||||
- "src/features/run/**"
|
||||
@@ -42,77 +41,12 @@ env:
|
||||
CARGO_INCREMENTAL: 0
|
||||
|
||||
jobs:
|
||||
# The languages a pull request can affect: a change to one language's fixture, definition or
|
||||
# JDT LS bundle runs that language; crates the smoke doesn't exercise and other crates' tests
|
||||
# run none; anything else runs them all. Pushes and manual runs always run them all.
|
||||
changes:
|
||||
name: Changes
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
permissions:
|
||||
pull-requests: read
|
||||
outputs:
|
||||
languages: ${{ steps.classify.outputs.languages }}
|
||||
steps:
|
||||
- id: classify
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
PR: ${{ github.event.pull_request.number }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
all="typescript python rust go java kotlin php c cpp"
|
||||
emit() { tr ' ' '\n' <<< "$1" | { grep . || true; } | sort -u | jq -Rsc 'split("\n") | map(select(. != ""))'; }
|
||||
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
|
||||
echo "languages=$(emit "$all")" | tee -a "$GITHUB_OUTPUT"
|
||||
exit 0
|
||||
fi
|
||||
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
|
||||
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
|
||||
cat files.txt
|
||||
# Crates outside what the smoke runs (language servers, debuggers, run configurations,
|
||||
# SDKs, build tools and the project model): cargo metadata, deps of ide-lsp/dap/run/sdk/tools.
|
||||
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-search|ide-spell|ide-ssh|ide-streams|ide-vcs|ide-web)/'
|
||||
# The workflow's paths, less those handled per language below.
|
||||
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger)/|src/platform/|smoke/|package\.json$|pnpm-lock\.yaml$|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
|
||||
langs=""
|
||||
while read -r f; do
|
||||
case "$f" in
|
||||
crates/ide-host/tests/language_smoke.rs | crates/ide-host/tests/project_smoke.rs) langs="$all"; break ;;
|
||||
crates/*/tests/* | crates/*/benches/*) ;;
|
||||
fixtures/ts-app/*) langs+=" typescript" ;;
|
||||
fixtures/python-app/*) langs+=" python" ;;
|
||||
fixtures/rust-app/*) langs+=" rust" ;;
|
||||
fixtures/go-app/*) langs+=" go" ;;
|
||||
fixtures/java-app/*) langs+=" java" ;;
|
||||
fixtures/kotlin-gradle/*) langs+=" kotlin" ;;
|
||||
fixtures/php-app/*) langs+=" php" ;;
|
||||
fixtures/c-app/*) langs+=" c cpp" ;;
|
||||
fixtures/*) ;;
|
||||
languages/typescript.toml | languages/typescriptreact.toml | languages/javascript.toml | languages/javascriptreact.toml) langs+=" typescript" ;;
|
||||
languages/python.toml) langs+=" python" ;;
|
||||
languages/rust.toml) langs+=" rust" ;;
|
||||
languages/go.toml | languages/gomod.toml | languages/gowork.toml) langs+=" go" ;;
|
||||
languages/java.toml) langs+=" java" ;;
|
||||
languages/kotlin.toml) langs+=" kotlin" ;;
|
||||
languages/php.toml) langs+=" php" ;;
|
||||
languages/c.toml) langs+=" c" ;;
|
||||
languages/cpp.toml) langs+=" cpp" ;;
|
||||
languages/*) ;;
|
||||
java/kotlin-bridge/*) langs+=" kotlin" ;;
|
||||
java/*) langs+=" java kotlin" ;;
|
||||
*) if grep -Eq "$smoke" <<< "$f" && ! grep -Eq "$unused" <<< "$f"; then langs="$all"; break; fi ;;
|
||||
esac
|
||||
done < files.txt
|
||||
echo "languages=$(emit "$langs")" | tee -a "$GITHUB_OUTPUT"
|
||||
|
||||
smoke:
|
||||
name: Language smoke (${{ matrix.language }})
|
||||
needs: changes
|
||||
if: needs.changes.outputs.languages != '[]'
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
language: ${{ fromJSON(needs.changes.outputs.languages) }}
|
||||
language: [typescript, python, rust, go, java, kotlin, php, c, cpp]
|
||||
# C/C++ debug with GDB, whose DAP interpreter needs 14+: 22.04 ships 12.1, 24.04 ships 15.
|
||||
runs-on: ${{ (matrix.language == 'c' || matrix.language == 'cpp') && 'ubuntu-24.04' || 'ubuntu-22.04' }}
|
||||
timeout-minutes: 40
|
||||
|
||||
@@ -9,7 +9,6 @@
|
||||
"dist",
|
||||
"target",
|
||||
"src/bindings.ts",
|
||||
"docs/snippets/plugin-catalog.jsx",
|
||||
"evals/*/golden",
|
||||
"src/editor/core/cm/angular/parser*.ts",
|
||||
"src/editor/core/cm/jsp/parser*.ts",
|
||||
|
||||
Створено
+46
-48
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
|
||||
|
||||
[[package]]
|
||||
name = "ide-agent"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4169,7 +4169,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-analysis"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ast-grep-core",
|
||||
"ide-core",
|
||||
@@ -4183,7 +4183,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-android"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4194,7 +4194,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-build"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"chardetng",
|
||||
@@ -4212,7 +4212,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-cli"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"serde",
|
||||
@@ -4226,7 +4226,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-clipboard"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
@@ -4237,7 +4237,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-command"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"heck 0.5.0",
|
||||
"proc-macro2",
|
||||
@@ -4248,7 +4248,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-core"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4265,7 +4265,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-coverage"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-run",
|
||||
@@ -4279,7 +4279,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-dap"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"futures",
|
||||
@@ -4308,7 +4308,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-db"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"bb8",
|
||||
@@ -4344,7 +4344,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-docker"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4357,7 +4357,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4378,7 +4378,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-fonts"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-text",
|
||||
@@ -4390,7 +4390,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-github"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vcs",
|
||||
@@ -4403,7 +4403,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-heap"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4421,7 +4421,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-host"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4495,7 +4495,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-http"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
@@ -4514,7 +4514,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-index"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4536,7 +4536,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jdwp"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-jvm-inspect",
|
||||
"proptest",
|
||||
@@ -4548,7 +4548,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jsonrpc"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"encoding_rs",
|
||||
"futures",
|
||||
@@ -4565,7 +4565,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-attach"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"tempfile",
|
||||
@@ -4574,7 +4574,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-inspect"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"serde",
|
||||
@@ -4585,11 +4585,10 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-language"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
"dunce",
|
||||
"ide-core",
|
||||
"ide-extension",
|
||||
"ide-text",
|
||||
@@ -4644,7 +4643,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-lsp"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4672,7 +4671,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-mcp"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"dunce",
|
||||
@@ -4691,7 +4690,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-notebook"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"ide-core",
|
||||
@@ -4714,7 +4713,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-plugin"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4737,7 +4736,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-profiler"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-jvm-attach",
|
||||
@@ -4751,7 +4750,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-remote"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"futures",
|
||||
@@ -4771,7 +4770,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-run"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4795,7 +4794,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-scaffold"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-tools",
|
||||
@@ -4811,7 +4810,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-sdk"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"flate2",
|
||||
@@ -4834,7 +4833,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-search"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"encoding_rs",
|
||||
@@ -4855,7 +4854,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-spell"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"parking_lot",
|
||||
@@ -4868,7 +4867,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-ssh"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"flate2",
|
||||
@@ -4893,7 +4892,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-streams"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4906,7 +4905,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-syntax"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4921,7 +4920,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-terminal"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"libc",
|
||||
@@ -4934,7 +4933,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-text"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4947,7 +4946,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-tools"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"hex",
|
||||
@@ -4968,7 +4967,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vcs"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4989,7 +4988,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vfs"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"chardetng",
|
||||
"dunce",
|
||||
@@ -5015,7 +5014,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-web"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"ide-core",
|
||||
@@ -5031,7 +5030,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-workspace"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -6660,7 +6659,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "openidea"
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -6734,7 +6733,6 @@ dependencies = [
|
||||
"tracing",
|
||||
"tracing-appender",
|
||||
"tracing-subscriber",
|
||||
"webview2-com",
|
||||
"windows",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
+1
-1
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
|
||||
exclude = ["sdk", "plugins"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.48"
|
||||
version = "0.1.47"
|
||||
edition = "2024"
|
||||
rust-version = "1.96"
|
||||
license = "Apache-2.0"
|
||||
|
||||
@@ -194,36 +194,6 @@ declarations, key and animation binding names (`(keydown.enter)`, `[@fade]`,
|
||||
`(@fade.done)`), runs of text that entities split (`a && b`) parsed as one, and one
|
||||
token for `{` and `}`.
|
||||
|
||||
## Julia CodeMirror language support
|
||||
|
||||
[`@plutojl/lang-julia`](https://github.com/JuliaPluto/lang-julia) 1.2.0 and its
|
||||
[`@plutojl/lezer-julia`](https://github.com/JuliaPluto/lezer-julia) parser dependency
|
||||
provide the Julia CodeMirror 6 language mode. Both packages are MIT licensed;
|
||||
the full license text is below. The mode wraps a Lezer grammar and exposes its
|
||||
syntax tags through `julia()`.
|
||||
|
||||
### MIT License (@plutojl/lang-julia and @plutojl/lezer-julia)
|
||||
|
||||
Copyright (c) 2021 Andrey Popp
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
## nvim-treesitter queries
|
||||
|
||||
`crates/ide-syntax/queries/<grammar>/locals.scm` are derived from the `locals.scm`
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
//! Codex's asynchronous questions are answered by a user message, not a permission response.
|
||||
|
||||
use crate::AgentQuestion;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde_json::json;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// The wire reply and its readable record. Question ids, not wording, associate each answer.
|
||||
pub(crate) fn reply(questions: &[AgentQuestion], answers: &str) -> IdeResult<(String, String)> {
|
||||
let answers: BTreeMap<String, Vec<String>> =
|
||||
serde_json::from_str(answers).map_err(|_| IdeError::invalid("invalid question answers"))?;
|
||||
if questions.is_empty() || answers.len() != questions.len() {
|
||||
return Err(IdeError::invalid("answer every question"));
|
||||
}
|
||||
let mut replies = Vec::new();
|
||||
let mut record = Vec::new();
|
||||
for question in questions {
|
||||
let key = question.answer_key.as_deref().ok_or_else(|| IdeError::invalid("missing question id"))?;
|
||||
let values = answers.get(key).ok_or_else(|| IdeError::invalid("missing question answer"))?;
|
||||
if values.is_empty()
|
||||
|| (!question.multi_select && values.len() != 1)
|
||||
|| values.iter().any(|v| v.trim().is_empty())
|
||||
{
|
||||
return Err(IdeError::invalid("empty or invalid question answer"));
|
||||
}
|
||||
let answer = values.iter().map(|v| v.trim()).collect::<Vec<_>>().join(", ");
|
||||
let mut title = question.question.clone();
|
||||
let mut end = title.len().min(512);
|
||||
while !title.is_char_boundary(end) {
|
||||
end -= 1;
|
||||
}
|
||||
title.truncate(end);
|
||||
title = title.replace(['\n', '\r'], " ");
|
||||
replies.push(json!({ "questionItemId": key, "question": title, "answer": answer }));
|
||||
record.push(format!("{}: {}", question.question, answer));
|
||||
}
|
||||
Ok((
|
||||
format!("<send_user_message_question_reply>\n{}\n</send_user_message_question_reply>", json!(replies)),
|
||||
record.join("\n"),
|
||||
))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn question(key: &str) -> AgentQuestion {
|
||||
AgentQuestion {
|
||||
answer_key: Some(key.into()),
|
||||
header: String::new(),
|
||||
question: "Which?".into(),
|
||||
multi_select: false,
|
||||
options: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn identical_wording_keeps_answers_associated_with_ids() {
|
||||
let (wire, record) =
|
||||
reply(&[question("first"), question("second")], r#"{"first":[" One "],"second":["Two"]}"#).unwrap();
|
||||
let body = wire
|
||||
.strip_prefix("<send_user_message_question_reply>\n")
|
||||
.unwrap()
|
||||
.strip_suffix("\n</send_user_message_question_reply>")
|
||||
.unwrap();
|
||||
let replies: serde_json::Value = serde_json::from_str(body).unwrap();
|
||||
assert_eq!(replies[0], json!({"questionItemId":"first","question":"Which?","answer":"One"}));
|
||||
assert_eq!(replies[1]["answer"], "Two");
|
||||
assert_eq!(record, "Which?: One\nWhich?: Two");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_missing_and_empty_answers_are_rejected() {
|
||||
for answers in
|
||||
["no", "{}", r#"{"other":["One"]}"#, r#"{"first":[]}"#, r#"{"first":[" "]}"#, r#"{"first":["One","Two"]}"#]
|
||||
{
|
||||
assert!(reply(&[question("first")], answers).is_err(), "{answers}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -213,31 +213,6 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
/// Availability for an explicit session switch must come from a recent discovery for this
|
||||
/// launch, not from the display fallback or a different project's session report.
|
||||
pub(super) fn fresh_model(
|
||||
&self,
|
||||
shared: &Shared,
|
||||
spec: &provider::ProviderSpec,
|
||||
model: &str,
|
||||
) -> Option<crate::AgentConfigValue> {
|
||||
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
|
||||
let select = |catalog: &CatalogData| {
|
||||
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
|
||||
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
|
||||
return None;
|
||||
}
|
||||
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
|
||||
};
|
||||
let state = self.state.lock();
|
||||
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
|
||||
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
|
||||
}
|
||||
let cache = shared.known.lock();
|
||||
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
|
||||
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
|
||||
}
|
||||
|
||||
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
let state = self.state.lock();
|
||||
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
|
||||
|
||||
@@ -11,7 +11,6 @@ const PROVIDER: &str = "catalog-test";
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Pending {
|
||||
launch: usize,
|
||||
method: String,
|
||||
params: Value,
|
||||
reply: oneshot::Sender<Result<Value, String>>,
|
||||
@@ -45,7 +44,7 @@ impl Harness {
|
||||
let launches = launches.clone();
|
||||
let live = live.clone();
|
||||
move |_, _, client, _| {
|
||||
let launch = launches.fetch_add(1, Ordering::SeqCst);
|
||||
launches.fetch_add(1, Ordering::SeqCst);
|
||||
live.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Live(live.clone());
|
||||
let pending = pending_tx.clone();
|
||||
@@ -76,17 +75,10 @@ impl Harness {
|
||||
}
|
||||
let response = match request["method"].as_str().unwrap() {
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
|
||||
"session/new"
|
||||
| "session/set_config_option"
|
||||
| "session/set_model"
|
||||
| "session/load"
|
||||
| "session/resume"
|
||||
| "session/prompt"
|
||||
| "session/set_mode" => {
|
||||
"session/new" | "session/set_config_option" | "session/set_model" => {
|
||||
let (reply, mut result) = oneshot::channel();
|
||||
pending
|
||||
.send(Pending {
|
||||
launch,
|
||||
method: request["method"].as_str().unwrap().to_owned(),
|
||||
params: request["params"].clone(),
|
||||
reply,
|
||||
@@ -298,223 +290,6 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_confirmed_by_the_live_session() {
|
||||
switch_chat_model(ChatSwitch::Live).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
|
||||
switch_chat_model(ChatSwitch::Resume).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
|
||||
switch_chat_model(ChatSwitch::ResumeFails).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
|
||||
switch_chat_model(ChatSwitch::Unavailable).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
|
||||
switch_chat_model(ChatSwitch::Idle).await;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum ChatSwitch {
|
||||
Live,
|
||||
Resume,
|
||||
ResumeFails,
|
||||
Unavailable,
|
||||
Idle,
|
||||
}
|
||||
|
||||
async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::with_initialize(json!({
|
||||
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
|
||||
}));
|
||||
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let task = manager
|
||||
.create(NewAgentTask {
|
||||
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
|
||||
provider: PROVIDER.into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
|
||||
let mut initial = response(&["old"], &["low", "high"]);
|
||||
initial["sessionId"] = json!("saved-chat");
|
||||
initial["modes"] = json!({
|
||||
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
|
||||
});
|
||||
next.reply.send(Ok(initial.clone())).unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(0, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let mode = manager.set_config(&task.id, "mode", "ask".into());
|
||||
tokio::pin!(mode);
|
||||
let set = next_chat_request(&mut harness, mode.as_mut()).await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
mode.await.unwrap();
|
||||
}
|
||||
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
|
||||
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
|
||||
if matches!(scenario, ChatSwitch::Idle) {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
}
|
||||
|
||||
let mut events = events(&manager);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
|
||||
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
|
||||
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
|
||||
|
||||
let live = matches!(scenario, ChatSwitch::Live);
|
||||
let offline = matches!(scenario, ChatSwitch::Idle);
|
||||
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
|
||||
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
}
|
||||
}
|
||||
// A fallback selection settles without waiting for a new process.
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not open another session: {request:?}"),
|
||||
}
|
||||
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
|
||||
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
|
||||
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
|
||||
|
||||
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
|
||||
if !live {
|
||||
let load = harness.next().await;
|
||||
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
|
||||
assert_eq!(load.params["sessionId"], "saved-chat");
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
|
||||
}}))
|
||||
.unwrap();
|
||||
if load_fails {
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "config_option_update",
|
||||
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
|
||||
}}))
|
||||
.unwrap();
|
||||
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
|
||||
} else {
|
||||
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
|
||||
let mut resumed = response(models, &["low", "high"]);
|
||||
resumed["modes"] = initial["modes"].clone();
|
||||
load.reply.send(Ok(resumed)).unwrap();
|
||||
}
|
||||
if load_fails || unavailable {
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
|
||||
let task = snapshot(&manager);
|
||||
assert_eq!(task.model.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
|
||||
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
|
||||
if load_fails {
|
||||
manager
|
||||
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
|
||||
.await
|
||||
.unwrap();
|
||||
let retry = harness.next().await;
|
||||
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
|
||||
assert_eq!(retry.params["sessionId"], "saved-chat");
|
||||
retry.reply.send(Ok(initial.clone())).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!(set.method, "session/set_mode");
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
let prompt = harness.next().await;
|
||||
assert_eq!(prompt.method, "session/prompt");
|
||||
assert_eq!(prompt.params["sessionId"], "saved-chat");
|
||||
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
}
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
}
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("new"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
|
||||
manager.shutdown();
|
||||
}
|
||||
|
||||
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
|
||||
let task = manager.task(id).unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while task.state.lock().task.status != status || task.state.lock().busy {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
async fn next_chat_request(
|
||||
harness: &mut Harness,
|
||||
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
|
||||
) -> Pending {
|
||||
tokio::select! {
|
||||
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
|
||||
request = harness.next() => request,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -219,23 +219,6 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
|
||||
}
|
||||
}
|
||||
|
||||
/// Legacy setters and agents that report the change in a notification may return no model.
|
||||
pub(super) fn accepts_model(reply: &Value, id: &str, value: &str) -> bool {
|
||||
reply
|
||||
.get("configOptions")
|
||||
.and_then(Value::as_array)
|
||||
.and_then(|options| {
|
||||
options.iter().find(|option| {
|
||||
option.get("category").and_then(Value::as_str) == Some("model")
|
||||
|| option.get("id").or_else(|| option.get("configId")).and_then(Value::as_str) == Some(id)
|
||||
})
|
||||
})
|
||||
.and_then(|option| option.get("currentValue"))
|
||||
.or_else(|| reply.pointer("/models/currentModelId"))
|
||||
.and_then(Value::as_str)
|
||||
.is_none_or(|current| current == value)
|
||||
}
|
||||
|
||||
/// `available_commands_update`.
|
||||
pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
|
||||
update
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
//! next prompt when the agent supports `session/load`.
|
||||
|
||||
mod acp;
|
||||
mod async_questions;
|
||||
mod catalogs;
|
||||
mod config;
|
||||
mod conversation;
|
||||
@@ -348,9 +347,6 @@ struct TaskFile {
|
||||
/// Settings the user chose, re-applied to every new or reloaded session.
|
||||
#[serde(default)]
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pending_model: Option<String>,
|
||||
/// In the project's own checkout: files already changed when the task started.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
before: BTreeMap<String, worktree::Stamp>,
|
||||
@@ -362,9 +358,6 @@ struct TaskFile {
|
||||
/// `None` for a worktree task, and a task saved before these were recorded.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
touched: Option<BTreeSet<String>>,
|
||||
/// The checkout as the last turn started, its copies in the store's `<id>.turn` folder.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
turn: Option<worktree::TurnStart>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
subagents: Vec<SavedSubagent>,
|
||||
/// Turns to drop from the session once it is loaded (a fork of an earlier point).
|
||||
@@ -383,14 +376,11 @@ struct TaskState {
|
||||
session_id: Option<String>,
|
||||
conversation: Conversation,
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
pending_model: Option<String>,
|
||||
model_choice: u64,
|
||||
before: Arc<BTreeMap<String, worktree::Stamp>>,
|
||||
saved: Option<String>,
|
||||
/// See `TaskFile::touched`.
|
||||
touched: Option<Arc<BTreeSet<String>>>,
|
||||
/// See `TaskFile::turn`.
|
||||
turn: Option<Arc<worktree::TurnStart>>,
|
||||
pending_rollback: u32,
|
||||
/// The user named the task; see `TaskFile::title_renamed`.
|
||||
title_renamed: bool,
|
||||
@@ -402,24 +392,6 @@ struct TaskState {
|
||||
background_tasks: Vec<Value>,
|
||||
}
|
||||
|
||||
impl TaskState {
|
||||
fn pending_model(&self) -> Option<&AgentConfigChoice> {
|
||||
let id = self.pending_model.as_deref()?;
|
||||
self.wanted.iter().find(|c| c.id == id)
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> AgentTask {
|
||||
let mut task = self.task.clone();
|
||||
if let Some(choice) = self.pending_model()
|
||||
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
|
||||
{
|
||||
model.current = Some(choice.value.clone());
|
||||
task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
task
|
||||
}
|
||||
}
|
||||
|
||||
/// A running agent and its session.
|
||||
#[derive(Clone)]
|
||||
struct Live {
|
||||
@@ -443,15 +415,11 @@ struct Task {
|
||||
live: Mutex<Option<Live>>,
|
||||
/// Serializes starting the agent.
|
||||
connecting: tokio::sync::Mutex<()>,
|
||||
/// Serializes replies from multiple windows to the same async question.
|
||||
answering_questions: tokio::sync::Mutex<()>,
|
||||
/// Unanswered permission requests: where to send the chosen option id.
|
||||
permissions: Mutex<HashMap<u32, std::sync::mpsc::Sender<Option<String>>>>,
|
||||
next_permission: AtomicU32,
|
||||
/// Set while `session/load` replays history we already have.
|
||||
replaying: AtomicBool,
|
||||
/// The saved session failed to load and the user was told: the next start opens a new one.
|
||||
start_fresh: AtomicBool,
|
||||
/// The current turn is being cancelled to send the first queued message right away.
|
||||
send_now: AtomicBool,
|
||||
/// The user stopped the current turn. A stop that reaches the agent before it took the
|
||||
@@ -546,7 +514,7 @@ impl AgentManager {
|
||||
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
|
||||
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
|
||||
*self.shared.sink.write() = Some(sink);
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().task.clone()).collect();
|
||||
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
|
||||
tasks
|
||||
}
|
||||
@@ -777,11 +745,9 @@ impl AgentManager {
|
||||
session_id: Some(session_id.to_owned()),
|
||||
entries: Vec::new(),
|
||||
wanted: Vec::new(),
|
||||
pending_model: None,
|
||||
before: BTreeMap::new(),
|
||||
saved: None,
|
||||
touched: Some(BTreeSet::new()),
|
||||
turn: None,
|
||||
subagents: Vec::new(),
|
||||
pending_rollback: 0,
|
||||
title_renamed: true,
|
||||
@@ -892,11 +858,9 @@ impl AgentManager {
|
||||
session_id: None,
|
||||
entries: Vec::new(),
|
||||
wanted: req.config,
|
||||
pending_model: None,
|
||||
before,
|
||||
saved,
|
||||
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
|
||||
turn: None,
|
||||
subagents: Vec::new(),
|
||||
pending_rollback: 0,
|
||||
title_renamed: false,
|
||||
@@ -1025,7 +989,7 @@ impl AgentManager {
|
||||
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
|
||||
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let (target, change) = {
|
||||
let (target, model_choice, previous_levels) = {
|
||||
let mut s = task.state.lock();
|
||||
let target = s
|
||||
.task
|
||||
@@ -1035,28 +999,22 @@ impl AgentManager {
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
if target.category.as_deref() != Some("model") {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
(target, None)
|
||||
} else {
|
||||
let switching_model = target.category.as_deref() == Some("model");
|
||||
if switching_model {
|
||||
s.model_choice += 1;
|
||||
s.pending_model = None;
|
||||
}
|
||||
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
|
||||
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
|
||||
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current =
|
||||
Some(value.clone());
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
(target, Some((s.model_choice, previous_levels)))
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
};
|
||||
let Some((model_choice, previous_levels)) = change else {
|
||||
return task.switch_discovered_model(target, value).await;
|
||||
if target.category.as_deref() == Some("model") {
|
||||
s.model_choice += 1;
|
||||
}
|
||||
let previous_levels =
|
||||
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
|
||||
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
|
||||
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
(target, s.model_choice, previous_levels)
|
||||
};
|
||||
let previous = target.current.clone();
|
||||
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
|
||||
@@ -1223,12 +1181,9 @@ impl AgentManager {
|
||||
session_id: Some(session),
|
||||
entries,
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: None,
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
// The source's next turn replaces its copies: the fork's last turn is one of its own.
|
||||
turn: None,
|
||||
subagents: s.conversation.saved_subagents(),
|
||||
pending_rollback: total - keep,
|
||||
title_renamed: s.title_renamed,
|
||||
@@ -1268,7 +1223,6 @@ impl AgentManager {
|
||||
_ => None,
|
||||
};
|
||||
s.session_id = None;
|
||||
s.pending_model = None;
|
||||
s.conversation = Conversation::default();
|
||||
// The fresh session reports its own usage; nothing carries over.
|
||||
s.task.usage = None;
|
||||
@@ -1455,53 +1409,6 @@ impl AgentManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// Replies to a non-blocking question without interrupting the agent's current turn.
|
||||
pub async fn answer_question(&self, id: &str, question: &str, answer: Option<String>) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let _answering = task.answering_questions.lock().await;
|
||||
let questions = {
|
||||
let s = task.state.lock();
|
||||
s.conversation
|
||||
.main
|
||||
.entries
|
||||
.iter()
|
||||
.find_map(|entry| match entry {
|
||||
AgentEntry::Question { id, questions, chosen: None, .. } if id == question => {
|
||||
Some(questions.clone())
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.ok_or_else(|| IdeError::not_found("the question was already answered"))?
|
||||
};
|
||||
let chosen = match answer {
|
||||
None => "Skipped".to_owned(),
|
||||
Some(answer) => {
|
||||
let (text, record) = async_questions::reply(&questions, &answer)?;
|
||||
let prompt = AgentPrompt { text, files: Vec::new(), images: Vec::new() };
|
||||
if let Err(prompt) = task.steer(prompt).await {
|
||||
if task.state.lock().busy {
|
||||
return Err(IdeError::unavailable("the reply could not join the running turn; try again"));
|
||||
}
|
||||
self.prompt(id, prompt, false).await?;
|
||||
}
|
||||
record
|
||||
}
|
||||
};
|
||||
let changed = {
|
||||
let mut s = task.state.lock();
|
||||
s.conversation.main.entries.iter_mut().enumerate().find_map(|(index, entry)| match entry {
|
||||
AgentEntry::Question { id, chosen: current, .. } if id == question => {
|
||||
*current = Some(chosen.clone());
|
||||
Some((None, index))
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
};
|
||||
task.mark_dirty(changed);
|
||||
task.persist();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Stops the agent and moves the task to Archived; its worktree stays.
|
||||
pub fn archive(&self, id: &str) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
@@ -1569,7 +1476,6 @@ impl AgentManager {
|
||||
self.tasks.write().remove(id);
|
||||
*task.deleted.lock() = true;
|
||||
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{id}.json")));
|
||||
let _ = std::fs::remove_dir_all(task.turn_dir());
|
||||
let saved = task.state.lock().saved.clone();
|
||||
if let Some(saved) = saved
|
||||
&& !self.tasks.read().values().any(|t| t.state.lock().saved.as_ref() == Some(&saved))
|
||||
@@ -1612,47 +1518,18 @@ impl AgentManager {
|
||||
.await
|
||||
}
|
||||
|
||||
/// The files the task's last turn changed, against the checkout as it started (while a
|
||||
/// turn runs: that turn's so far). None before the task's first turn.
|
||||
pub async fn turn_changes(&self, id: &str) -> IdeResult<Vec<AgentChange>> {
|
||||
let (cwd, turn, dir) = self.task(id)?.last_turn();
|
||||
let Some(turn) = turn else { return Ok(Vec::new()) };
|
||||
blocking(move || {
|
||||
let changed = match &turn.changed {
|
||||
Some(changed) => changed.clone(),
|
||||
None => worktree::changed_in_turn(&cwd, &turn)?.1,
|
||||
};
|
||||
worktree::turn_changes(&cwd, &turn, &dir, &changed)
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Content of `path` (in the task's directory) as `view` compares it: when the task
|
||||
/// started, in `HEAD`, or when the last turn started.
|
||||
pub async fn base_text(&self, id: &str, path: PathBuf, view: AgentChangesView) -> IdeResult<Option<String>> {
|
||||
let task = self.task(id)?;
|
||||
if view == AgentChangesView::LastTurn {
|
||||
let (cwd, turn, dir) = task.last_turn();
|
||||
let Some(turn) = turn else { return Ok(None) };
|
||||
return blocking(move || worktree::turn_text(&cwd, &path, &turn, &dir)).await;
|
||||
}
|
||||
let at = task.base();
|
||||
blocking(move || {
|
||||
let rev = match view {
|
||||
AgentChangesView::Group => worktree::head_commit(at.cwd())?,
|
||||
_ => at.rev()?,
|
||||
};
|
||||
match rev {
|
||||
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
|
||||
None => Ok(None),
|
||||
}
|
||||
/// Content of `path` (in the task's directory) when the task started.
|
||||
pub async fn base_text(&self, id: &str, path: PathBuf) -> IdeResult<Option<String>> {
|
||||
let at = self.task(id)?.base();
|
||||
blocking(move || match at.rev()? {
|
||||
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
|
||||
None => Ok(None),
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Rollback: puts the task's changed files among `rel_paths` (all with `None`) back as
|
||||
/// `view` compares them: as they were when it started, as they are in `HEAD`, or as they
|
||||
/// were when its last turn started.
|
||||
/// `view` compares them: as they were when it started, or as they are in `HEAD`.
|
||||
pub async fn rollback_changes(
|
||||
&self,
|
||||
id: &str,
|
||||
@@ -1663,18 +1540,15 @@ impl AgentManager {
|
||||
if task.state.lock().busy {
|
||||
return Err(IdeError::invalid("the agent is working: stop it before rolling back its changes"));
|
||||
}
|
||||
if view == AgentChangesView::LastTurn {
|
||||
return self.rollback_turn(&task, rel_paths).await;
|
||||
}
|
||||
let at = task.base();
|
||||
let (before, saved, touched) = {
|
||||
let s = task.state.lock();
|
||||
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)), s.touched.clone())
|
||||
};
|
||||
let (restamped, restored) = blocking(move || {
|
||||
let restamped = blocking(move || {
|
||||
let (changes, rev) = match view {
|
||||
AgentChangesView::Group => (at.grouped_changes(&before)?.uncommitted, worktree::head_commit(at.cwd())?),
|
||||
AgentChangesView::SinceStart | AgentChangesView::LastTurn => (at.changes(&before)?, at.rev()?),
|
||||
AgentChangesView::SinceStart => (at.changes(&before)?, at.rev()?),
|
||||
};
|
||||
let changes = worktree::made_by_task(changes, touched.as_deref());
|
||||
let sources = match rev.as_deref() {
|
||||
@@ -1682,7 +1556,6 @@ impl AgentManager {
|
||||
None => Default::default(),
|
||||
};
|
||||
let mut restamped = Vec::new();
|
||||
let mut restored = Vec::new();
|
||||
for change in changes.iter().filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path))) {
|
||||
// A rename goes back to its old path too; the new one is taken away first, so a
|
||||
// case-only rename on a case-insensitive disk ends as the old file.
|
||||
@@ -1692,58 +1565,6 @@ impl AgentManager {
|
||||
if before.contains_key(&change.rel_path) {
|
||||
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
|
||||
}
|
||||
restored.push(change.rel_path.clone());
|
||||
}
|
||||
}
|
||||
Ok((restamped, restored))
|
||||
})
|
||||
.await?;
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
if !restamped.is_empty() {
|
||||
let mut before = (*s.before).clone();
|
||||
before.extend(restamped);
|
||||
s.before = Arc::new(before);
|
||||
}
|
||||
// Rolled back further than the last turn: what it changed there is gone, not the turn's to list.
|
||||
if let Some(turn) = &s.turn
|
||||
&& let Some(changed) = &turn.changed
|
||||
&& restored.iter().any(|rel| changed.contains(rel))
|
||||
{
|
||||
let changed = changed.iter().filter(|rel| !restored.contains(rel)).cloned().collect();
|
||||
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(changed), ..(**turn).clone() }));
|
||||
}
|
||||
}
|
||||
task.persist();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Puts the last turn's changed files among `rel_paths` (all with `None`) back as they
|
||||
/// were when it started.
|
||||
async fn rollback_turn(&self, task: &Task, rel_paths: Option<Vec<String>>) -> IdeResult<()> {
|
||||
let (cwd, turn, dir) = task.last_turn();
|
||||
let Some(turn) = turn else { return Ok(()) };
|
||||
let (before, saved) = {
|
||||
let s = task.state.lock();
|
||||
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)))
|
||||
};
|
||||
let restamped = blocking(move || {
|
||||
let changed = match &turn.changed {
|
||||
Some(changed) => changed.clone(),
|
||||
None => worktree::changed_in_turn(&cwd, &turn)?.1,
|
||||
};
|
||||
let mut restamped = Vec::new();
|
||||
for change in worktree::turn_changes(&cwd, &turn, &dir, &changed)?
|
||||
.iter()
|
||||
.filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path)))
|
||||
{
|
||||
worktree::restore_turn(&cwd, &turn, &dir, change)?;
|
||||
// Back to the user's own edits from before the task: not a change of the task.
|
||||
if let Some(Some(_)) = before.get(&change.rel_path)
|
||||
&& let Some(copy) = saved.as_deref().and_then(|d| worktree::saved_copy(d, &change.rel_path))
|
||||
&& std::fs::read(&change.path.0).is_ok_and(|now| now == copy)
|
||||
{
|
||||
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
|
||||
}
|
||||
}
|
||||
Ok(restamped)
|
||||
@@ -1817,7 +1638,7 @@ impl AgentManager {
|
||||
s.task.mcp_overrides = cleaned;
|
||||
s.task.updated_ms = now_ms();
|
||||
}
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.snapshot())
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
|
||||
};
|
||||
if changed {
|
||||
task.persist();
|
||||
@@ -1875,12 +1696,10 @@ impl Task {
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
pending_model: file.pending_model,
|
||||
model_choice: 0,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
turn: file.turn.map(Arc::new),
|
||||
pending_rollback: file.pending_rollback,
|
||||
title_renamed: file.title_renamed,
|
||||
busy: false,
|
||||
@@ -1888,11 +1707,9 @@ impl Task {
|
||||
}),
|
||||
live: Mutex::new(None),
|
||||
connecting: tokio::sync::Mutex::new(()),
|
||||
answering_questions: tokio::sync::Mutex::new(()),
|
||||
permissions: Mutex::new(HashMap::new()),
|
||||
next_permission: AtomicU32::new(1),
|
||||
replaying: AtomicBool::new(false),
|
||||
start_fresh: AtomicBool::new(false),
|
||||
send_now: AtomicBool::new(false),
|
||||
cancel_pending: AtomicBool::new(false),
|
||||
turn_started: AtomicBool::new(false),
|
||||
@@ -1914,48 +1731,31 @@ impl Task {
|
||||
(s.before.clone(), s.touched.clone())
|
||||
}
|
||||
|
||||
/// Where the copies of the files already changed as the last turn started are kept.
|
||||
fn turn_dir(&self) -> PathBuf {
|
||||
self.shared.paths.store_dir.join(format!("{}.turn", self.id))
|
||||
}
|
||||
|
||||
/// The checkout as the last turn started, with the folder of its copies.
|
||||
fn last_turn(&self) -> (PathBuf, Option<Arc<worktree::TurnStart>>, PathBuf) {
|
||||
let s = self.state.lock();
|
||||
(s.task.cwd.0.clone(), s.turn.clone(), self.turn_dir())
|
||||
}
|
||||
|
||||
/// Records the checkout as a turn starts: what the turn's changes are compared with.
|
||||
async fn checkout_before_turn(&self) {
|
||||
let (cwd, previous, dir) = self.last_turn();
|
||||
let turn = match blocking(move || worktree::start_turn(&cwd, &dir, previous.as_deref())).await {
|
||||
Ok(turn) => Some(Arc::new(turn)),
|
||||
Err(e) => {
|
||||
tracing::warn!("recording the checkout as a turn of agent task {} starts: {e}", self.id);
|
||||
None
|
||||
}
|
||||
/// The changed files of the checkout as a turn starts, when the task records what its turns change.
|
||||
async fn checkout_before_turn(&self) -> Option<Snapshot> {
|
||||
let cwd = {
|
||||
let s = self.state.lock();
|
||||
s.touched.as_ref()?;
|
||||
s.task.cwd.0.clone()
|
||||
};
|
||||
self.state.lock().turn = turn;
|
||||
self.persist();
|
||||
blocking(move || worktree::snapshot(&cwd)).await.ok()
|
||||
}
|
||||
|
||||
/// Records the files that changed in the checkout while the turn ran: the turn's, and in
|
||||
/// the project's own checkout also the task's.
|
||||
async fn record_turn_changes(&self) {
|
||||
let (cwd, turn, _) = self.last_turn();
|
||||
let Some(turn) = turn else { return };
|
||||
let start = turn.clone();
|
||||
let Ok((in_worktree, all)) = blocking(move || worktree::changed_in_turn(&cwd, &start)).await else { return };
|
||||
/// Records the files that changed in the checkout since `start`, as the turn ends, as the task's.
|
||||
async fn record_turn_changes(&self, start: Option<Snapshot>) {
|
||||
let Some(start) = start else { return };
|
||||
let cwd = self.state.lock().task.cwd.0.clone();
|
||||
let Ok(end) = blocking(move || worktree::snapshot(&cwd)).await else { return };
|
||||
let changed = worktree::changed_between(&start, &end);
|
||||
if changed.is_empty() {
|
||||
return;
|
||||
}
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if !in_worktree.is_empty()
|
||||
&& let Some(touched) = &s.touched
|
||||
{
|
||||
let mut touched = (**touched).clone();
|
||||
touched.extend(in_worktree);
|
||||
s.touched = Some(Arc::new(touched));
|
||||
}
|
||||
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(all), ..(*turn).clone() }));
|
||||
let Some(touched) = &s.touched else { return };
|
||||
let mut touched = (**touched).clone();
|
||||
touched.extend(changed);
|
||||
s.touched = Some(Arc::new(touched));
|
||||
}
|
||||
self.persist();
|
||||
}
|
||||
@@ -1972,7 +1772,7 @@ impl Task {
|
||||
}
|
||||
|
||||
fn emit_task(&self) {
|
||||
let task = self.state.lock().snapshot();
|
||||
let task = self.state.lock().task.clone();
|
||||
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
|
||||
}
|
||||
|
||||
@@ -2069,11 +1869,9 @@ impl Task {
|
||||
session_id: s.session_id.clone(),
|
||||
entries: s.conversation.main.entries.clone(),
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: s.pending_model.clone(),
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
turn: s.turn.as_deref().cloned(),
|
||||
subagents: s.conversation.saved_subagents(),
|
||||
pending_rollback: s.pending_rollback,
|
||||
title_renamed: s.title_renamed,
|
||||
@@ -2125,11 +1923,11 @@ impl Task {
|
||||
/// the user stops one. The caller set `busy`.
|
||||
async fn run(self: Arc<Self>, mut prompt: AgentPrompt) {
|
||||
loop {
|
||||
self.checkout_before_turn().await;
|
||||
let start = self.checkout_before_turn().await;
|
||||
let result = self.turn(&prompt).await;
|
||||
self.cancel_pending.store(false, Ordering::Release);
|
||||
tokio::time::sleep(TURN_GRACE).await;
|
||||
self.record_turn_changes().await;
|
||||
self.record_turn_changes(start).await;
|
||||
let changed = self.state.lock().conversation.end_turn(Some(now_ms()));
|
||||
self.mark_dirty(changed);
|
||||
let send_now = self.send_now.swap(false, Ordering::AcqRel);
|
||||
@@ -2175,7 +1973,7 @@ impl Task {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drops an idle resumable live session so the next turn reloads it.
|
||||
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
|
||||
fn recycle_resumable_session(&self) {
|
||||
self.mcp_reload_pending.store(false, Ordering::Release);
|
||||
let live = {
|
||||
@@ -2183,110 +1981,12 @@ impl Task {
|
||||
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
|
||||
};
|
||||
if let Some(live) = live {
|
||||
tracing::debug!("agent task {}: recycling idle resumable session", self.id);
|
||||
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
|
||||
live.peer.kill();
|
||||
self.clear_shown_background();
|
||||
}
|
||||
}
|
||||
|
||||
async fn switch_discovered_model(&self, target: AgentConfigOption, value: String) -> IdeResult<()> {
|
||||
let provider = self.state.lock().task.provider.clone();
|
||||
let spec = self.shared.spec(&provider).ok_or_else(|| IdeError::not_found("no such agent"))?;
|
||||
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
|
||||
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
|
||||
})?;
|
||||
let model_choice = {
|
||||
let mut s = self.state.lock();
|
||||
s.model_choice += 1;
|
||||
s.model_choice
|
||||
};
|
||||
// A prompt starting during the switch must not grab the peer we're about to recycle.
|
||||
let _connecting = self.connecting.lock().await;
|
||||
{
|
||||
let s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
}
|
||||
let live = self.live.lock().clone();
|
||||
let result = if let Some(live) = live.as_ref().filter(|l| !l.peer.is_closed()) {
|
||||
let (method, mut params) = config::set_request(&target, &value);
|
||||
params["sessionId"] = json!(live.session);
|
||||
match live.peer.request::<_, Value>(method, params, None).await {
|
||||
Ok(reply) if config::accepts_model(&reply, &target.id, &value) => Ok(Some(reply)),
|
||||
Ok(_) => Err(format!("The agent did not switch to model {value}.")),
|
||||
Err(e) => Err(self.describe(e)),
|
||||
}
|
||||
} else {
|
||||
Ok(None)
|
||||
};
|
||||
|
||||
let accepted = {
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
let pending = match result {
|
||||
Ok(Some(reply)) => {
|
||||
if let Some(options) = reply.get("configOptions") {
|
||||
config::merge_update(&mut s.task.config, options);
|
||||
} else if s.task.model.as_deref() != Some(value.as_str()) {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
let model =
|
||||
if let Some(i) = s.task.config.iter().position(|o| o.category.as_deref() == Some("model")) {
|
||||
&mut s.task.config[i]
|
||||
} else {
|
||||
s.task.config.push(target.clone());
|
||||
s.task.config.last_mut().unwrap()
|
||||
};
|
||||
if !model.values.iter().any(|v| v.value == value) {
|
||||
model.values.push(candidate);
|
||||
}
|
||||
model.current = Some(value.clone());
|
||||
s.task.model = Some(value.clone());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
false
|
||||
}
|
||||
refused => {
|
||||
if s.session_id.is_none()
|
||||
|| live.as_ref().is_some_and(|l| !l.resumable)
|
||||
|| self.start_fresh.load(Ordering::Acquire)
|
||||
{
|
||||
return Err(IdeError::unavailable(
|
||||
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
|
||||
));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
true
|
||||
}
|
||||
};
|
||||
s.wanted.retain(|c| c.id != target.id);
|
||||
s.pending_model = pending.then(|| target.id.clone());
|
||||
s.wanted.push(AgentConfigChoice { id: target.id, value });
|
||||
(!pending).then(|| {
|
||||
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
|
||||
(s.task.config.clone(), model)
|
||||
})
|
||||
};
|
||||
if let Some((config, model)) = accepted {
|
||||
self.shared.remember(&provider, Some(&config), None, model.as_deref());
|
||||
} else {
|
||||
self.recycle_resumable_session();
|
||||
}
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
|
||||
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
|
||||
/// reloads its session: the next message starts it again with the conversation intact.
|
||||
@@ -2534,12 +2234,10 @@ impl Task {
|
||||
{
|
||||
return Ok(live);
|
||||
}
|
||||
let (provider_id, cwd, saved, pending) = {
|
||||
let (provider_id, cwd, saved) = {
|
||||
let s = self.state.lock();
|
||||
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
|
||||
};
|
||||
let pending_model = pending.as_ref().map(|(choice, _)| choice);
|
||||
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let can_fallback =
|
||||
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
|
||||
@@ -2548,8 +2246,8 @@ impl Task {
|
||||
} else {
|
||||
raw_spec.clone()
|
||||
};
|
||||
let opened = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone(), pending_model).await {
|
||||
Ok(live) => Ok(live),
|
||||
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
|
||||
Ok(live) => live,
|
||||
Err(err) if can_fallback && err.allow_acp_fallback => {
|
||||
tracing::warn!(
|
||||
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
|
||||
@@ -2558,32 +2256,9 @@ impl Task {
|
||||
);
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
|
||||
self.open_session(&provider_id, acp_spec, &cwd, saved, pending_model).await
|
||||
}
|
||||
Err(err) => Err(err),
|
||||
};
|
||||
let live = match opened {
|
||||
Ok(live) => live,
|
||||
Err(err) => {
|
||||
if let Some((choice, previous)) = pending {
|
||||
let mut s = self.state.lock();
|
||||
if s.pending_model() == Some(&choice) {
|
||||
s.pending_model = None;
|
||||
s.wanted.retain(|c| c.id != choice.id);
|
||||
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
|
||||
model.current.clone_from(&previous);
|
||||
}
|
||||
s.task.model.clone_from(&previous);
|
||||
if let Some(value) = previous {
|
||||
s.wanted.push(AgentConfigChoice { id: choice.id, value });
|
||||
}
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
return Err(err.message);
|
||||
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
|
||||
}
|
||||
Err(err) => return Err(err.message),
|
||||
};
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
@@ -2595,7 +2270,6 @@ impl Task {
|
||||
spec: provider::ProviderSpec,
|
||||
cwd: &Path,
|
||||
saved: Option<String>,
|
||||
pending_model: Option<&AgentConfigChoice>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
@@ -2644,14 +2318,7 @@ impl Task {
|
||||
|
||||
let mut tried_auth = false;
|
||||
let mut session = None;
|
||||
let start_fresh = self.start_fresh.load(Ordering::Acquire);
|
||||
if pending_model.is_some() && (saved.is_none() || !can_load || start_fresh) {
|
||||
return Err(SessionOpenError {
|
||||
message: "The agent does not support resuming this session.".into(),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
|
||||
if let (Some(id), true) = (saved, can_load) {
|
||||
self.replaying.store(true, Ordering::Release);
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
params["sessionId"] = json!(&id);
|
||||
@@ -2660,33 +2327,7 @@ impl Task {
|
||||
self.replaying.store(false, Ordering::Release);
|
||||
match loaded {
|
||||
Ok(v) => session = Some((id, v)),
|
||||
// Not silently: a new session would lose the conversation and replace the saved id.
|
||||
Err(e) => {
|
||||
tracing::info!("agent task {}: session/load failed: {e}", self.id);
|
||||
if let Some(message) = self.sign_in_error(&e, Some(&sign_in_message)) {
|
||||
return Err(SessionOpenError { message, allow_acp_fallback: false });
|
||||
}
|
||||
if pending_model.is_some() {
|
||||
return Err(SessionOpenError {
|
||||
message: format!(
|
||||
"Couldn't reopen this conversation's {} session: {}",
|
||||
spec.name,
|
||||
self.describe(e)
|
||||
),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
self.start_fresh.store(true, Ordering::Release);
|
||||
return Err(SessionOpenError {
|
||||
message: format!(
|
||||
"Couldn't reopen this conversation's {} session: {}\n\nSend the message again to \
|
||||
continue in a new session. The agent won't see the earlier conversation.",
|
||||
spec.name,
|
||||
self.describe(e)
|
||||
),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
Err(e) => tracing::info!("agent task {}: session/load failed, starting a new session: {e}", self.id),
|
||||
}
|
||||
}
|
||||
let resumed = session.is_some();
|
||||
@@ -2747,19 +2388,6 @@ impl Task {
|
||||
});
|
||||
let mut model_options = known;
|
||||
for choice in &wanted {
|
||||
let pending = pending_model == Some(choice);
|
||||
if pending
|
||||
&& !options.iter().any(|o| {
|
||||
o.id == choice.id
|
||||
&& (o.values.iter().any(|v| v.value == choice.value)
|
||||
|| (known && o.current.as_deref() == Some(choice.value.as_str())))
|
||||
})
|
||||
{
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The reloaded session does not offer model {}.", choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
|
||||
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
|
||||
if o.id == config::CURSOR_APPROVAL {
|
||||
@@ -2780,12 +2408,6 @@ impl Task {
|
||||
params["sessionId"] = json!(session_id);
|
||||
match peer.request::<_, Value>(method, params, None).await {
|
||||
Ok(reply) => {
|
||||
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The reloaded session did not switch to model {}.", choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if let Some(fresh) = reply.get("configOptions") {
|
||||
config::merge_update(&mut options, fresh);
|
||||
model_options = true;
|
||||
@@ -2799,9 +2421,6 @@ impl Task {
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
}
|
||||
Err(e) if pending => {
|
||||
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
|
||||
}
|
||||
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
|
||||
}
|
||||
}
|
||||
@@ -2811,10 +2430,8 @@ impl Task {
|
||||
let mut s = self.state.lock();
|
||||
s.task.model = model_of(&options).or(s.task.model.take());
|
||||
s.task.config = options;
|
||||
s.pending_model = None;
|
||||
s.task.capabilities = capabilities;
|
||||
s.session_id = Some(session_id.clone());
|
||||
self.start_fresh.store(false, Ordering::Release);
|
||||
// The (re)started process runs nothing yet: whatever it reports next is all of it.
|
||||
s.background_tasks = Vec::new();
|
||||
s.task.background.clear();
|
||||
@@ -3038,7 +2655,7 @@ impl Task {
|
||||
let applied = self.state.lock().conversation.apply(session, update, now_ms());
|
||||
self.mark_dirty(applied);
|
||||
// A subagent can start or finish after the turn that started it: saved right away.
|
||||
if matches!(kind, "subagent_update" | "user_question") {
|
||||
if kind == "subagent_update" {
|
||||
self.persist();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -399,429 +399,163 @@ pub fn apply_save_json(
|
||||
Ok(saved_names)
|
||||
}
|
||||
|
||||
const COPILOT_PLUGIN_MANIFESTS: &[&str] = &[
|
||||
".github/plugin/plugin.json",
|
||||
".plugin/plugin.json",
|
||||
".claude-plugin/plugin.json",
|
||||
".cursor-plugin/plugin.json",
|
||||
"plugin.json",
|
||||
];
|
||||
|
||||
#[derive(Clone, PartialEq, Eq)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum SourceFormat {
|
||||
Jsonc,
|
||||
CodexToml,
|
||||
CopilotPlugin { root: PathBuf },
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct SourceSpec {
|
||||
id: String,
|
||||
label: String,
|
||||
id: &'static str,
|
||||
label: &'static str,
|
||||
path: PathBuf,
|
||||
format: SourceFormat,
|
||||
suggested_scope: McpScope,
|
||||
native_provider: Option<&'static str>,
|
||||
claude_project_lookup: bool,
|
||||
disabled_servers: std::sync::Arc<BTreeSet<String>>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct CopilotSettings {
|
||||
disabled_mcp_servers: std::sync::Arc<BTreeSet<String>>,
|
||||
disabled_plugins: BTreeSet<String>,
|
||||
}
|
||||
|
||||
fn external_source_specs(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<SourceSpec> {
|
||||
let mut specs = Vec::new();
|
||||
let no_disabled: std::sync::Arc<BTreeSet<String>> = std::sync::Arc::new(BTreeSet::new());
|
||||
if let Some(root) = workspace_root {
|
||||
specs.push(SourceSpec {
|
||||
id: "workspace-mcp".into(),
|
||||
label: "Project (.mcp.json)".into(),
|
||||
id: "workspace-mcp",
|
||||
label: "Project (.mcp.json)",
|
||||
path: root.join(".mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("claude"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "vscode-mcp".into(),
|
||||
label: "VS Code (.vscode/mcp.json)".into(),
|
||||
id: "vscode-mcp",
|
||||
label: "VS Code (.vscode/mcp.json)",
|
||||
path: root.join(".vscode").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "cursor-project".into(),
|
||||
label: "Cursor Project (.cursor/mcp.json)".into(),
|
||||
id: "cursor-project",
|
||||
label: "Cursor Project (.cursor/mcp.json)",
|
||||
path: root.join(".cursor").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("cursor"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "codex-project".into(),
|
||||
label: "Codex Project (.codex/config.toml)".into(),
|
||||
id: "codex-project",
|
||||
label: "Codex Project (.codex/config.toml)",
|
||||
path: root.join(".codex").join("config.toml"),
|
||||
format: SourceFormat::CodexToml,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("codex"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "gemini-project".into(),
|
||||
label: "Gemini Project (.gemini/settings.json)".into(),
|
||||
id: "gemini-project",
|
||||
label: "Gemini Project (.gemini/settings.json)",
|
||||
path: root.join(".gemini").join("settings.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("gemini"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
}
|
||||
if let Some(home) = home_dir {
|
||||
let copilot_dir = home.join(".copilot");
|
||||
let copilot_settings = read_copilot_settings(&copilot_dir);
|
||||
specs.push(SourceSpec {
|
||||
id: "copilot-cli".into(),
|
||||
label: "GitHub Copilot CLI".into(),
|
||||
path: copilot_dir.join("mcp-config.json"),
|
||||
id: "copilot-cli",
|
||||
label: "GitHub Copilot CLI",
|
||||
path: home.join(".copilot").join("mcp-config.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("copilot"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: copilot_settings.disabled_mcp_servers.clone(),
|
||||
});
|
||||
specs.extend(copilot_plugin_source_specs(&copilot_dir, &copilot_settings));
|
||||
specs.push(SourceSpec {
|
||||
id: "claude-code".into(),
|
||||
label: "Claude Code".into(),
|
||||
id: "claude-code",
|
||||
label: "Claude Code",
|
||||
path: home.join(".claude.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("claude"),
|
||||
claude_project_lookup: true,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "codex".into(),
|
||||
label: "Codex".into(),
|
||||
id: "codex",
|
||||
label: "Codex",
|
||||
path: home.join(".codex").join("config.toml"),
|
||||
format: SourceFormat::CodexToml,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("codex"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "cursor".into(),
|
||||
label: "Cursor".into(),
|
||||
id: "cursor",
|
||||
label: "Cursor",
|
||||
path: home.join(".cursor").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("cursor"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "gemini".into(),
|
||||
label: "Gemini CLI".into(),
|
||||
id: "gemini",
|
||||
label: "Gemini CLI",
|
||||
path: home.join(".gemini").join("settings.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("gemini"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "jetbrains-air".into(),
|
||||
label: "JetBrains Air".into(),
|
||||
id: "jetbrains-air",
|
||||
label: "JetBrains Air",
|
||||
path: home.join(".jetbrains").join("mcp").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "copilot-intellij".into(),
|
||||
label: "GitHub Copilot (JetBrains)".into(),
|
||||
id: "copilot-intellij",
|
||||
label: "GitHub Copilot (JetBrains)",
|
||||
path: home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled,
|
||||
});
|
||||
}
|
||||
specs
|
||||
}
|
||||
|
||||
fn read_copilot_settings(copilot_dir: &Path) -> CopilotSettings {
|
||||
let Ok(text) = std::fs::read_to_string(copilot_dir.join("settings.json")) else {
|
||||
return CopilotSettings::default();
|
||||
};
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return CopilotSettings::default();
|
||||
};
|
||||
let disabled_mcp_servers = root
|
||||
.get("disabledMcpServers")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned))
|
||||
.collect::<BTreeSet<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let disabled_plugins = root
|
||||
.get("enabledPlugins")
|
||||
.and_then(Value::as_object)
|
||||
.map(|obj| {
|
||||
obj.iter()
|
||||
.filter(|(_, v)| v.as_bool() == Some(false))
|
||||
.map(|(k, _)| k.trim().to_owned())
|
||||
.filter(|k| !k.is_empty())
|
||||
.collect::<BTreeSet<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
CopilotSettings { disabled_mcp_servers: std::sync::Arc::new(disabled_mcp_servers), disabled_plugins }
|
||||
}
|
||||
|
||||
fn copilot_plugin_source_specs(copilot_dir: &Path, settings: &CopilotSettings) -> Vec<SourceSpec> {
|
||||
let Ok(text) = std::fs::read_to_string(copilot_dir.join("config.json")) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let Some(installed) = root.get("installedPlugins").and_then(Value::as_array) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let mut seen_ids = HashSet::new();
|
||||
let mut specs = Vec::new();
|
||||
for entry in installed {
|
||||
let Some(obj) = entry.as_object() else { continue };
|
||||
if obj.get("enabled").and_then(Value::as_bool) == Some(false) {
|
||||
continue;
|
||||
}
|
||||
let Some(name) = obj.get("name").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()) else {
|
||||
continue;
|
||||
};
|
||||
let marketplace = obj.get("marketplace").and_then(Value::as_str).map(str::trim).unwrap_or_default();
|
||||
if settings.disabled_plugins.contains(name)
|
||||
|| (!marketplace.is_empty()
|
||||
&& (settings.disabled_plugins.contains(&format!("{name}@{marketplace}"))
|
||||
|| settings.disabled_plugins.contains(&format!("{marketplace}/{name}"))))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let Some(raw_cache) = obj.get("cache_path").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let plugin_root =
|
||||
if Path::new(raw_cache).is_relative() { copilot_dir.join(raw_cache) } else { PathBuf::from(raw_cache) };
|
||||
if !plugin_root.is_dir() {
|
||||
continue;
|
||||
}
|
||||
let Some((manifest_path, _)) = read_copilot_plugin_servers(&plugin_root) else {
|
||||
continue;
|
||||
};
|
||||
let base_id = if marketplace.is_empty() {
|
||||
format!("copilot-plugin:{name}")
|
||||
} else {
|
||||
format!("copilot-plugin:{marketplace}/{name}")
|
||||
};
|
||||
let mut id = base_id.clone();
|
||||
let mut suffix = 2usize;
|
||||
while !seen_ids.insert(id.clone()) {
|
||||
id = format!("{base_id}#{suffix}");
|
||||
suffix += 1;
|
||||
}
|
||||
let label = if marketplace.is_empty() {
|
||||
format!("GitHub Copilot Plugin ({name})")
|
||||
} else {
|
||||
format!("GitHub Copilot Plugin ({name} · {marketplace})")
|
||||
};
|
||||
specs.push(SourceSpec {
|
||||
id,
|
||||
label,
|
||||
path: manifest_path,
|
||||
format: SourceFormat::CopilotPlugin { root: plugin_root },
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("copilot"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: settings.disabled_mcp_servers.clone(),
|
||||
});
|
||||
}
|
||||
specs
|
||||
}
|
||||
|
||||
fn resolve_within_dir(base_dir: &Path, candidate: &Path) -> Option<PathBuf> {
|
||||
if candidate.as_os_str().is_empty() {
|
||||
return None;
|
||||
}
|
||||
let base_canon = dunce::canonicalize(base_dir).ok()?;
|
||||
let clean = candidate.strip_prefix(".").unwrap_or(candidate);
|
||||
let joined = if clean.is_relative() { base_dir.join(clean) } else { clean.to_path_buf() };
|
||||
let meta = std::fs::metadata(&joined).ok()?;
|
||||
if !meta.is_file() {
|
||||
return None;
|
||||
}
|
||||
let target_canon = dunce::canonicalize(&joined).ok()?;
|
||||
target_canon.starts_with(&base_canon).then_some(joined)
|
||||
}
|
||||
|
||||
fn expand_plugin_root_vars(value: &str, root: &str) -> String {
|
||||
value.replace("${COPILOT_PLUGIN_ROOT}", root).replace("${CLAUDE_PLUGIN_ROOT}", root).replace("${PLUGIN_ROOT}", root)
|
||||
}
|
||||
|
||||
fn expand_plugin_servers(servers: &mut BTreeMap<String, AgentMcpServer>, plugin_root: &Path) {
|
||||
let root = plugin_root.to_string_lossy();
|
||||
for srv in servers.values_mut() {
|
||||
if let Some(cmd) = srv.command.as_mut() {
|
||||
*cmd = expand_plugin_root_vars(cmd, &root);
|
||||
}
|
||||
for arg in &mut srv.args {
|
||||
*arg = expand_plugin_root_vars(arg, &root);
|
||||
}
|
||||
if let Some(url) = srv.url.as_mut() {
|
||||
*url = expand_plugin_root_vars(url, &root);
|
||||
}
|
||||
for val in srv.env.values_mut() {
|
||||
*val = expand_plugin_root_vars(val, &root);
|
||||
}
|
||||
for val in srv.headers.values_mut() {
|
||||
*val = expand_plugin_root_vars(val, &root);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_plugin_manifest_servers(
|
||||
plugin_root: &Path,
|
||||
manifest_path: &Path,
|
||||
mcp_val: &Value,
|
||||
) -> (PathBuf, BTreeMap<String, AgentMcpServer>) {
|
||||
match mcp_val {
|
||||
Value::String(rel) => {
|
||||
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
|
||||
let map = read_external_file(&path);
|
||||
return (path, map);
|
||||
}
|
||||
(manifest_path.to_path_buf(), BTreeMap::new())
|
||||
}
|
||||
Value::Object(_) => {
|
||||
let wrapper = json!({ "mcpServers": mcp_val });
|
||||
(manifest_path.to_path_buf(), extract_servers_from_root(&wrapper, None))
|
||||
}
|
||||
Value::Array(items) => {
|
||||
let mut merged = BTreeMap::new();
|
||||
let mut first_path: Option<PathBuf> = None;
|
||||
for item in items {
|
||||
match item {
|
||||
Value::String(rel) => {
|
||||
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
|
||||
let map = read_external_file(&path);
|
||||
if !map.is_empty() && first_path.is_none() {
|
||||
first_path = Some(path);
|
||||
}
|
||||
merged.extend(map);
|
||||
}
|
||||
}
|
||||
Value::Object(_) => {
|
||||
let map = extract_servers_from_root(item, None);
|
||||
if !map.is_empty() && first_path.is_none() {
|
||||
first_path = Some(manifest_path.to_path_buf());
|
||||
}
|
||||
merged.extend(map);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
(first_path.unwrap_or_else(|| manifest_path.to_path_buf()), merged)
|
||||
}
|
||||
_ => (manifest_path.to_path_buf(), BTreeMap::new()),
|
||||
}
|
||||
}
|
||||
|
||||
fn read_copilot_plugin_servers(plugin_root: &Path) -> Option<(PathBuf, BTreeMap<String, AgentMcpServer>)> {
|
||||
if let Some(dot_mcp) = resolve_within_dir(plugin_root, Path::new(".mcp.json")) {
|
||||
let mut servers = read_external_file(&dot_mcp);
|
||||
if !servers.is_empty() {
|
||||
expand_plugin_servers(&mut servers, plugin_root);
|
||||
return Some((dot_mcp, servers));
|
||||
}
|
||||
}
|
||||
for rel in COPILOT_PLUGIN_MANIFESTS {
|
||||
let Some(manifest_path) = resolve_within_dir(plugin_root, Path::new(rel)) else {
|
||||
continue;
|
||||
};
|
||||
let Ok(text) = std::fs::read_to_string(&manifest_path) else {
|
||||
continue;
|
||||
};
|
||||
let Ok(manifest) = parse_jsonc_value(&text) else {
|
||||
continue;
|
||||
};
|
||||
let Some(mcp_val) = manifest.get("mcpServers") else {
|
||||
continue;
|
||||
};
|
||||
let (source_path, mut servers) = extract_plugin_manifest_servers(plugin_root, &manifest_path, mcp_val);
|
||||
if !servers.is_empty() {
|
||||
expand_plugin_servers(&mut servers, plugin_root);
|
||||
return Some((source_path, servers));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
|
||||
let mut servers = match &spec.format {
|
||||
SourceFormat::CopilotPlugin { root } => {
|
||||
read_copilot_plugin_servers(root).map(|(_, map)| map).unwrap_or_default()
|
||||
}
|
||||
SourceFormat::CodexToml => {
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
parse_codex_toml_servers(&text)
|
||||
}
|
||||
SourceFormat::Jsonc => {
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let mut map = extract_servers_from_root(&root, None);
|
||||
if spec.claude_project_lookup
|
||||
&& let Some(ws) = workspace_root
|
||||
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
|
||||
{
|
||||
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
|
||||
for (proj_key, proj_val) in projects {
|
||||
let matches =
|
||||
Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
|
||||
if matches {
|
||||
for (name, srv) in extract_servers_from_root(proj_val, None) {
|
||||
map.insert(name, srv);
|
||||
}
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
if spec.format == SourceFormat::CodexToml {
|
||||
return parse_codex_toml_servers(&text);
|
||||
}
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let mut servers = extract_servers_from_root(&root, None);
|
||||
if spec.claude_project_lookup
|
||||
&& let Some(ws) = workspace_root
|
||||
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
|
||||
{
|
||||
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
|
||||
for (proj_key, proj_val) in projects {
|
||||
let matches = Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
|
||||
if matches {
|
||||
for (name, srv) in extract_servers_from_root(proj_val, None) {
|
||||
servers.insert(name, srv);
|
||||
}
|
||||
}
|
||||
map
|
||||
}
|
||||
};
|
||||
for name in spec.disabled_servers.iter() {
|
||||
if let Some(srv) = servers.get_mut(name) {
|
||||
srv.enabled = false;
|
||||
}
|
||||
}
|
||||
servers
|
||||
@@ -878,8 +612,8 @@ pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option
|
||||
})
|
||||
.collect();
|
||||
out.push(McpExternalSource {
|
||||
id: spec.id,
|
||||
label: spec.label,
|
||||
id: spec.id.to_owned(),
|
||||
label: spec.label.to_owned(),
|
||||
path: IpcPath(spec.path),
|
||||
suggested_scope: spec.suggested_scope,
|
||||
native_provider: spec.native_provider.map(str::to_owned),
|
||||
@@ -907,7 +641,7 @@ pub fn apply_import_selected(
|
||||
let mut by_source: BTreeMap<&str, BTreeMap<String, AgentMcpServer>> = BTreeMap::new();
|
||||
for spec in &specs {
|
||||
if selections.iter().any(|s| s.source_id == spec.id) {
|
||||
by_source.insert(spec.id.as_str(), read_source_servers(spec, workspace_root));
|
||||
by_source.insert(spec.id, read_source_servers(spec, workspace_root));
|
||||
}
|
||||
}
|
||||
let target = match scope {
|
||||
@@ -1636,125 +1370,4 @@ mod tests {
|
||||
assert_eq!(workspace["events-sse"].transport, McpTransport::Sse);
|
||||
assert_eq!(workspace["events-sse"].url.as_deref(), Some("https://sse.example.com/events"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn discovers_and_imports_copilot_installed_plugin_mcp_servers() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let home = tmp.path().join("home");
|
||||
let copilot = home.join(".copilot");
|
||||
let azure_root = copilot.join("installed-plugins/_direct/azure-skills");
|
||||
let inline_root = copilot.join("installed-plugins/awesome-copilot/inline-tools");
|
||||
let disabled_root = copilot.join("installed-plugins/_direct/disabled-plug");
|
||||
let outside_root = tmp.path().join("outside");
|
||||
|
||||
std::fs::create_dir_all(azure_root.join(".plugin")).unwrap();
|
||||
std::fs::create_dir_all(inline_root.join(".claude-plugin")).unwrap();
|
||||
std::fs::create_dir_all(&disabled_root).unwrap();
|
||||
std::fs::create_dir_all(&outside_root).unwrap();
|
||||
|
||||
std::fs::write(
|
||||
azure_root.join(".plugin/plugin.json"),
|
||||
r#"{"name":"azure","version":"1.2.106","mcpServers":"./.mcp.json"}"#,
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(
|
||||
azure_root.join(".mcp.json"),
|
||||
r#"{"mcpServers":{"azure":{"command":"npx","args":["-y","@azure/mcp@latest","${COPILOT_PLUGIN_ROOT}/cfg"],"env":{"PLUG_DIR":"${CLAUDE_PLUGIN_ROOT}"}}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
std::fs::write(
|
||||
inline_root.join(".claude-plugin/plugin.json"),
|
||||
r#"{"name":"inline-tools","version":"0.1.0","mcpServers":{"inline-srv":{"command":"${PLUGIN_ROOT}/bin/run","args":["--stdio"]},"muted-srv":{"command":"echo","args":["off"]}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
std::fs::write(
|
||||
disabled_root.join(".mcp.json"),
|
||||
r#"{"mcpServers":{"never":{"command":"npx","args":["never"]}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
std::fs::write(outside_root.join("secret.json"), r#"{"mcpServers":{"escaped":{"command":"sh"}}}"#).unwrap();
|
||||
let escape_root = copilot.join("installed-plugins/_direct/escape-plug");
|
||||
std::fs::create_dir_all(escape_root.join(".plugin")).unwrap();
|
||||
std::fs::write(
|
||||
escape_root.join(".plugin/plugin.json"),
|
||||
r#"{"name":"escape-plug","mcpServers":"../../../../outside/secret.json"}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// `~/.copilot/config.json` includes leading `//` comments in Copilot CLI.
|
||||
let config_json = format!(
|
||||
"// Managed automatically.\n{}",
|
||||
serde_json::json!({
|
||||
"installedPlugins": [
|
||||
{
|
||||
"name": "azure",
|
||||
"marketplace": "",
|
||||
"enabled": true,
|
||||
"cache_path": azure_root,
|
||||
},
|
||||
{
|
||||
"name": "inline-tools",
|
||||
"marketplace": "awesome-copilot",
|
||||
"enabled": true,
|
||||
"cache_path": inline_root,
|
||||
},
|
||||
{
|
||||
"name": "disabled-plug",
|
||||
"marketplace": "",
|
||||
"enabled": false,
|
||||
"cache_path": disabled_root,
|
||||
},
|
||||
{
|
||||
"name": "escape-plug",
|
||||
"marketplace": "",
|
||||
"enabled": true,
|
||||
"cache_path": escape_root,
|
||||
}
|
||||
]
|
||||
})
|
||||
);
|
||||
std::fs::write(copilot.join("config.json"), config_json).unwrap();
|
||||
std::fs::write(copilot.join("settings.json"), r#"{"disabledMcpServers":["muted-srv"]}"#).unwrap();
|
||||
|
||||
let sources = discover_external_sources(Some(&home), None);
|
||||
assert_eq!(sources.len(), 2);
|
||||
|
||||
let azure_src = sources.iter().find(|s| s.id == "copilot-plugin:azure").unwrap();
|
||||
assert_eq!(azure_src.label, "GitHub Copilot Plugin (azure)");
|
||||
assert_eq!(azure_src.native_provider.as_deref(), Some("copilot"));
|
||||
assert_eq!(azure_src.path.0, azure_root.join(".mcp.json"));
|
||||
assert_eq!(azure_src.servers.len(), 1);
|
||||
assert!(azure_src.servers[0].enabled);
|
||||
assert_eq!(
|
||||
azure_src.servers[0].args,
|
||||
vec!["-y", "@azure/mcp@latest", &format!("{}/cfg", azure_root.display())]
|
||||
);
|
||||
|
||||
let inline_src = sources.iter().find(|s| s.id == "copilot-plugin:awesome-copilot/inline-tools").unwrap();
|
||||
assert_eq!(inline_src.label, "GitHub Copilot Plugin (inline-tools · awesome-copilot)");
|
||||
assert_eq!(inline_src.path.0, inline_root.join(".claude-plugin/plugin.json"));
|
||||
let active = inline_src.servers.iter().find(|s| s.name == "inline-srv").unwrap();
|
||||
assert!(active.enabled);
|
||||
assert_eq!(active.command.as_deref(), Some(format!("{}/bin/run", inline_root.display()).as_str()));
|
||||
let muted = inline_src.servers.iter().find(|s| s.name == "muted-srv").unwrap();
|
||||
assert!(!muted.enabled);
|
||||
|
||||
let mut user = BTreeMap::new();
|
||||
let mut workspace = BTreeMap::new();
|
||||
let imported = apply_import_selected(
|
||||
&mut user,
|
||||
&mut workspace,
|
||||
Some(&home),
|
||||
None,
|
||||
McpScope::User,
|
||||
&[McpImportSelection { source_id: "copilot-plugin:azure".into(), name: "azure".into() }],
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(imported, vec!["azure".to_string()]);
|
||||
assert_eq!(user["azure"].env.get("PLUG_DIR").map(String::as_str), Some(azure_root.to_str().unwrap()));
|
||||
}
|
||||
}
|
||||
@@ -469,14 +469,6 @@ pub enum AgentEntry {
|
||||
Agent {
|
||||
text: String,
|
||||
},
|
||||
/// A question that can be answered while the agent keeps working, or after the turn ends.
|
||||
Question {
|
||||
id: String,
|
||||
title: String,
|
||||
questions: Vec<AgentQuestion>,
|
||||
/// The submitted answers, or `Skipped`; `None` while unanswered.
|
||||
chosen: Option<String>,
|
||||
},
|
||||
Thought {
|
||||
text: String,
|
||||
},
|
||||
@@ -672,8 +664,6 @@ pub enum AgentChangesView {
|
||||
SinceStart,
|
||||
/// The uncommitted files against `HEAD`; commits made since the start stay.
|
||||
Group,
|
||||
/// What the last turn changed, against the checkout as that turn started.
|
||||
LastTurn,
|
||||
}
|
||||
|
||||
/// A task's uncommitted files and the commits made since it started.
|
||||
|
||||
@@ -1028,11 +1028,6 @@ impl CodexShim {
|
||||
}
|
||||
Some(t.chunk(kind, &id, &text))
|
||||
});
|
||||
if ty == "agentMessage"
|
||||
&& let Some(update) = translate::question_update(item)
|
||||
{
|
||||
self.emit(thread, update);
|
||||
}
|
||||
}
|
||||
"subAgentActivity" => {
|
||||
let child = item.get("agentThreadId").and_then(Value::as_str).unwrap_or_default();
|
||||
|
||||
@@ -473,56 +473,6 @@ fn history_replays_turns() {
|
||||
assert_eq!(updates[4]["status"], "completed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_preserves_async_questions_with_stable_answer_ids() {
|
||||
let updates = history(
|
||||
&json!({"turns": [{"items": [{
|
||||
"type": "agentMessage", "id": "call-1", "text": "Which?",
|
||||
"questions": [{"title": "Which?", "options": ["One", "Two"]}, {"title": "Why?"}]
|
||||
}]}]}),
|
||||
None,
|
||||
);
|
||||
let asked = updates.iter().find(|u| u["sessionUpdate"] == "user_question").expect("question update");
|
||||
assert_eq!(asked["id"], "call-1");
|
||||
assert_eq!(asked["questions"][0]["answerKey"], r#"["request_user_input_async","call-1",0]"#);
|
||||
assert_eq!(asked["questions"][0]["options"][1]["label"], "Two");
|
||||
assert_eq!(asked["questions"][1]["options"], json!([]));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn completing_a_streamed_message_still_delivers_its_async_questions() {
|
||||
let shim = Arc::new(CodexShim {
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
codex: OnceLock::new(),
|
||||
client: OnceLock::new(),
|
||||
state: Mutex::default(),
|
||||
models: tokio::sync::Mutex::new(None),
|
||||
skills: tokio::sync::Mutex::new(()),
|
||||
});
|
||||
shim.state.lock().threads.insert("thread".into(), Thread::default());
|
||||
let client = Arc::new(Client::default());
|
||||
let peer = crate::native::serve(shim.clone(), client.clone());
|
||||
shim.text("thread", &json!({"itemId":"call-1","delta":"Which?"}), "agent_message_chunk", false);
|
||||
shim.item(
|
||||
"thread",
|
||||
&json!({"type":"agentMessage","id":"call-1","text":"Which?",
|
||||
"questions":[{"title":"Which?","options":["One","Two"]}]}),
|
||||
true,
|
||||
);
|
||||
tokio::time::timeout(Duration::from_secs(2), async {
|
||||
while client.of("thread").len() < 2 {
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(client.text("thread", "agent_message_chunk"), "Which?");
|
||||
assert!(client.of("thread").iter().any(|u| u["sessionUpdate"] == "user_question"));
|
||||
assert!(client.asked.lock().is_empty(), "an asynchronous question must not block on a permission response");
|
||||
peer.kill();
|
||||
shim.client.get().unwrap().kill();
|
||||
}
|
||||
|
||||
// ---- Transcripts ---------------------------------------------------------------------
|
||||
|
||||
/// The ACP client: records updates and answers permission requests in order.
|
||||
|
||||
@@ -871,7 +871,6 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
|
||||
if !text.is_empty() {
|
||||
out.push(chunk("agent_message_chunk", text));
|
||||
}
|
||||
out.extend(question_update(item));
|
||||
}
|
||||
Some("reasoning") => {
|
||||
let text = reasoning_text(item);
|
||||
@@ -891,36 +890,6 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
|
||||
out
|
||||
}
|
||||
|
||||
/// Structured async questions accompany a completed message, even when its text streamed already.
|
||||
pub(super) fn question_update(item: &Value) -> Option<Value> {
|
||||
let id = item.get("id")?.as_str().filter(|id| !id.is_empty())?;
|
||||
let questions: Vec<Value> = item
|
||||
.get("questions")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(index, q)| {
|
||||
let title = q.get("title")?.as_str().filter(|title| !title.trim().is_empty())?;
|
||||
let options: Vec<Value> = q
|
||||
.get("options")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(Value::as_str)
|
||||
.filter(|label| !label.trim().is_empty())
|
||||
.map(|label| json!({ "label": label, "description": "" }))
|
||||
.collect();
|
||||
Some(json!({ "answerKey": json!(["request_user_input_async", id, index]).to_string(),
|
||||
"question": title, "header": "", "multiSelect": false, "options": options }))
|
||||
})
|
||||
.collect();
|
||||
if questions.is_empty() {
|
||||
return None;
|
||||
}
|
||||
Some(json!({ "sessionUpdate": "user_question", "id": id,
|
||||
"title": questions[0]["question"], "questions": questions }))
|
||||
}
|
||||
|
||||
/// A reasoning item's summary (or, without one, its raw text).
|
||||
pub(super) fn reasoning_text(item: &Value) -> String {
|
||||
let parts = |k: &str| -> Vec<String> {
|
||||
|
||||
@@ -39,8 +39,6 @@ struct FakeAgent {
|
||||
authenticate_method: Option<String>,
|
||||
authenticated: AtomicBool,
|
||||
request_error: Option<(i64, String)>,
|
||||
/// `session/load` fails with this, as OMP does for a session whose model it can't restore.
|
||||
load_error: Option<(i64, String)>,
|
||||
auth_methods: Vec<Value>,
|
||||
/// Hold the late mode reply until the prompt's permission request is already waiting.
|
||||
hold_late_mode: bool,
|
||||
@@ -214,7 +212,6 @@ impl Handler for FakeAgent {
|
||||
let outcome = if text == "too late" { "promptRequired" } else { "injected" };
|
||||
Ok(json!({"outcome": outcome, "queue": "steering"}))
|
||||
}
|
||||
"session/load" if self.load_error.is_some() => Err(self.load_error.clone().unwrap()),
|
||||
"session/load" => {
|
||||
self.say(&session, "replayed history");
|
||||
Ok(json!({}))
|
||||
@@ -248,10 +245,6 @@ impl Handler for FakeAgent {
|
||||
}
|
||||
"session/prompt" => {
|
||||
let text = params.pointer("/prompt/0/text").and_then(Value::as_str).unwrap_or_default().to_owned();
|
||||
if text.starts_with("<send_user_message_question_reply>") {
|
||||
self.say(&session, "answer received");
|
||||
return Ok(json!({"stopReason": "end_turn"}));
|
||||
}
|
||||
if text == "again" {
|
||||
self.say(&session, "second turn");
|
||||
return Ok(json!({"stopReason": "end_turn"}));
|
||||
@@ -873,7 +866,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
|
||||
["session/load", "authenticate", "authenticate github_oauth", "session/load", "session/prompt"],
|
||||
);
|
||||
|
||||
// If `authenticate` fails during `session/load`, the sign-in error stands: no new session replaces it.
|
||||
// If `authenticate` fails during `session/load`, fallback to `session/new` does not try it again.
|
||||
mgr2.shutdown();
|
||||
let agent3 = Arc::new(FakeAgent {
|
||||
auth_on_load: true,
|
||||
@@ -892,7 +885,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
|
||||
.iter()
|
||||
.filter(|c| c.starts_with("session/") || c.starts_with("authenticate"))
|
||||
.collect::<Vec<_>>(),
|
||||
["session/load", "authenticate"],
|
||||
["session/load", "authenticate", "session/new"],
|
||||
);
|
||||
mgr3.shutdown();
|
||||
}
|
||||
@@ -1157,127 +1150,10 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
|
||||
assert!(calls.contains(&"session/set_mode \"code\"".to_owned()), "{calls:?}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_session_that_fails_to_load_is_reported_and_replaced_only_when_sent_again() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let saved = mgr.task(&task.id).unwrap().state.lock().session_id.clone().expect("a session");
|
||||
mgr.shutdown();
|
||||
|
||||
// OMP: "Could not restore model …" for a session saved with a model it can't restore.
|
||||
let agent = Arc::new(FakeAgent {
|
||||
load_error: Some((codes::INTERNAL_ERROR, "Could not restore model x".into())),
|
||||
..Default::default()
|
||||
});
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
mgr.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
|
||||
let calls = |agent: &FakeAgent| -> Vec<String> {
|
||||
agent.calls.lock().iter().filter(|c| c.starts_with("session/")).cloned().collect()
|
||||
};
|
||||
assert_eq!(calls(&agent), ["session/load"], "no new session behind the user's back");
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
assert_eq!(handle.state.lock().session_id.as_deref(), Some(saved.as_str()));
|
||||
assert!(mgr.entries(&task.id, None).unwrap().iter().any(|e| matches!(e,
|
||||
AgentEntry::Error { message } if message.contains("Could not restore model x") && message.contains("Send the message again"))));
|
||||
|
||||
// Sending again is the user's choice to continue without the earlier conversation.
|
||||
mgr.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
assert_eq!(calls(&agent), ["session/load", "session/new", "session/prompt"]);
|
||||
}
|
||||
|
||||
fn text(t: &str) -> AgentPrompt {
|
||||
AgentPrompt { text: t.into(), ..AgentPrompt::default() }
|
||||
}
|
||||
|
||||
fn asynchronous_question() -> Value {
|
||||
json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
|
||||
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]})
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn async_question_answers_join_the_turn_and_skipping_does_not_cancel_it() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent { session_steering: true, ..Default::default() });
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("wait"),
|
||||
provider: "claude".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Running).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.on_update(Some("s1"), &asynchronous_question());
|
||||
assert!(mgr.answer_question(&task.id, "call-1", Some("{}".into())).await.is_err());
|
||||
handle.live.lock().as_mut().unwrap().capabilities.steer = false;
|
||||
assert!(mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.is_err());
|
||||
assert!(handle.state.lock().task.queue.is_empty());
|
||||
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
|
||||
handle.live.lock().as_mut().unwrap().capabilities.steer = true;
|
||||
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
|
||||
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
|
||||
assert!(
|
||||
agent.calls.lock().iter().any(|call| call.starts_with("_session/steering ") && call.contains("questionItemId"))
|
||||
);
|
||||
assert!(!agent.calls.lock().iter().any(|call| call == "session/cancel"));
|
||||
assert!(mgr.answer_question(&task.id, "call-1", None).await.is_err());
|
||||
let mut question = asynchronous_question();
|
||||
question["id"] = json!("call-2");
|
||||
handle.on_update(Some("s1"), &question);
|
||||
mgr.answer_question(&task.id, "call-2", None).await.unwrap();
|
||||
assert!(
|
||||
matches!(mgr.entries(&task.id, None).unwrap().last(), Some(AgentEntry::Question { chosen: Some(chosen), .. }) if chosen == "Skipped")
|
||||
);
|
||||
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
|
||||
mgr.cancel(&task.id, None).unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn async_questions_can_be_answered_after_the_turn_ends() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.task(&task.id).unwrap().on_update(Some("s1"), &asynchronous_question());
|
||||
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
assert!(
|
||||
mgr.entries(&task.id, None)
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|entry| matches!(entry, AgentEntry::Question { chosen: Some(answer), .. } if answer == "Which?: One"))
|
||||
);
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
assert!(
|
||||
entries.iter().any(|entry| matches!(entry, AgentEntry::User { text, .. } if text.contains("questionItemId")))
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn steers_through_session_steering() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -2852,10 +2728,7 @@ async fn task_project_root_controls_local_and_worktree_repositories() {
|
||||
let changes = mgr.changes(&task.id).await.unwrap();
|
||||
assert_eq!(changes.len(), 1);
|
||||
assert_eq!(changes[0].path.0, task.cwd.0.join("file.txt"));
|
||||
assert_eq!(
|
||||
mgr.base_text(&task.id, changes[0].path.0.clone(), AgentChangesView::SinceStart).await.unwrap().as_deref(),
|
||||
Some("original\n")
|
||||
);
|
||||
assert_eq!(mgr.base_text(&task.id, changes[0].path.0.clone()).await.unwrap().as_deref(), Some("original\n"));
|
||||
let saved = std::fs::read(root.join("store").join(format!("{}.json", task.id))).unwrap();
|
||||
assert!(String::from_utf8(saved).unwrap().contains("projectRoot"));
|
||||
let mut old = serde_json::to_value(&task).unwrap();
|
||||
@@ -3639,178 +3512,6 @@ async fn changed(mgr: &AgentManager, id: &str) -> Vec<String> {
|
||||
mgr.changes(id).await.unwrap().into_iter().map(|c| c.rel_path).collect()
|
||||
}
|
||||
|
||||
/// Waits until the turn asks for permission, runs `work` (what the agent does), then stops it.
|
||||
async fn one_turn(mgr: &AgentManager, id: &str, prompt: Option<&str>, work: impl FnOnce()) {
|
||||
if let Some(prompt) = prompt {
|
||||
mgr.prompt(id, text(prompt), false).await.unwrap();
|
||||
}
|
||||
wait_for(mgr, id, AgentStatus::NeedsInput).await;
|
||||
work();
|
||||
mgr.cancel(id, None).unwrap();
|
||||
wait_for(mgr, id, AgentStatus::Ready).await;
|
||||
}
|
||||
|
||||
async fn turn_changed(mgr: &AgentManager, id: &str) -> Vec<(String, ide_vcs::ChangeKind, u32, u32)> {
|
||||
let changes = mgr.turn_changes(id).await.unwrap();
|
||||
changes.into_iter().map(|c| (c.rel_path, c.kind, c.added, c.removed)).collect()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn the_last_turn_lists_and_rolls_back_only_its_own_changes() {
|
||||
use ide_vcs::ChangeKind::{Added, Deleted, Modified};
|
||||
for isolation in [Isolation::Local, Isolation::Worktree] {
|
||||
for eol in EOLS {
|
||||
let repo = Checkout::new(eol);
|
||||
repo.write("a.txt", "base\n");
|
||||
repo.write("gone.txt", "base\n");
|
||||
repo.write("mine.txt", "base\n");
|
||||
repo.commit("init");
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("Hello"),
|
||||
provider: "claude".into(),
|
||||
isolation,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let cwd = task.cwd.0.clone();
|
||||
let write = |rel: &str, text: &str| {
|
||||
let text = match eol {
|
||||
Eol::Lf => text.to_owned(),
|
||||
Eol::Crlf => text.replace('\n', "\r\n"),
|
||||
};
|
||||
std::fs::write(cwd.join(rel), text).unwrap();
|
||||
};
|
||||
let read = |rel: &str| std::fs::read_to_string(cwd.join(rel)).unwrap().replace("\r\n", "\n");
|
||||
let case = format!("{isolation:?} {eol:?}");
|
||||
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}: no turn has ended yet");
|
||||
|
||||
one_turn(&mgr, &task.id, None, || {
|
||||
write("a.txt", "base\nturn 1\n");
|
||||
write("one.txt", "one\n");
|
||||
})
|
||||
.await;
|
||||
// The user's own work between the turns belongs to neither.
|
||||
write("mine.txt", "base\nmine\n");
|
||||
one_turn(&mgr, &task.id, Some("more"), || {
|
||||
write("a.txt", "base\nturn 1\nturn 2\n");
|
||||
write("one.txt", "one\ntwo\n");
|
||||
write("two.txt", "two\n");
|
||||
std::fs::remove_file(cwd.join("gone.txt")).unwrap();
|
||||
})
|
||||
.await;
|
||||
// And after the turn.
|
||||
write("later.txt", "mine\n");
|
||||
|
||||
assert_eq!(
|
||||
turn_changed(&mgr, &task.id).await,
|
||||
[
|
||||
("a.txt".into(), Modified, 1, 0),
|
||||
("gone.txt".into(), Deleted, 0, 1),
|
||||
("one.txt".into(), Modified, 1, 0),
|
||||
("two.txt".into(), Added, 1, 0),
|
||||
],
|
||||
"{case}"
|
||||
);
|
||||
let turn_base = |rel: &str| {
|
||||
let path = cwd.join(rel);
|
||||
let mgr = &mgr;
|
||||
let id = task.id.clone();
|
||||
async move {
|
||||
let text = mgr.base_text(&id, path, AgentChangesView::LastTurn).await.unwrap();
|
||||
text.map(|t| t.replace("\r\n", "\n"))
|
||||
}
|
||||
};
|
||||
assert_eq!(turn_base("a.txt").await.as_deref(), Some("base\nturn 1\n"), "{case}");
|
||||
assert_eq!(turn_base("gone.txt").await.as_deref(), Some("base\n"), "{case}");
|
||||
assert_eq!(turn_base("two.txt").await, None, "{case}");
|
||||
let whole: Vec<String> = changed(&mgr, &task.id).await;
|
||||
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
|
||||
|
||||
// One file, then the rest, after a restart: from the copies saved as the turn started.
|
||||
mgr.rollback_changes(&task.id, Some(vec!["one.txt".into()]), AgentChangesView::LastTurn).await.unwrap();
|
||||
assert_eq!(read("one.txt"), "one\n", "{case}");
|
||||
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 3, "{case}");
|
||||
mgr.shutdown();
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
|
||||
assert_eq!(read("a.txt"), "base\nturn 1\n", "{case}");
|
||||
assert_eq!(read("gone.txt"), "base\n", "{case}");
|
||||
assert!(!cwd.join("two.txt").exists(), "{case}");
|
||||
assert_eq!(read("mine.txt"), "base\nmine\n", "{case}: the user's edit between turns stays");
|
||||
assert_eq!(read("later.txt"), "mine\n", "{case}: and the one after");
|
||||
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}");
|
||||
// The task's own changes from its first turn stay.
|
||||
let whole: Vec<String> = changed(&mgr, &task.id).await;
|
||||
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
|
||||
|
||||
mgr.delete(&task.id, true).await.unwrap();
|
||||
assert!(!repo.dir.join("store").join(format!("{}.turn", task.id)).exists(), "{case}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn rolling_back_the_whole_task_leaves_the_last_turn_nothing_to_list() {
|
||||
let repo = Checkout::new(Eol::Lf);
|
||||
repo.write("a.txt", "base\n");
|
||||
repo.commit("init");
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask { prompt: text("Hello"), provider: "claude".into(), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
one_turn(&mgr, &task.id, None, || repo.write("a.txt", "base\nturn 1\n")).await;
|
||||
one_turn(&mgr, &task.id, Some("more"), || repo.write("a.txt", "base\nturn 1\nturn 2\n")).await;
|
||||
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 1);
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
|
||||
assert_eq!(repo.read("a.txt"), "base\n");
|
||||
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_commit_made_in_the_last_turn_is_among_its_changes() {
|
||||
let repo = Checkout::new(Eol::Lf);
|
||||
repo.write("a.txt", "base\n");
|
||||
repo.commit("init");
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("Hello"),
|
||||
provider: "claude".into(),
|
||||
isolation: Isolation::Worktree,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let cwd = task.cwd.0.clone();
|
||||
let git = |args: &[&str]| {
|
||||
let ok = std::process::Command::new("git")
|
||||
.args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
|
||||
.args(args)
|
||||
.current_dir(&cwd)
|
||||
.status()
|
||||
.unwrap()
|
||||
.success();
|
||||
assert!(ok, "{args:?}");
|
||||
};
|
||||
one_turn(&mgr, &task.id, None, || {
|
||||
std::fs::write(cwd.join("a.txt"), "base\nagent\n").unwrap();
|
||||
std::fs::write(cwd.join("new.txt"), "new\n").unwrap();
|
||||
git(&["add", "."]);
|
||||
git(&["commit", "-q", "-m", "agent"]);
|
||||
})
|
||||
.await;
|
||||
let rel: Vec<String> = mgr.turn_changes(&task.id).await.unwrap().into_iter().map(|c| c.rel_path).collect();
|
||||
assert_eq!(rel, ["a.txt", "new.txt"]);
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(cwd.join("a.txt")).unwrap(), "base\n");
|
||||
assert!(!cwd.join("new.txt").exists());
|
||||
mgr.delete(&task.id, true).await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
|
||||
for eol in EOLS {
|
||||
@@ -3827,7 +3528,7 @@ async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
|
||||
repo.git(&["reset", "-q", "--soft", "HEAD~1"]);
|
||||
assert_eq!(changed(&mgr, &task.id).await, ["a.txt"], "{eol:?}");
|
||||
|
||||
let base = mgr.base_text(&task.id, repo.dir.join("a.txt"), AgentChangesView::SinceStart).await.unwrap();
|
||||
let base = mgr.base_text(&task.id, repo.dir.join("a.txt")).await.unwrap();
|
||||
assert_eq!(base.map(|b| b.replace("\r\n", "\n")).as_deref(), Some("base\n"), "{eol:?}");
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
|
||||
assert_eq!(repo.read("a.txt"), "base\n", "{eol:?}");
|
||||
@@ -3967,11 +3668,7 @@ async fn a_local_task_in_a_repository_without_commits_lists_and_rolls_back_its_c
|
||||
let (mgr, task) = repo.task().await;
|
||||
repo.write("new.txt", "agent\n");
|
||||
assert_eq!(changed(&mgr, &task.id).await, ["new.txt"], "{eol:?}");
|
||||
assert_eq!(
|
||||
mgr.base_text(&task.id, repo.dir.join("new.txt"), AgentChangesView::SinceStart).await.unwrap(),
|
||||
None,
|
||||
"{eol:?}"
|
||||
);
|
||||
assert_eq!(mgr.base_text(&task.id, repo.dir.join("new.txt")).await.unwrap(), None, "{eol:?}");
|
||||
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
|
||||
assert!(!repo.dir.join("new.txt").exists(), "{eol:?}");
|
||||
|
||||
@@ -54,23 +54,6 @@ impl Timeline {
|
||||
let mut out = Applied::default();
|
||||
let kind = update.get("sessionUpdate").and_then(Value::as_str).unwrap_or_default();
|
||||
match kind {
|
||||
"user_question" => {
|
||||
let id = str_field(update, "id");
|
||||
let Ok(questions) = serde_json::from_value::<Vec<crate::model::AgentQuestion>>(
|
||||
update.get("questions").cloned().unwrap_or(Value::Null),
|
||||
) else {
|
||||
return out;
|
||||
};
|
||||
if id.is_empty()
|
||||
|| questions.is_empty()
|
||||
|| self.entries.iter().any(|e| matches!(e, AgentEntry::Question { id: known, .. } if known == &id))
|
||||
{
|
||||
return out;
|
||||
}
|
||||
let index =
|
||||
self.push(AgentEntry::Question { id, title: str_field(update, "title"), questions, chosen: None });
|
||||
out.changed.push(index);
|
||||
}
|
||||
"agent_message_chunk" | "agent_thought_chunk" => {
|
||||
let Some(text) = content_text(update.get("content")) else { return out };
|
||||
out.changed.push(self.append_text(kind == "agent_thought_chunk", &text));
|
||||
@@ -405,25 +388,6 @@ mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn asynchronous_questions_survive_turn_end_restart_and_duplicate_notifications() {
|
||||
let mut t = Timeline::default();
|
||||
let update = json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
|
||||
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]});
|
||||
assert_eq!(t.apply(&update).changed, vec![0]);
|
||||
assert!(t.end_turn(None).is_empty());
|
||||
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: None, .. }));
|
||||
let saved = serde_json::to_string(&t.entries).unwrap();
|
||||
let mut t = Timeline::from_entries(serde_json::from_str(&saved).unwrap());
|
||||
assert!(t.apply(&update).changed.is_empty());
|
||||
assert_eq!(t.entries.len(), 1);
|
||||
if let AgentEntry::Question { chosen, .. } = &mut t.entries[0] {
|
||||
*chosen = Some("One".into());
|
||||
}
|
||||
assert!(t.apply(&update).changed.is_empty());
|
||||
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: Some(answer), .. } if answer == "One"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chunks_merge_into_one_message_until_another_entry_comes() {
|
||||
let mut t = Timeline::default();
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
use crate::model::{AgentChange, AgentChanges, AgentCommit};
|
||||
use ide_core::{IdeError, IdeResult, IpcPath};
|
||||
use ide_vcs::{ChangeKind, LogQuery, Repo};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, UNIX_EPOCH};
|
||||
@@ -611,6 +610,7 @@ pub(crate) fn restore(
|
||||
before: &BTreeMap<String, Stamp>,
|
||||
saved: Option<&Path>,
|
||||
) -> IdeResult<()> {
|
||||
let path = &change.path.0;
|
||||
let content = match before.get(&change.rel_path) {
|
||||
Some(None) => None,
|
||||
Some(Some(_)) => {
|
||||
@@ -626,16 +626,11 @@ pub(crate) fn restore(
|
||||
None => match rev {
|
||||
Some(rev) => {
|
||||
let repo = Repo::discover(cwd)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
|
||||
repo.file_bytes_at(&change.path.0, Some(rev))?
|
||||
repo.file_bytes_at(path, Some(rev))?
|
||||
}
|
||||
None => None,
|
||||
},
|
||||
};
|
||||
put(&change.path.0, content)
|
||||
}
|
||||
|
||||
/// Writes `content` to `path`, or removes the file when there is none.
|
||||
fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
|
||||
match content {
|
||||
Some(bytes) => {
|
||||
if let Some(parent) = path.parent() {
|
||||
@@ -651,187 +646,6 @@ fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The bytes of the copy of `rel` saved in `dir`, if there is one.
|
||||
pub(crate) fn saved_copy(dir: &Path, rel: &str) -> Option<Vec<u8>> {
|
||||
std::fs::read(dir.join(saved_name(rel))).ok()
|
||||
}
|
||||
|
||||
/// The checkout as the task's last turn started: what that turn's changes are compared with
|
||||
/// and rolled back to. Recorded like the task's own start: `HEAD`, the files already changed,
|
||||
/// and copies of those.
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct TurnStart {
|
||||
/// `HEAD` then (`None` outside a repository or before its first commit).
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub head: Option<String>,
|
||||
/// The files already changed then, stamped.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub before: BTreeMap<String, Stamp>,
|
||||
/// The files among `before` with a copy in the task's turn folder.
|
||||
#[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
|
||||
pub saved: BTreeSet<String>,
|
||||
/// The files that changed while the turn ran, recorded as it ended (`None` while it runs).
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub changed: Option<BTreeSet<String>>,
|
||||
}
|
||||
|
||||
/// Records the checkout at `cwd` as a turn starts, with copies of its changed files in `dir`.
|
||||
/// The copies `previous` saved of files unchanged since are kept rather than made again, so
|
||||
/// starting a turn copies little more than what the turn before it changed.
|
||||
pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -> IdeResult<TurnStart> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(TurnStart::default()) };
|
||||
let head = repo.head()?.1;
|
||||
// As the turn's end is read, so the two compare.
|
||||
let before = snapshot(cwd)?;
|
||||
let mut saved = BTreeSet::new();
|
||||
match previous {
|
||||
Some(previous) => {
|
||||
for rel in &previous.saved {
|
||||
let unchanged =
|
||||
before.get(rel).is_some_and(|now| now.is_some() && previous.before.get(rel) == Some(now));
|
||||
if unchanged {
|
||||
saved.insert(rel.clone());
|
||||
} else {
|
||||
let _ = std::fs::remove_file(dir.join(saved_name(rel)));
|
||||
}
|
||||
}
|
||||
}
|
||||
None => {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
}
|
||||
for (rel, stamp) in &before {
|
||||
let path = repo.root().join(rel);
|
||||
if stamp.is_none()
|
||||
|| saved.contains(rel)
|
||||
|| !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
std::fs::create_dir_all(dir)?;
|
||||
// One that can't be copied is listed but can't be rolled back, as a large one.
|
||||
if std::fs::copy(&path, dir.join(saved_name(rel))).is_ok() {
|
||||
saved.insert(rel.clone());
|
||||
}
|
||||
}
|
||||
Ok(TurnStart { head, before, saved, changed: None })
|
||||
}
|
||||
|
||||
/// The files that changed in `cwd` since the turn `start` began: in the working tree (as
|
||||
/// `changed_between` sees them), and in the commits made since.
|
||||
pub(crate) fn changed_in_turn(cwd: &Path, start: &TurnStart) -> IdeResult<(Vec<String>, BTreeSet<String>)> {
|
||||
let end = snapshot(cwd)?;
|
||||
let worktree = changed_between(&start.before, &end);
|
||||
let mut all: BTreeSet<String> = worktree.iter().cloned().collect();
|
||||
if let Some(repo) = discover(cwd)?
|
||||
&& let (Some(from), Some(to)) = (&start.head, repo.head()?.1)
|
||||
&& *from != to
|
||||
{
|
||||
for f in repo.diff_revisions(from, &to)? {
|
||||
all.extend(f.old_path);
|
||||
all.insert(f.path);
|
||||
}
|
||||
}
|
||||
Ok((worktree, all))
|
||||
}
|
||||
|
||||
/// The content of `rel` as the turn `start` began (`None`: no file), its copies in `dir`.
|
||||
fn at_turn_start(repo: &Repo, rel: &str, start: &TurnStart, dir: &Path) -> IdeResult<Option<Vec<u8>>> {
|
||||
match start.before.get(rel) {
|
||||
Some(None) => Ok(None),
|
||||
Some(Some(_)) => match start.saved.contains(rel).then(|| saved_copy(dir, rel)).flatten() {
|
||||
Some(bytes) => Ok(Some(bytes)),
|
||||
None => Err(IdeError::invalid(format!(
|
||||
"{rel} had changes when the turn started that weren't saved; roll it back in Git instead"
|
||||
))),
|
||||
},
|
||||
None => match &start.head {
|
||||
Some(head) => repo.file_bytes_at(&repo.root().join(rel), Some(head)),
|
||||
None => Ok(None),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Added and removed lines from `old` to `new`; none for binary content.
|
||||
fn line_stats(old: Option<&[u8]>, new: Option<&[u8]>) -> (u32, u32) {
|
||||
if [old, new].iter().flatten().any(|b| b.contains(&0)) {
|
||||
return (0, 0);
|
||||
}
|
||||
let text = |b: Option<&[u8]>| b.map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();
|
||||
ide_vcs::diff_hunks(&text(old), &text(new))
|
||||
.iter()
|
||||
.fold((0, 0), |(added, removed), h| (added + h.lines, removed + h.old_lines))
|
||||
}
|
||||
|
||||
/// The files among `changed` that differ from how they were as the turn `start` began.
|
||||
pub(crate) fn turn_changes(
|
||||
cwd: &Path,
|
||||
start: &TurnStart,
|
||||
dir: &Path,
|
||||
changed: &BTreeSet<String>,
|
||||
) -> IdeResult<Vec<AgentChange>> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(Vec::new()) };
|
||||
let mut out = Vec::new();
|
||||
for rel in changed {
|
||||
let path = repo.root().join(rel);
|
||||
// A folder (a submodule, say) or a file that can't be read has nothing to compare.
|
||||
let Some(now) = existing(&path) else { continue };
|
||||
let (kind, (added, removed)) = match at_turn_start(&repo, rel, start, dir) {
|
||||
Ok(then) if then == now => continue,
|
||||
Ok(then) => {
|
||||
let kind = match (&then, &now) {
|
||||
(None, _) => ChangeKind::Added,
|
||||
(_, None) => ChangeKind::Deleted,
|
||||
_ => ChangeKind::Modified,
|
||||
};
|
||||
(kind, line_stats(then.as_deref(), now.as_deref()))
|
||||
}
|
||||
// Its start wasn't saved: listed, without counts.
|
||||
Err(_) => (ChangeKind::Modified, (0, 0)),
|
||||
};
|
||||
out.push(AgentChange { path: IpcPath(path), rel_path: rel.clone(), kind, added, removed, old_path: None });
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The text of `path` as the turn `start` began, `None` when there was no file.
|
||||
pub(crate) fn turn_text(cwd: &Path, path: &Path, start: &TurnStart, dir: &Path) -> IdeResult<Option<String>> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(None) };
|
||||
let rel = rel_in(repo.root(), path)?;
|
||||
if let (None, Some(head)) = (start.before.get(&rel), &start.head) {
|
||||
return file_at(cwd, path, head);
|
||||
}
|
||||
let Some(bytes) = at_turn_start(&repo, &rel, start, dir)? else { return Ok(None) };
|
||||
let encoding = match ide_vfs::load_text(path) {
|
||||
Ok(loaded) => encoding_rs::Encoding::for_label(loaded.encoding.as_bytes()).unwrap_or(encoding_rs::UTF_8),
|
||||
Err(_) => ide_vfs::detect_encoding(&bytes, None),
|
||||
};
|
||||
Ok(Some(encoding.decode(&bytes).0.into_owned()))
|
||||
}
|
||||
|
||||
/// `path` relative to the repository at `root`, with `/` separators.
|
||||
fn rel_in(root: &Path, path: &Path) -> IdeResult<String> {
|
||||
let rel = path
|
||||
.strip_prefix(root)
|
||||
.map(Path::to_path_buf)
|
||||
.ok()
|
||||
.or_else(|| {
|
||||
// Another spelling of the same place (a link, `/var` and `/private/var`); the file may be gone.
|
||||
let root = dunce::canonicalize(root).ok()?;
|
||||
let parent = dunce::canonicalize(path.parent()?).ok()?;
|
||||
Some(parent.strip_prefix(&root).ok()?.join(path.file_name()?))
|
||||
})
|
||||
.ok_or_else(|| IdeError::invalid(format!("{} is outside the repository", path.display())))?;
|
||||
Ok(rel.components().map(|c| c.as_os_str().to_string_lossy()).collect::<Vec<_>>().join("/"))
|
||||
}
|
||||
|
||||
/// Puts `change` back as it was when the turn `start` began.
|
||||
pub(crate) fn restore_turn(cwd: &Path, start: &TurnStart, dir: &Path, change: &AgentChange) -> IdeResult<()> {
|
||||
let repo = repo_at(cwd)?;
|
||||
put(&change.path.0, at_turn_start(&repo, &change.rel_path, start, dir)?)
|
||||
}
|
||||
|
||||
pub(crate) fn file_at(cwd: &Path, path: &Path, rev: &str) -> IdeResult<Option<String>> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(None) };
|
||||
let encoding = match ide_vfs::load_text(path) {
|
||||
@@ -1001,67 +815,6 @@ mod tests {
|
||||
assert!(!created.path.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_turn_copies_only_what_changed_since_the_last_one() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let repo = tmp.path().join("repo");
|
||||
std::fs::create_dir(&repo).unwrap();
|
||||
git(&repo, &["init", "-q", "-b", "main"]);
|
||||
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
|
||||
git(&repo, &["add", "."]);
|
||||
git(&repo, &["commit", "-q", "-m", "init"]);
|
||||
let dir = tmp.path().join("turn");
|
||||
let set = |names: &[&str]| names.iter().map(|n| (*n).to_owned()).collect::<BTreeSet<_>>();
|
||||
|
||||
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
|
||||
std::fs::write(repo.join("b.txt"), "b\n").unwrap();
|
||||
let first = start_turn(&repo, &dir, None).unwrap();
|
||||
assert_eq!(first.saved, set(&["a.txt", "b.txt"]));
|
||||
// A copy made again would replace this mark.
|
||||
std::fs::write(dir.join(saved_name("b.txt")), "kept\n").unwrap();
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
std::fs::write(repo.join("a.txt"), "turn two\n").unwrap();
|
||||
let second = start_turn(&repo, &dir, Some(&first)).unwrap();
|
||||
assert_eq!(second.saved, set(&["a.txt", "b.txt"]));
|
||||
assert_eq!(saved_copy(&dir, "a.txt").as_deref(), Some(&b"turn two\n"[..]));
|
||||
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"kept\n"[..]));
|
||||
|
||||
// Back as committed: nothing to keep a copy of.
|
||||
git(&repo, &["checkout", "--", "a.txt"]);
|
||||
let third = start_turn(&repo, &dir, Some(&second)).unwrap();
|
||||
assert_eq!(third.saved, set(&["b.txt"]));
|
||||
assert_eq!(saved_copy(&dir, "a.txt"), None);
|
||||
// Without a record of the last turn (a task from before), every copy is made afresh.
|
||||
let fresh = start_turn(&repo, &dir, None).unwrap();
|
||||
assert_eq!(fresh.saved, set(&["b.txt"]));
|
||||
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"b\n"[..]));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_turns_start_is_found_through_another_spelling_of_the_checkout() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let repo = dunce::canonicalize(tmp.path()).unwrap().join("repo");
|
||||
std::fs::create_dir(&repo).unwrap();
|
||||
git(&repo, &["init", "-q", "-b", "main"]);
|
||||
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
|
||||
git(&repo, &["add", "."]);
|
||||
git(&repo, &["commit", "-q", "-m", "init"]);
|
||||
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
|
||||
let dir = tmp.path().join("turn");
|
||||
let start = start_turn(&repo, &dir, None).unwrap();
|
||||
std::fs::write(repo.join("a.txt"), "turn 2\n").unwrap();
|
||||
std::fs::write(repo.join("new.txt"), "new\n").unwrap();
|
||||
let link = tmp.path().join("link");
|
||||
std::os::unix::fs::symlink(&repo, &link).unwrap();
|
||||
for at in [&repo, &link] {
|
||||
assert_eq!(turn_text(&repo, &at.join("a.txt"), &start, &dir).unwrap().as_deref(), Some("turn 1\n"));
|
||||
assert_eq!(turn_text(&repo, &at.join("new.txt"), &start, &dir).unwrap(), None);
|
||||
}
|
||||
assert!(turn_text(&repo, &tmp.path().join("elsewhere.txt"), &start, &dir).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn commits_since_the_base_are_listed_with_their_files() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -120,7 +120,7 @@ fn collect(
|
||||
break;
|
||||
}
|
||||
}
|
||||
let program = process::program_path(&step.program, &step.env, &step.cwd);
|
||||
let program = process::program_path(&step.program, &step.env);
|
||||
inputs.push(program.clone());
|
||||
// Maven installed via a symlink still reads conf from its distribution.
|
||||
if let Ok(program) = dunce::canonicalize(program)
|
||||
@@ -131,7 +131,7 @@ fn collect(
|
||||
}
|
||||
}
|
||||
if !environment.contains_key("JAVA_HOME") {
|
||||
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env, &step.cwd);
|
||||
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env);
|
||||
inputs.push(java.clone());
|
||||
if let Ok(java) = dunce::canonicalize(java)
|
||||
&& let Some(home) = java.parent().and_then(Path::parent)
|
||||
@@ -171,7 +171,7 @@ fn collect(
|
||||
let steps = plan
|
||||
.steps
|
||||
.iter()
|
||||
.map(|s| (process::program_path(&s.program, &s.env, &s.cwd), s.args.clone(), s.cwd.clone(), s.env.clone()))
|
||||
.map(|s| (process::program_path(&s.program, &s.env), s.args.clone(), s.cwd.clone(), s.env.clone()))
|
||||
.collect();
|
||||
// Profiles and plugins can read arbitrary environment variables. Keep a signature
|
||||
// of the inherited environment without persisting unrelated credentials.
|
||||
|
||||
@@ -536,9 +536,7 @@ impl PathMap {
|
||||
let abs = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
// rustc prints workspace members' files relative to the workspace root, above
|
||||
// the member's manifest directory (`base`) when a member is built on its own.
|
||||
let in_base = base.and_then(|b| Path::new(b).ancestors().map(|a| a.join(p)).find(|c| c.exists()));
|
||||
let in_base = base.map(|b| Path::new(b).join(p)).filter(|c| c.exists());
|
||||
in_base.unwrap_or_else(|| cwd.join(p))
|
||||
};
|
||||
let abs = normalize(&abs);
|
||||
@@ -715,7 +713,7 @@ pub fn run(
|
||||
}
|
||||
}
|
||||
};
|
||||
let out = process::run_bounded(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
|
||||
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
|
||||
let parsed = parser.feed(line);
|
||||
match parsed.console {
|
||||
Some(text) if text.is_empty() => {}
|
||||
@@ -757,7 +755,7 @@ pub fn run(
|
||||
if !out.success {
|
||||
success = false;
|
||||
if !messages.iter().any(|m| m.severity == Severity::Error) {
|
||||
let summary = crate::sync::error_summary(&out);
|
||||
let summary = crate::sync::error_summary(&out.text);
|
||||
let text = if summary.is_empty() { last_error_line.clone() } else { summary };
|
||||
let m = BuildMessage { severity: Severity::Error, text, path: None, range: None, code: None };
|
||||
on_event(BuildEvent::Message { message: m.clone() });
|
||||
@@ -1305,22 +1303,6 @@ mod tests {
|
||||
assert_eq!(identifier_len("x é_1 c", 2), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_a_member_build_s_workspace_relative_paths() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().to_path_buf();
|
||||
write(&root, "client/src/main.rs", "fn main() {}\n");
|
||||
write(&root, "client/src/lib.rs", "\n");
|
||||
write(&root, "src/lib.rs", "\n");
|
||||
let map = PathMap { root: root.clone(), canonical: None };
|
||||
let member = root.join("client");
|
||||
let base = member.to_str();
|
||||
// Build Module runs in the member; rustc names its files from the workspace root.
|
||||
assert_eq!(map.resolve("client/src/main.rs", &member, base), root.join("client/src/main.rs"));
|
||||
// A crate built from its own directory names them from there.
|
||||
assert_eq!(map.resolve("src/lib.rs", &member, base), member.join("src/lib.rs"));
|
||||
}
|
||||
|
||||
// Uses Unix absolute paths for the canonical root.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
|
||||
@@ -30,7 +30,6 @@ 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)
|
||||
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
|
||||
// Gradle 4.x has it as a convention property, not an extension.
|
||||
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
|
||||
if (sets != null) {
|
||||
|
||||
@@ -41,10 +41,6 @@ pub struct GradleProject {
|
||||
/// Project-relative build script, if any.
|
||||
pub build_file: Option<String>,
|
||||
pub tasks: Vec<GradleTask>,
|
||||
/// Configurations Gradle can resolve, or null before Gradle reports the project.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub resolvable_configurations: Option<Vec<String>>,
|
||||
/// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
|
||||
/// `:buildSrc`); null for the opened build.
|
||||
#[serde(default)]
|
||||
@@ -305,7 +301,6 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
|
||||
path,
|
||||
name,
|
||||
tasks,
|
||||
resolvable_configurations: None,
|
||||
build: None,
|
||||
}
|
||||
}
|
||||
@@ -322,8 +317,6 @@ pub struct ReportedProject {
|
||||
pub build_dir: Option<String>,
|
||||
#[serde(default)]
|
||||
pub source_sets: Vec<ReportedSourceSet>,
|
||||
#[serde(default)]
|
||||
pub resolvable_configurations: Option<Vec<String>>,
|
||||
/// Toolchain language version, else target compatibility.
|
||||
#[serde(default)]
|
||||
pub java: Option<u32>,
|
||||
@@ -419,7 +412,6 @@ pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &
|
||||
if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
|
||||
project.tasks.clear();
|
||||
}
|
||||
project.resolvable_configurations = p.resolvable_configurations.clone();
|
||||
project.build = p.build.clone();
|
||||
project
|
||||
})
|
||||
@@ -1638,11 +1630,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
|
||||
path: path.into(),
|
||||
dir: ws.join(d).to_string_lossy().into_owned(),
|
||||
build: build.map(Into::into),
|
||||
resolvable_configurations: match path {
|
||||
":" => Some(vec!["reviewTools".into(), "runtimeClasspath".into()]),
|
||||
":lib:core" => Some(Vec::new()),
|
||||
_ => None,
|
||||
},
|
||||
..ReportedProject::default()
|
||||
};
|
||||
format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
|
||||
@@ -1671,12 +1658,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
|
||||
);
|
||||
let build_src = &model.projects[2];
|
||||
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
|
||||
assert_eq!(
|
||||
model.projects[0].resolvable_configurations,
|
||||
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
|
||||
);
|
||||
assert_eq!(model.projects[1].resolvable_configurations, None);
|
||||
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
|
||||
assert!(!model.projects[4].tasks.is_empty());
|
||||
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
|
||||
}
|
||||
|
||||
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
|
||||
configuration: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<GradleDependency>> {
|
||||
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
|
||||
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
|
||||
return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
|
||||
}
|
||||
if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
|
||||
@@ -143,7 +143,7 @@ pub fn gradle_dependencies(
|
||||
}
|
||||
let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
|
||||
let mut args: Vec<String> =
|
||||
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
|
||||
vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
|
||||
if options.offline {
|
||||
args.push("--offline".into());
|
||||
}
|
||||
@@ -156,10 +156,7 @@ pub fn gradle_dependencies(
|
||||
|_, _| {},
|
||||
)?;
|
||||
if !out.success {
|
||||
return Err(IdeError::unavailable(error_summary(&out)));
|
||||
}
|
||||
if let Some(note) = sync::truncation_note(&out) {
|
||||
return Err(IdeError::unavailable(note));
|
||||
return Err(IdeError::unavailable(error_summary(&out.text)));
|
||||
}
|
||||
Ok(parse_report(&out.text))
|
||||
}
|
||||
@@ -340,14 +337,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
|
||||
&gradle::load(root).unwrap(),
|
||||
&options,
|
||||
":app",
|
||||
"review.tools",
|
||||
"testRuntimeClasspath",
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(root.join("args")).unwrap().trim(),
|
||||
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
|
||||
"--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -13,8 +13,6 @@ pub mod kotlin_bridge;
|
||||
pub mod maven;
|
||||
pub mod pom_edit;
|
||||
mod process;
|
||||
#[cfg(test)]
|
||||
mod process_numbers;
|
||||
pub mod sbt;
|
||||
mod sync;
|
||||
pub mod web;
|
||||
|
||||
@@ -1241,13 +1241,10 @@ fn file_stamp(path: &Path) -> FileStamp {
|
||||
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
|
||||
}
|
||||
|
||||
/// The POM files a reactor walk read or looked for, the module folders it found outside the
|
||||
/// root, and the folders of every project in the reactor (canonical, the root's first).
|
||||
#[derive(Clone)]
|
||||
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
|
||||
struct ReactorScan {
|
||||
stamps: Vec<(PathBuf, FileStamp)>,
|
||||
dirs: Vec<PathBuf>,
|
||||
members: Vec<PathBuf>,
|
||||
}
|
||||
|
||||
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
|
||||
@@ -1257,28 +1254,18 @@ struct ReactorScan {
|
||||
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
|
||||
/// sizes: content roots are read on hot paths (every references search, Find in Files).
|
||||
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
|
||||
reactor(root, profiles, unlinked).dirs
|
||||
}
|
||||
|
||||
/// Folders of every project in the reactor of `root/pom.xml` (canonical): `root` itself and its
|
||||
/// modules, theirs in turn, including those of the active `profiles`. A POM elsewhere below `root`
|
||||
/// that no `<module>` reaches is a separate build.
|
||||
pub fn reactor_member_dirs(root: &Path, profiles: &[String]) -> Vec<PathBuf> {
|
||||
reactor(root, profiles, &[]).members
|
||||
}
|
||||
|
||||
fn reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
|
||||
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
|
||||
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
|
||||
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
|
||||
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
|
||||
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
|
||||
{
|
||||
return scan.clone();
|
||||
return scan.dirs.clone();
|
||||
}
|
||||
let scan = scan_reactor(root, profiles, unlinked);
|
||||
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan.clone());
|
||||
scan
|
||||
let dirs = scan.dirs.clone();
|
||||
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
|
||||
dirs
|
||||
}
|
||||
|
||||
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
|
||||
@@ -1287,8 +1274,7 @@ fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> Reacto
|
||||
let chosen = Resolver::new(None, profiles);
|
||||
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
|
||||
let first = root.join("pom.xml");
|
||||
let mut scan =
|
||||
ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new(), members: Vec::new() };
|
||||
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
|
||||
let mut seen: HashSet<PathBuf> = HashSet::new();
|
||||
let mut pending = vec![first];
|
||||
while let Some(path) = pending.pop() {
|
||||
@@ -1302,7 +1288,6 @@ fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> Reacto
|
||||
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
|
||||
let dir = path.parent().unwrap_or(root).to_path_buf();
|
||||
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
|
||||
scan.members.push(dir_canon.clone());
|
||||
if !dir_canon.starts_with(&canonical_root) {
|
||||
if canonical_root.starts_with(&dir_canon) {
|
||||
continue;
|
||||
@@ -1875,14 +1860,6 @@ pub fn goto_declaration(text: &str, path: &Path, pos: Pos, local_repo: Option<Pa
|
||||
goto_declaration_in(text, path, pos, local_repo, Vec::new)
|
||||
}
|
||||
|
||||
/// The declaration of the property `name` in the pom at `path`, for files it configures
|
||||
/// outside the pom itself (a YAML resource's `@name@`): the first `<properties>` entry
|
||||
/// along the parent chain declaring it, `project.*` built-ins included.
|
||||
pub fn property_declaration(pom: &Path, name: &str, local_repo: Option<PathBuf>) -> Option<PomGoto> {
|
||||
let text = xml::read_text(pom)?;
|
||||
property_target(&text, pom, name, local_repo)
|
||||
}
|
||||
|
||||
/// [`goto_declaration`], where a `<parent>` and a dependency or plugin whose version no
|
||||
/// management entry provides (or a management entry itself) go to the artifact's own
|
||||
/// POM: the project module among `modules` with its coordinates, else the local
|
||||
|
||||
@@ -17,79 +17,16 @@ pub(crate) enum Stream {
|
||||
Stderr,
|
||||
}
|
||||
|
||||
/// A single line longer than this without a newline is delivered as several lines: the pump
|
||||
/// buffer stays bounded whatever the child prints (progress bars, minified bundles, binary
|
||||
/// output), and every byte still arrives.
|
||||
pub(crate) const MAX_LINE_BYTES: usize = 1024 * 1024;
|
||||
/// `Output::text` stops growing past this while the pipes keep draining: a chatty build can
|
||||
/// print far more than is ever parsed back out of the retained copy.
|
||||
pub(crate) const MAX_TEXT_BYTES: usize = 32 * 1024 * 1024;
|
||||
|
||||
pub(crate) struct Output {
|
||||
pub success: bool,
|
||||
/// Every line, stdout and stderr interleaved as received, up to [`MAX_TEXT_BYTES`].
|
||||
/// Every line, stdout and stderr interleaved as received.
|
||||
pub text: String,
|
||||
/// More output followed the retained `text`; the lines were still fed to `on_line`.
|
||||
pub truncated: bool,
|
||||
}
|
||||
|
||||
/// Bounded pump for callers that stream every line and only summarize errors: reads fixed
|
||||
/// 64 KiB chunks, splits newline-free runs at a UTF-8 char boundary at the line cap, and
|
||||
/// never grows one line buffer without bound.
|
||||
fn pump_bounded(stream: Box<dyn Read + Send>, kind: Stream, tx: &mpsc::Sender<(Stream, String)>) {
|
||||
let mut reader = BufReader::new(stream);
|
||||
// `terminated`: the buffer ends in the stream's newline. A segment cut from a
|
||||
// newline-free run at the line cap must keep a trailing `\r` — it is data.
|
||||
let send = |buf: &mut Vec<u8>, terminated: bool, tx: &mpsc::Sender<(Stream, String)>| {
|
||||
let line = ide_core::output_encoding::decode_tool_output(buf);
|
||||
let line = if terminated { line.trim_end_matches(['\n', '\r']).to_owned() } else { line };
|
||||
buf.clear();
|
||||
tx.send((kind, line)).is_ok()
|
||||
};
|
||||
let mut chunk = vec![0u8; 64 * 1024];
|
||||
let mut line: Vec<u8> = Vec::with_capacity(256);
|
||||
'read: loop {
|
||||
let n = match reader.read(&mut chunk) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => n,
|
||||
};
|
||||
let mut start = 0;
|
||||
for (i, &b) in chunk[..n].iter().enumerate() {
|
||||
if b == b'\n' {
|
||||
line.extend_from_slice(&chunk[start..=i]);
|
||||
if !send(&mut line, true, tx) {
|
||||
break 'read;
|
||||
}
|
||||
start = i + 1;
|
||||
}
|
||||
}
|
||||
line.extend_from_slice(&chunk[start..n]);
|
||||
while line.len() > MAX_LINE_BYTES {
|
||||
let mut at = MAX_LINE_BYTES;
|
||||
while at > 0 && line[at] & 0xC0 == 0x80 {
|
||||
at -= 1;
|
||||
}
|
||||
// Malformed input with no boundary at all: split raw and let decoding say so.
|
||||
if at == 0 {
|
||||
at = MAX_LINE_BYTES;
|
||||
}
|
||||
let rest = line.split_off(at);
|
||||
if !send(&mut line, false, tx) {
|
||||
break 'read;
|
||||
}
|
||||
line = rest;
|
||||
}
|
||||
}
|
||||
if !line.is_empty() {
|
||||
send(&mut line, true, tx);
|
||||
}
|
||||
}
|
||||
|
||||
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
|
||||
/// search path — the login shell's `PATH` plus version-manager shims — since the
|
||||
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there. The `PATH`
|
||||
/// of the project holding `cwd` (its direnv `.envrc`) comes first.
|
||||
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &Path) -> std::path::PathBuf {
|
||||
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there.
|
||||
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std::path::PathBuf {
|
||||
let path = std::path::Path::new(program);
|
||||
if !path.is_relative() || path.components().count() > 1 {
|
||||
return path.to_path_buf();
|
||||
@@ -98,13 +35,12 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &
|
||||
.iter()
|
||||
.find(|(k, _)| k.eq_ignore_ascii_case("PATH"))
|
||||
.map(|(_, v)| std::ffi::OsString::from(v))
|
||||
.unwrap_or_else(|| ide_core::tool_path::search_path_in(cwd));
|
||||
.unwrap_or_else(ide_core::tool_path::search_path);
|
||||
ide_core::process::find_executable(program, &search).unwrap_or_else(|| path.to_path_buf())
|
||||
}
|
||||
|
||||
/// Runs `program args` in `cwd`, feeding each output line to `on_line`; kills
|
||||
/// the process group and returns `cancelled` when `cancel` fires. `Output.text`
|
||||
/// keeps every line: callers that parse a complete model from it use this.
|
||||
/// the process group and returns `cancelled` when `cancel` fires.
|
||||
pub(crate) fn run(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
@@ -116,20 +52,6 @@ pub(crate) fn run(
|
||||
run_with_env(program, args, cwd, env, false, cancel, on_line)
|
||||
}
|
||||
|
||||
/// Like [`run`], but bounds both the per-line buffer and the retained copy. For callers
|
||||
/// that stream every line to `on_line` and use `Output.text` only for error summaries:
|
||||
/// sync/model listings must be kept whole and use [`run`] instead.
|
||||
pub(crate) fn run_bounded(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
cwd: &Path,
|
||||
env: &BTreeMap<String, String>,
|
||||
cancel: &CancellationToken,
|
||||
on_line: impl FnMut(Stream, &str),
|
||||
) -> IdeResult<Output> {
|
||||
run_with_env_capture(program, args, cwd, env, RunOptions { bounded: true, ..Default::default() }, cancel, on_line)
|
||||
}
|
||||
|
||||
pub(crate) fn run_with_env(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
@@ -137,32 +59,13 @@ pub(crate) fn run_with_env(
|
||||
env: &BTreeMap<String, String>,
|
||||
clear_env: bool,
|
||||
cancel: &CancellationToken,
|
||||
on_line: impl FnMut(Stream, &str),
|
||||
) -> IdeResult<Output> {
|
||||
run_with_env_capture(program, args, cwd, env, RunOptions { clear_env, ..Default::default() }, cancel, on_line)
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Default)]
|
||||
struct RunOptions {
|
||||
clear_env: bool,
|
||||
bounded: bool,
|
||||
}
|
||||
|
||||
fn run_with_env_capture(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
cwd: &Path,
|
||||
env: &BTreeMap<String, String>,
|
||||
options: RunOptions,
|
||||
cancel: &CancellationToken,
|
||||
mut on_line: impl FnMut(Stream, &str),
|
||||
) -> IdeResult<Output> {
|
||||
let RunOptions { clear_env, bounded } = options;
|
||||
tracing::info!("build: {program} {} (in {})", args.join(" "), cwd.display());
|
||||
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
|
||||
let encoding =
|
||||
ide_core::output_encoding::fix(program, args, env, |k| std::env::var(k).ok(), "UTF-8", cfg!(windows));
|
||||
let program = program_path(program, env, cwd);
|
||||
let program = program_path(program, env);
|
||||
let mut command = Command::new(&program);
|
||||
command.args(args).current_dir(cwd).envs(env).envs(encoding.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
|
||||
command.stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
@@ -176,22 +79,17 @@ fn run_with_env_capture(
|
||||
let (tx, rx) = mpsc::channel::<(Stream, String)>();
|
||||
let pump = |stream: Box<dyn Read + Send>, kind: Stream, tx: mpsc::Sender<(Stream, String)>| {
|
||||
std::thread::spawn(move || {
|
||||
if bounded {
|
||||
pump_bounded(stream, kind, &tx);
|
||||
} else {
|
||||
// Model listings are parsed from Output.text: keep every line whole, however long.
|
||||
let mut reader = BufReader::new(stream);
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
buf.clear();
|
||||
match reader.read_until(b'\n', &mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(_) => {
|
||||
let line = ide_core::output_encoding::decode_tool_output(&buf);
|
||||
let line = line.trim_end_matches(['\n', '\r']).to_owned();
|
||||
if tx.send((kind, line)).is_err() {
|
||||
break;
|
||||
}
|
||||
let mut reader = BufReader::new(stream);
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
buf.clear();
|
||||
match reader.read_until(b'\n', &mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(_) => {
|
||||
let line = ide_core::output_encoding::decode_tool_output(&buf);
|
||||
let line = line.trim_end_matches(['\n', '\r']).to_owned();
|
||||
if tx.send((kind, line)).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -203,17 +101,7 @@ fn run_with_env_capture(
|
||||
child.stderr.take().map(|s| pump(Box::new(s), Stream::Stderr, tx.clone())),
|
||||
];
|
||||
drop(tx);
|
||||
// Retained copy of the output: the first half of the cap, then — once output overflows —
|
||||
// a rolling tail instead of the middle. Error summaries read the end of the output, while
|
||||
// listings parsed out of a successful run read from the start. The pipes keep draining
|
||||
// either way: `on_line` still sees every line, so the child never blocks on a full pipe.
|
||||
let cap = MAX_TEXT_BYTES / 2;
|
||||
let mut head = String::new();
|
||||
let mut tail: std::collections::VecDeque<Vec<u8>> = Default::default();
|
||||
let mut chunk: Vec<u8> = Vec::new();
|
||||
let mut tail_bytes = 0usize;
|
||||
let mut total = 0usize;
|
||||
let mut truncated = false;
|
||||
let mut text = String::new();
|
||||
loop {
|
||||
if cancel.is_cancelled() {
|
||||
kill_tree(&mut child);
|
||||
@@ -223,34 +111,8 @@ fn run_with_env_capture(
|
||||
Ok((_, line)) if encoding.notice.as_ref() == Some(&line) => {}
|
||||
Ok((stream, line)) => {
|
||||
on_line(stream, &line);
|
||||
if !bounded {
|
||||
// The caller parses a complete model from `text`, so keep every line.
|
||||
head.push_str(&line);
|
||||
head.push('\n');
|
||||
continue;
|
||||
}
|
||||
total += line.len() + 1;
|
||||
if !truncated {
|
||||
if head.len() + line.len() < cap {
|
||||
head.push_str(&line);
|
||||
head.push('\n');
|
||||
continue;
|
||||
}
|
||||
truncated = true;
|
||||
}
|
||||
// Fixed-size chunks, not per-line buffers: a chatty build pushes millions of
|
||||
// lines past the cap, and the tail must add no allocation per line.
|
||||
chunk.extend_from_slice(line.as_bytes());
|
||||
chunk.push(b'\n');
|
||||
if chunk.len() >= 64 * 1024 {
|
||||
tail_bytes += chunk.len();
|
||||
tail.push_back(std::mem::take(&mut chunk));
|
||||
chunk.reserve_exact(64 * 1024);
|
||||
while tail_bytes > cap {
|
||||
let Some(front) = tail.pop_front() else { break };
|
||||
tail_bytes -= front.len();
|
||||
}
|
||||
}
|
||||
text.push_str(&line);
|
||||
text.push('\n');
|
||||
}
|
||||
Err(mpsc::RecvTimeoutError::Timeout) => {}
|
||||
Err(mpsc::RecvTimeoutError::Disconnected) => break,
|
||||
@@ -260,85 +122,13 @@ fn run_with_env_capture(
|
||||
let _ = r.join();
|
||||
}
|
||||
let status = child.wait()?;
|
||||
let mut text = head;
|
||||
if truncated {
|
||||
if !chunk.is_empty() {
|
||||
tail_bytes += chunk.len();
|
||||
tail.push_back(std::mem::take(&mut chunk));
|
||||
}
|
||||
// The last partial chunk may sit past the cap; drop whole front chunks back under it.
|
||||
while tail_bytes > cap {
|
||||
let Some(front) = tail.pop_front() else { break };
|
||||
tail_bytes -= front.len();
|
||||
}
|
||||
// Tail chunks are flushed only right after a completed line, so the tail always begins
|
||||
// at a line boundary — no leading fragment to drop.
|
||||
let tail = ide_core::output_encoding::decode_tool_output(&tail.into_iter().flatten().collect::<Vec<u8>>());
|
||||
let omitted = total.saturating_sub(text.len() + tail.len());
|
||||
if omitted == 0 {
|
||||
// Everything that overflowed the head still fits in the tail: nothing was lost.
|
||||
truncated = false;
|
||||
} else {
|
||||
text.push_str(&format!("[{omitted} bytes of build output between these lines were not retained]\n"));
|
||||
}
|
||||
text.push_str(&tail);
|
||||
}
|
||||
Ok(Output { success: status.success(), text, truncated })
|
||||
Ok(Output { success: status.success(), text })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_model_line_over_one_mebibyte_is_kept_whole_for_the_parsers() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// A Gradle MODEL_LINE JSON line longer than the bounded pump's 1 MiB line cap,
|
||||
// surrounded by ordinary output.
|
||||
let script = "echo start; head -c 1048576 /dev/zero | tr '\\0' a; printf '\\n{\"id\":\"big\"}\\n'; echo end";
|
||||
let mut lines = Vec::new();
|
||||
let out = run(
|
||||
"sh",
|
||||
&["-c".into(), script.into()],
|
||||
tmp.path(),
|
||||
&BTreeMap::new(),
|
||||
&CancellationToken::new(),
|
||||
|_, line| lines.push(line.to_owned()),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
// The long line is one line, not segments that a JSON-line parser would skip.
|
||||
assert_eq!(lines.len(), 4);
|
||||
assert_eq!(lines[1].len(), 1_048_576);
|
||||
assert!(out.text.contains("{\"id\":\"big\"}"));
|
||||
let models: Vec<serde_json::Value> = out.text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
|
||||
assert_eq!(models.len(), 1, "the model line must survive full retention");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_successful_report_over_the_text_cap_is_retained_in_full() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
|
||||
let mut fed = 0usize;
|
||||
let out = run("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
fed += line.len() + 1;
|
||||
})
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
// Every line of a large successful dependency/model report is still there.
|
||||
assert_eq!(out.text.len(), fed);
|
||||
assert!(out.text.starts_with("1\n"));
|
||||
assert!(out.text.ends_with("6000000\n"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runs_and_cancels_processes() {
|
||||
if cfg!(windows) {
|
||||
@@ -357,11 +147,10 @@ mod tests {
|
||||
)
|
||||
.unwrap();
|
||||
assert!(!out.success);
|
||||
assert!(!out.truncated);
|
||||
lines.sort_by(|a, b| a.1.cmp(&b.1));
|
||||
assert_eq!(lines, [(Stream::Stdout, "one".to_owned()), (Stream::Stderr, "two".to_owned())]);
|
||||
cancel.cancel();
|
||||
let err = run_bounded("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
|
||||
let err = run("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
|
||||
.err()
|
||||
.unwrap();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
@@ -381,117 +170,9 @@ mod tests {
|
||||
std::thread::sleep(Duration::from_millis(200));
|
||||
c.cancel();
|
||||
});
|
||||
let err =
|
||||
run_bounded("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
|
||||
let err = run("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
std::thread::sleep(Duration::from_millis(1300));
|
||||
assert!(!marker.exists(), "the background child must be killed with the group");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_past_the_text_cap_keeps_head_and_tail_and_drains() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// Numbered lines 1..=6,000,000 ≈ 45 MB: past the 32 MiB retained cap.
|
||||
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
|
||||
let mut fed = 0usize;
|
||||
let mut last_seen = String::new();
|
||||
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
fed += line.len() + 1;
|
||||
last_seen = line.to_owned();
|
||||
})
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(out.truncated);
|
||||
// The pipes drained to the end: the callback saw the last line.
|
||||
assert_eq!(last_seen, "6000000");
|
||||
assert_eq!(fed, out_success_bytes());
|
||||
// The retained copy is bounded, keeps the head and the tail, and says what was dropped.
|
||||
assert!(out.text.len() <= MAX_TEXT_BYTES + 128, "{}", out.text.len());
|
||||
assert!(out.text.starts_with("1\n"));
|
||||
assert!(out.text.ends_with("6000000\n"));
|
||||
assert!(out.text.contains("were not retained]"));
|
||||
assert!(!out.text.contains("\n3000000\n"), "a middle line must be the dropped part");
|
||||
}
|
||||
|
||||
/// Lines `1..=6_000_000` emit exactly this many bytes (digit count + newline each).
|
||||
fn out_success_bytes() -> usize {
|
||||
(1..=6_000_000u64).map(|n| n.checked_ilog10().unwrap() as usize + 2).sum()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_newline_free_run_longer_than_the_line_cap_arrives_as_split_lines() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// 2.5 MiB of `x` without a single newline.
|
||||
let args = ["-c".into(), "head -c 2621440 /dev/zero | tr '\\0' x".into()];
|
||||
let mut lines = Vec::new();
|
||||
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
lines.push(line.to_owned())
|
||||
})
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
// Split at the cap, not dropped: the segments carry every byte and none is unbounded.
|
||||
assert!(lines.len() >= 3, "{}", lines.len());
|
||||
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 2_621_440);
|
||||
assert!(lines.iter().all(|l| l.len() <= MAX_LINE_BYTES));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_line_split_never_cuts_a_multibyte_character() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// `x` up to one byte before the 1 MiB cap, then `é` (two bytes) straddling it, then more `x`.
|
||||
let script =
|
||||
"head -c 1048575 /dev/zero | tr '\\0' x; printf '\\303\\251'; head -c 1048575 /dev/zero | tr '\\0' x";
|
||||
let mut lines = Vec::new();
|
||||
let out = run_bounded(
|
||||
"sh",
|
||||
&["-c".into(), script.into()],
|
||||
tmp.path(),
|
||||
&BTreeMap::new(),
|
||||
&CancellationToken::new(),
|
||||
|_, line| lines.push(line.to_owned()),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
// The é straddles the 1 MiB split point: segments shift to keep it whole.
|
||||
assert!(lines.len() >= 2, "{}", lines.len());
|
||||
// The character survived the split: present whole, never as U+FFFD halves.
|
||||
assert!(lines.iter().any(|l| l.contains('é')));
|
||||
assert!(lines.iter().all(|l| !l.contains('\u{FFFD}')));
|
||||
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 1_048_575 + 2 + 1_048_575);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_just_past_the_head_cap_loses_nothing() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// 4-byte `pad` lines up to just past the 16 MiB head cap, then the real last line:
|
||||
// the overflow fits the tail whole, so nothing is dropped and nothing is marked.
|
||||
let script = "yes pad | head -c 16777213; echo 'FATAL: the real error'";
|
||||
let out = run_bounded(
|
||||
"sh",
|
||||
&["-c".into(), script.into()],
|
||||
tmp.path(),
|
||||
&BTreeMap::new(),
|
||||
&CancellationToken::new(),
|
||||
|_, _| {},
|
||||
)
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
assert!(!out.text.contains("were not retained]"));
|
||||
assert!(out.text.starts_with("pad\n"));
|
||||
assert!(out.text.ends_with("FATAL: the real error\n"));
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
|
||||
//! run it on both revisions of `process.rs` and compare the printed numbers.
|
||||
//!
|
||||
//! ```text
|
||||
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
|
||||
//! ```
|
||||
|
||||
use crate::process;
|
||||
use ide_core::CancellationToken;
|
||||
use std::collections::BTreeMap;
|
||||
use std::time::Instant;
|
||||
|
||||
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
|
||||
#[test]
|
||||
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
|
||||
fn high_output_process_numbers() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
|
||||
let start = Instant::now();
|
||||
let mut lines = 0u64;
|
||||
let mut fed = 0usize;
|
||||
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
lines += 1;
|
||||
fed += line.len() + 1;
|
||||
})
|
||||
.unwrap();
|
||||
println!(
|
||||
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
|
||||
start.elapsed(),
|
||||
out.success,
|
||||
out.text.len()
|
||||
);
|
||||
}
|
||||
@@ -268,20 +268,8 @@ fn run(
|
||||
process::run(program, args, cwd, env, cancel, |_, line| on_line(line))
|
||||
}
|
||||
|
||||
/// What a sync records when a *successful* child run's output was truncated: parsing a
|
||||
/// truncated listing would silently produce an incomplete model, so it is surfaced, not hidden.
|
||||
pub(crate) fn truncation_note(out: &Output) -> Option<String> {
|
||||
out.truncated.then(|| {
|
||||
format!(
|
||||
"the build printed more than the retained {} MiB of output; the model may be incomplete",
|
||||
crate::process::MAX_TEXT_BYTES / (1024 * 1024)
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// The first error lines of a failed build, for the tool window.
|
||||
pub(crate) fn error_summary(output: &Output) -> String {
|
||||
let text = &output.text;
|
||||
pub(crate) fn error_summary(text: &str) -> String {
|
||||
// The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
|
||||
if text.contains("org.gradle.wrapper.GradleWrapperMain") {
|
||||
return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
|
||||
@@ -301,15 +289,11 @@ pub(crate) fn error_summary(output: &Output) -> String {
|
||||
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
|
||||
.take(4)
|
||||
.collect();
|
||||
let mut summary = if lines.is_empty() {
|
||||
if lines.is_empty() {
|
||||
text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("the build failed").trim().to_owned()
|
||||
} else {
|
||||
lines.join("\n")
|
||||
};
|
||||
if output.truncated {
|
||||
summary.push_str("\n[the build printed more than the retained output; this summary may miss lines]");
|
||||
}
|
||||
summary
|
||||
}
|
||||
|
||||
/// `[INFO] Building core 1.0-SNAPSHOT [2/3]` → ("core 1.0-SNAPSHOT", 2, 3).
|
||||
@@ -413,9 +397,7 @@ pub fn sync_maven(
|
||||
}
|
||||
}
|
||||
if !out.success {
|
||||
errors.push(error_summary(&out));
|
||||
} else if let Some(note) = truncation_note(&out) {
|
||||
errors.push(note);
|
||||
errors.push(error_summary(&out.text));
|
||||
}
|
||||
}
|
||||
cache.at_ms = now_ms();
|
||||
@@ -455,8 +437,6 @@ pub fn sync_gradle_model(
|
||||
let mut args: Vec<String> = vec![
|
||||
"--console=plain".into(),
|
||||
"-q".into(),
|
||||
// The init script reports the evaluated projects, even when a build enables the configuration cache.
|
||||
"-Dorg.gradle.configuration-cache=false".into(),
|
||||
"--init-script".into(),
|
||||
init_script.to_string_lossy().into_owned(),
|
||||
"tasks".into(),
|
||||
@@ -477,7 +457,7 @@ pub fn sync_gradle_model(
|
||||
Ok(out) => out,
|
||||
Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
|
||||
Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
|
||||
Output { success: false, text: error.message, truncated: false }
|
||||
Output { success: false, text: error.message }
|
||||
}
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
@@ -490,7 +470,7 @@ pub fn sync_gradle_model(
|
||||
let cache = GradleCache {
|
||||
hash: hash_gradle_files(&gradle::build_files(root, &model)),
|
||||
at_ms: now_ms(),
|
||||
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
|
||||
error: (!out.success).then(|| error_summary(&out.text)),
|
||||
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
|
||||
projects,
|
||||
resources: true,
|
||||
@@ -934,22 +914,10 @@ mod tests {
|
||||
);
|
||||
assert_eq!(maven_building("[INFO] Building jar: x.jar"), None);
|
||||
let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
|
||||
let out = |text: &str, truncated| crate::process::Output { success: false, text: text.to_owned(), truncated };
|
||||
assert_eq!(error_summary(&out(text, false)), "Failed to execute goal");
|
||||
assert_eq!(error_summary(&out("one\nlast line\n\n", false)), "last line");
|
||||
assert_eq!(error_summary(text), "Failed to execute goal");
|
||||
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
|
||||
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
|
||||
assert!(error_summary(&out(missing_jar, false)).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
|
||||
// A truncated capture says so instead of hiding that lines are missing.
|
||||
assert!(error_summary(&out(text, true)).ends_with("this summary may miss lines]"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_truncated_successful_run_is_surfaced_not_silent() {
|
||||
let out = |truncated| crate::process::Output { success: true, text: String::new(), truncated };
|
||||
assert!(truncation_note(&out(false)).is_none());
|
||||
let note = truncation_note(&out(true)).unwrap();
|
||||
assert!(note.starts_with("the build printed more than the retained 32 MiB"), "{note}");
|
||||
assert!(note.ends_with("the model may be incomplete"));
|
||||
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -446,12 +446,6 @@ pub struct LanguageCodeStyle {
|
||||
/// Comment Code › Add a space at line comment start.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub line_comment_add_space: Option<bool>,
|
||||
/// PHP: align `=>` in multi-line arrays after formatting (other languages ignore it).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub align_key_value_pairs: Option<bool>,
|
||||
/// PHP: align `=` of consecutive assignment statements after formatting.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub align_consecutive_assignments: Option<bool>,
|
||||
}
|
||||
|
||||
/// Editor › Code Style (General tab + per-language overrides).
|
||||
|
||||
@@ -47,12 +47,6 @@ pub enum IdeEvent {
|
||||
root: crate::IpcPath,
|
||||
trusted: bool,
|
||||
},
|
||||
/// The project's direnv environment (`.envrc`) could not be loaded, or a file it is read
|
||||
/// from changed and it can be reloaded.
|
||||
Direnv {
|
||||
root: crate::IpcPath,
|
||||
status: DirenvStatus,
|
||||
},
|
||||
/// Files or directories changed on disk (after debouncing, ignore rules applied).
|
||||
FsChanged {
|
||||
created: Vec<crate::IpcPath>,
|
||||
@@ -234,20 +228,6 @@ pub enum AskpassKind {
|
||||
Confirm,
|
||||
}
|
||||
|
||||
/// See [`IdeEvent::Direnv`].
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum DirenvStatus {
|
||||
/// `direnv` is not installed (on the search path).
|
||||
NotInstalled,
|
||||
/// direnv refuses the `.envrc` until the user approves it with `direnv allow`.
|
||||
Blocked,
|
||||
/// `direnv export` failed or took too long: what it printed last.
|
||||
Failed { message: String },
|
||||
/// `.envrc`, `flake.nix` or `flake.lock` (a file name in the project root) changed.
|
||||
Changed { file: String },
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum ServerStatus {
|
||||
|
||||
@@ -19,7 +19,6 @@ pub mod output_encoding;
|
||||
pub mod platform;
|
||||
pub mod process;
|
||||
pub mod project_dir;
|
||||
pub mod project_env;
|
||||
pub mod project_roots;
|
||||
pub mod proxy_settings;
|
||||
pub mod real_path;
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
//! Child-process helpers shared by every crate that spawns tools.
|
||||
|
||||
use std::ffi::{OsStr, OsString};
|
||||
use std::path::Path;
|
||||
#[cfg(windows)]
|
||||
use std::process::Stdio;
|
||||
use std::process::{Child, Command};
|
||||
@@ -19,8 +18,7 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
||||
/// console child flashes a `cmd` window.
|
||||
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
|
||||
///
|
||||
/// Variables the call site has already set are kept; call it before `env_clear` and after
|
||||
/// `current_dir`, which picks the project environment.
|
||||
/// Variables the call site has already set are kept; call it before `env_clear`.
|
||||
pub fn prepare(cmd: &mut Command) -> &mut Command {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
@@ -518,13 +516,10 @@ mod windows_job {
|
||||
/// those of a manual HTTP proxy ([`crate::proxy_settings::ProxySettings::child_env`]),
|
||||
/// and the login shell's variables this process lacks ([`shell_env`]: an app started from
|
||||
/// Finder/Dock doesn't have what rc files export, such as `GOPATH`, `JAVA_HOME` or
|
||||
/// `MAVEN_OPTS`). A child whose `current_dir` is inside a project also gets the project's
|
||||
/// environment ([`crate::project_env`]), so set it first. Variables the call site has
|
||||
/// already set are kept.
|
||||
/// `MAVEN_OPTS`). Variables the call site has already set are kept.
|
||||
pub fn host_env(cmd: &mut Command) -> &mut Command {
|
||||
let dir = cmd.get_current_dir().map(Path::to_path_buf);
|
||||
let fixes = child_env_changes(dir.as_deref());
|
||||
let shell: Vec<_> = shell_env_for(dir.as_deref()).collect();
|
||||
let fixes = child_env_changes();
|
||||
let shell: Vec<_> = shell_env().collect();
|
||||
if fixes.is_empty() && shell.is_empty() {
|
||||
return cmd;
|
||||
}
|
||||
@@ -545,40 +540,22 @@ pub fn host_env(cmd: &mut Command) -> &mut Command {
|
||||
/// that are not a `std::process::Command` (a PTY `CommandBuilder`). Apply before the call
|
||||
/// site's own variables. Empty outside an AppImage without an overlay.
|
||||
pub fn host_env_fixes() -> Vec<(OsString, Option<OsString>)> {
|
||||
child_env_changes(None)
|
||||
}
|
||||
|
||||
/// [`host_env_fixes`] for a child started in `dir`, the environment of the project holding it included.
|
||||
pub fn host_env_fixes_in(dir: &Path) -> Vec<(OsString, Option<OsString>)> {
|
||||
child_env_changes(Some(dir))
|
||||
child_env_changes()
|
||||
}
|
||||
|
||||
/// This process's environment as a child should inherit it (see [`host_env`]), for call
|
||||
/// sites that build a child's environment from the IDE's own instead of inheriting it.
|
||||
pub fn host_vars() -> impl Iterator<Item = (OsString, OsString)> {
|
||||
apply_changes(std::env::vars_os().collect(), &child_env_changes(None)).into_iter()
|
||||
}
|
||||
|
||||
/// [`host_vars`] for a child started in `dir`.
|
||||
pub fn host_vars_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
|
||||
apply_changes(std::env::vars_os().collect(), &child_env_changes(Some(dir))).into_iter()
|
||||
apply_changes(std::env::vars_os().collect(), &child_env_changes()).into_iter()
|
||||
}
|
||||
|
||||
/// [`std::env::var_os`] as a child should see it (see [`host_env`]), the login shell's value
|
||||
/// included when this process lacks the variable.
|
||||
pub fn host_var_os(key: impl AsRef<OsStr>) -> Option<OsString> {
|
||||
host_var_os_for(None, key.as_ref())
|
||||
}
|
||||
|
||||
/// [`host_var_os`] for a child started in `dir`.
|
||||
pub fn host_var_os_in(dir: &Path, key: impl AsRef<OsStr>) -> Option<OsString> {
|
||||
host_var_os_for(Some(dir), key.as_ref())
|
||||
}
|
||||
|
||||
fn host_var_os_for(dir: Option<&Path>, key: &OsStr) -> Option<OsString> {
|
||||
match child_env_changes(dir).into_iter().find(|(k, _)| k == key) {
|
||||
let key = key.as_ref();
|
||||
match child_env_changes().into_iter().find(|(k, _)| k == key) {
|
||||
Some((_, fixed)) => fixed,
|
||||
None => std::env::var_os(key).or_else(|| shell_env_for(dir).find(|(k, _)| k == key).map(|(_, v)| v)),
|
||||
None => std::env::var_os(key).or_else(|| shell_env().find(|(k, _)| k == key).map(|(_, v)| v)),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -601,9 +578,8 @@ fn apply_changes(
|
||||
vars
|
||||
}
|
||||
|
||||
/// The AppImage fixes, the overlay, the manual proxy's, then those of the project holding
|
||||
/// `dir` (a later one wins); one entry per name.
|
||||
fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
|
||||
/// The AppImage fixes, the overlay, then the manual proxy's (a later one wins); one entry per name.
|
||||
fn child_env_changes() -> Vec<(OsString, Option<OsString>)> {
|
||||
let mut changes = appimage_fixes();
|
||||
let overlay = env_overlay();
|
||||
changes.retain(|(k, _)| !overlay.iter().any(|(o, _)| o == k));
|
||||
@@ -612,11 +588,6 @@ fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
|
||||
let proxy = crate::proxy_settings::proxy().child_env();
|
||||
changes.retain(|(k, _)| !proxy.iter().any(|(p, _)| p == k));
|
||||
changes.extend(proxy);
|
||||
if let Some(dir) = dir {
|
||||
let project = crate::project_env::for_dir(dir);
|
||||
changes.retain(|(k, _)| !project.iter().any(|(p, _)| p == k));
|
||||
changes.extend(project.iter().cloned());
|
||||
}
|
||||
changes
|
||||
}
|
||||
|
||||
@@ -696,26 +667,11 @@ pub fn login_env() -> Option<Vars> {
|
||||
/// Apply before a call site's own variables so those win. Empty until the shell has been read.
|
||||
/// Names the overlay sets are left out: [`host_env`] gives them their value.
|
||||
pub fn shell_env() -> impl Iterator<Item = (OsString, OsString)> {
|
||||
shell_env_for(None)
|
||||
}
|
||||
|
||||
/// [`shell_env`] for a child started in `dir`: names the environment of the project holding
|
||||
/// it sets are left out too.
|
||||
pub fn shell_env_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
|
||||
shell_env_for(Some(dir))
|
||||
}
|
||||
|
||||
fn shell_env_for(dir: Option<&Path>) -> impl Iterator<Item = (OsString, OsString)> {
|
||||
let overlay = env_overlay();
|
||||
let project = dir.map(crate::project_env::for_dir).unwrap_or_default();
|
||||
let vars = login_env().unwrap_or_default();
|
||||
let lacking: Vec<_> = vars
|
||||
.iter()
|
||||
.filter(|(k, _)| {
|
||||
std::env::var_os(k).is_none()
|
||||
&& !overlay.iter().any(|(o, _)| o == k)
|
||||
&& !project.iter().any(|(p, _)| p == k)
|
||||
})
|
||||
.filter(|(k, _)| std::env::var_os(k).is_none() && !overlay.iter().any(|(o, _)| o == k))
|
||||
.cloned()
|
||||
.collect();
|
||||
lacking.into_iter()
|
||||
@@ -1059,47 +1015,6 @@ mod tests {
|
||||
set_env_overlay(Vec::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_child_inside_a_project_gets_its_environment() {
|
||||
let root = std::path::Path::new("/openidea-test-process/project");
|
||||
// Absolute on the platform: the search path drops relative entries.
|
||||
let devshell = if cfg!(windows) { r"C:\nix\store\x-devshell\bin" } else { "/nix/store/x-devshell/bin" };
|
||||
crate::project_env::set(
|
||||
root,
|
||||
vec![
|
||||
("OPENIDEA_PROJECT_VAR".into(), Some("devshell".into())),
|
||||
("PATH".into(), Some(devshell.into())),
|
||||
("OPENIDEA_PROJECT_UNSET".into(), None),
|
||||
],
|
||||
);
|
||||
let get = |cmd: &Command, k: &str| cmd.get_envs().find(|(n, _)| *n == k).map(|(_, v)| v.map(OsStr::to_owned));
|
||||
|
||||
let mut inside = Command::new("true");
|
||||
inside.current_dir(root.join("src")).env("OPENIDEA_PROJECT_VAR", "call site");
|
||||
host_env(&mut inside);
|
||||
assert_eq!(get(&inside, "PATH"), Some(Some(devshell.into())));
|
||||
assert_eq!(get(&inside, "OPENIDEA_PROJECT_UNSET"), Some(None));
|
||||
assert_eq!(get(&inside, "OPENIDEA_PROJECT_VAR"), Some(Some("call site".into())), "the call site's value wins");
|
||||
|
||||
let mut outside = Command::new("true");
|
||||
outside.current_dir("/openidea-test-process/other");
|
||||
host_env(&mut outside);
|
||||
assert_eq!(get(&outside, "OPENIDEA_PROJECT_VAR"), None);
|
||||
let mut no_dir = Command::new("true");
|
||||
host_env(&mut no_dir);
|
||||
assert_eq!(get(&no_dir, "OPENIDEA_PROJECT_VAR"), None);
|
||||
|
||||
// Spawners that build the environment themselves (PTYs, runs) and `PATH` lookups.
|
||||
assert!(host_env_fixes_in(root).iter().any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v.is_some()));
|
||||
assert!(host_vars_in(root).any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v == "devshell"));
|
||||
assert_eq!(host_var_os_in(root, "OPENIDEA_PROJECT_VAR"), Some("devshell".into()));
|
||||
assert_eq!(host_var_os("OPENIDEA_PROJECT_VAR"), None);
|
||||
let search = crate::tool_path::search_path_in(root);
|
||||
assert_eq!(std::env::split_paths(&search).next(), Some(devshell.into()));
|
||||
crate::project_env::remove(root);
|
||||
assert!(host_vars_in(root).all(|(k, _)| k != "OPENIDEA_PROJECT_VAR"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changes_apply_in_order() {
|
||||
let vars = apply_changes(
|
||||
|
||||
@@ -1,138 +0,0 @@
|
||||
//! Environments of project folders (a project's direnv `.envrc`), for the children started
|
||||
//! inside them. One process can hold several projects (desktop windows), so unlike the
|
||||
//! process-wide overlay ([`crate::process::set_env_overlay`]) these are kept per root and
|
||||
//! found from a child's working directory: see [`crate::process::host_env`] and the `_in`
|
||||
//! variants next to it.
|
||||
|
||||
use crate::CancellationToken;
|
||||
use std::ffi::OsString;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
|
||||
use std::time::Duration;
|
||||
|
||||
pub type Changes = Arc<Vec<(OsString, Option<OsString>)>>;
|
||||
|
||||
struct Entry {
|
||||
root: PathBuf,
|
||||
changes: Changes,
|
||||
loading: bool,
|
||||
}
|
||||
|
||||
static ENTRIES: Mutex<Vec<Entry>> = Mutex::new(Vec::new());
|
||||
static SETTLED: Condvar = Condvar::new();
|
||||
|
||||
fn entries() -> MutexGuard<'static, Vec<Entry>> {
|
||||
ENTRIES.lock().unwrap_or_else(|e| e.into_inner())
|
||||
}
|
||||
|
||||
/// `root`'s environment is being read: [`wait`] blocks until [`set`] or [`remove`]. Children
|
||||
/// started meanwhile keep getting the last one read.
|
||||
pub fn begin_loading(root: &Path) {
|
||||
let mut entries = entries();
|
||||
match entries.iter_mut().find(|e| e.root == root) {
|
||||
Some(entry) => entry.loading = true,
|
||||
None => entries.push(Entry { root: root.to_path_buf(), changes: Changes::default(), loading: true }),
|
||||
}
|
||||
}
|
||||
|
||||
/// What children started in `root` (or below it) get on top of the IDE's own environment
|
||||
/// (`None`: removed). Ends a [`begin_loading`].
|
||||
pub fn set(root: &Path, changes: Vec<(OsString, Option<OsString>)>) {
|
||||
let mut entries = entries();
|
||||
let changes = Arc::new(changes);
|
||||
match entries.iter_mut().find(|e| e.root == root) {
|
||||
Some(entry) => {
|
||||
entry.changes = changes;
|
||||
entry.loading = false;
|
||||
}
|
||||
None => entries.push(Entry { root: root.to_path_buf(), changes, loading: false }),
|
||||
}
|
||||
SETTLED.notify_all();
|
||||
}
|
||||
|
||||
/// Ends a [`begin_loading`] that read nothing new (an error): the last environment stays.
|
||||
pub fn settle(root: &Path) {
|
||||
if let Some(entry) = entries().iter_mut().find(|e| e.root == root) {
|
||||
entry.loading = false;
|
||||
}
|
||||
SETTLED.notify_all();
|
||||
}
|
||||
|
||||
/// `root` has no environment of its own any more (closed, or not trusted).
|
||||
pub fn remove(root: &Path) {
|
||||
entries().retain(|e| e.root != root);
|
||||
SETTLED.notify_all();
|
||||
}
|
||||
|
||||
/// The innermost root holding `dir`.
|
||||
fn find<'a>(entries: &'a [Entry], dir: &Path) -> Option<&'a Entry> {
|
||||
entries.iter().filter(|e| dir.starts_with(&e.root)).max_by_key(|e| e.root.components().count())
|
||||
}
|
||||
|
||||
/// The environment of the project holding `dir` (empty outside every project, or before it was read).
|
||||
pub fn for_dir(dir: &Path) -> Changes {
|
||||
find(&entries(), dir).map(|e| e.changes.clone()).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Whether the environment of the project holding `dir` is being read.
|
||||
pub fn is_loading(dir: &Path) -> bool {
|
||||
find(&entries(), dir).is_some_and(|e| e.loading)
|
||||
}
|
||||
|
||||
/// Blocks while the environment of the project holding `dir` is being read, or until `cancel`.
|
||||
/// For what must not start without it: language servers.
|
||||
pub fn wait(dir: &Path, cancel: &CancellationToken) {
|
||||
let mut entries = entries();
|
||||
while !cancel.is_cancelled() && find(&entries, dir).is_some_and(|e| e.loading) {
|
||||
entries = SETTLED.wait_timeout(entries, Duration::from_millis(200)).unwrap_or_else(|e| e.into_inner()).0;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
|
||||
(k.into(), v.map(Into::into))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_innermost_project_holding_a_folder_applies() {
|
||||
let outer = Path::new("/openidea-test-env/outer");
|
||||
let inner = Path::new("/openidea-test-env/outer/inner");
|
||||
set(outer, vec![change("A", Some("outer"))]);
|
||||
set(inner, vec![change("A", Some("inner")), change("B", None)]);
|
||||
assert_eq!(*for_dir(&outer.join("src")), [change("A", Some("outer"))]);
|
||||
assert_eq!(*for_dir(&inner.join("src/deep")), [change("A", Some("inner")), change("B", None)]);
|
||||
assert!(for_dir(Path::new("/openidea-test-env/outer-sibling")).is_empty(), "whole components only");
|
||||
remove(inner);
|
||||
assert_eq!(*for_dir(inner), [change("A", Some("outer"))]);
|
||||
remove(outer);
|
||||
assert!(for_dir(inner).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn waiting_ends_once_the_environment_is_read() {
|
||||
let root = Path::new("/openidea-test-env/waiting");
|
||||
set(root, vec![change("OLD", Some("1"))]);
|
||||
begin_loading(root);
|
||||
assert!(is_loading(&root.join("src")));
|
||||
assert_eq!(*for_dir(root), [change("OLD", Some("1"))], "the last one read stays until then");
|
||||
let reader = std::thread::spawn(|| {
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
set(Path::new("/openidea-test-env/waiting"), vec![change("NEW", Some("2"))]);
|
||||
});
|
||||
wait(&root.join("src"), &CancellationToken::new());
|
||||
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
|
||||
reader.join().unwrap();
|
||||
|
||||
begin_loading(root);
|
||||
let cancel = CancellationToken::new();
|
||||
cancel.cancel();
|
||||
wait(root, &cancel);
|
||||
settle(root);
|
||||
assert!(!is_loading(root));
|
||||
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
|
||||
remove(root);
|
||||
}
|
||||
}
|
||||
@@ -783,35 +783,6 @@ pub struct AppearanceSettings {
|
||||
pub main_toolbar: Option<MainToolbarSettings>,
|
||||
/// Appearance › Background Image: an image shown through the IDE window.
|
||||
pub background_image: BackgroundImageSettings,
|
||||
/// Appearance › Presentation Assistant: the name and shortcut of each action run.
|
||||
pub presentation_assistant: PresentationAssistantSettings,
|
||||
}
|
||||
|
||||
/// Appearance › Presentation Assistant: shows the name and shortcut of each action the user runs.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct PresentationAssistantSettings {
|
||||
pub enabled: bool,
|
||||
/// `small` | `medium` | `large`.
|
||||
pub size: String,
|
||||
/// How long each popup stays, in seconds.
|
||||
pub duration_seconds: u32,
|
||||
/// `top-left`, `top`, `top-right`, `bottom-left`, `bottom` or `bottom-right` of the window.
|
||||
pub position: String,
|
||||
/// Also show the shortcut of the other platform's keymap (macOS ⇄ Windows/Linux).
|
||||
pub alternate_keymap: bool,
|
||||
}
|
||||
|
||||
impl Default for PresentationAssistantSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
enabled: false,
|
||||
size: "medium".into(),
|
||||
duration_seconds: 4,
|
||||
position: "bottom".into(),
|
||||
alternate_keymap: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Appearance › Background Image. An empty `path` shows no image.
|
||||
@@ -904,7 +875,6 @@ impl Default for AppearanceSettings {
|
||||
status_bar_widgets: BTreeMap::new(),
|
||||
main_toolbar: None,
|
||||
background_image: BackgroundImageSettings::default(),
|
||||
presentation_assistant: PresentationAssistantSettings::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1504,10 +1474,6 @@ pub struct MavenSettings {
|
||||
pub active_profiles: String,
|
||||
/// Delegate IDE build/run actions to Maven: launches build with Maven (`javac`) instead of jdtls (ECJ).
|
||||
pub delegate_build: bool,
|
||||
/// Download `-sources.jar` of dependencies when the Java language server imports the
|
||||
/// project (jdtls `java.maven.downloadSources`). Off: sources are fetched on demand
|
||||
/// from a library class's Download Sources banner.
|
||||
pub download_sources: bool,
|
||||
}
|
||||
|
||||
impl MavenSettings {
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//! their settings come from, installers. An app started from the desktop gets a
|
||||
//! minimal `PATH`, and version managers set theirs up in shell rc files.
|
||||
|
||||
use crate::process::{host_var_os, host_var_os_in, login_env};
|
||||
use crate::process::{host_var_os, login_env};
|
||||
use crate::version_managers;
|
||||
use std::collections::HashSet;
|
||||
use std::ffi::{OsStr, OsString};
|
||||
@@ -14,16 +14,6 @@ use std::path::{Path, PathBuf};
|
||||
/// launchers, their settings hooks and tool detection all look here, so a settings
|
||||
/// hook finds the executable its server is launched from.
|
||||
pub fn search_path() -> OsString {
|
||||
search_path_for(None)
|
||||
}
|
||||
|
||||
/// [`search_path`] for a child started in `dir`: the `PATH` of the project holding it
|
||||
/// ([`crate::project_env`], e.g. a Nix devshell's) comes first.
|
||||
pub fn search_path_in(dir: &Path) -> OsString {
|
||||
search_path_for(Some(dir))
|
||||
}
|
||||
|
||||
fn search_path_for(dir: Option<&Path>) -> OsString {
|
||||
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from);
|
||||
let shell_path = login_env().and_then(|env| env.iter().find(|(k, _)| k == "PATH").map(|(_, v)| v.clone()));
|
||||
let shims: Vec<PathBuf> = version_managers::managers().iter().map(|m| m.shims()).collect();
|
||||
@@ -31,11 +21,7 @@ fn search_path_for(dir: Option<&Path>) -> OsString {
|
||||
// entries after the inherited ones so missing user tools still resolve.
|
||||
let user_path = crate::process::user_path();
|
||||
let dirs = search_dirs(
|
||||
match dir {
|
||||
Some(dir) => host_var_os_in(dir, "PATH"),
|
||||
None => host_var_os("PATH"),
|
||||
}
|
||||
.as_deref(),
|
||||
host_var_os("PATH").as_deref(),
|
||||
shell_path.as_deref(),
|
||||
user_path.as_deref(),
|
||||
home.as_deref(),
|
||||
|
||||
@@ -214,8 +214,9 @@ pub fn collect(spec: &CoverageReportSpec) -> IdeResult<CoverageSuite> {
|
||||
CoverageReportSpec::Exported { runner, argv, cwd, env, lcov } => {
|
||||
let (program, args) =
|
||||
argv.split_first().ok_or_else(|| IdeError::invalid("empty coverage export command"))?;
|
||||
let out = ide_core::process::prepare(Command::new(program).current_dir(cwd))
|
||||
let out = ide_core::process::prepare(&mut Command::new(program))
|
||||
.args(args)
|
||||
.current_dir(cwd)
|
||||
.envs(env)
|
||||
.output()
|
||||
.map_err(|e| IdeError::unavailable(format!("cannot run {program}: {e}")))?;
|
||||
|
||||
@@ -281,16 +281,15 @@ fn managed_dirs(root: &Path) -> Vec<PathBuf> {
|
||||
/// The `PATH` an adapter runs with, unless its launch sets one: the search path language servers
|
||||
/// get, so what it starts in turn (js-debug's wrapper runs `node`, Delve runs `go build`) is
|
||||
/// found like Run finds it, even when the login shell's `PATH` didn't reach the app.
|
||||
fn adapter_path(env: &[(String, String)], cwd: &Path) -> Option<std::ffi::OsString> {
|
||||
fn adapter_path(env: &[(String, String)]) -> Option<std::ffi::OsString> {
|
||||
let own = env.iter().any(|(k, _)| if cfg!(windows) { k.eq_ignore_ascii_case("PATH") } else { k == "PATH" });
|
||||
(!own).then(|| ide_core::tool_path::search_path_in(cwd))
|
||||
(!own).then(ide_core::tool_path::search_path)
|
||||
}
|
||||
|
||||
/// Directories searched for adapter binaries: managed tools first, then `PATH` (the project's
|
||||
/// holding `cwd` first) and the usual install spots.
|
||||
fn search_dirs(cwd: &Path) -> Vec<PathBuf> {
|
||||
/// Directories searched for adapter binaries: managed tools first, then `PATH` and the usual install spots.
|
||||
fn search_dirs() -> Vec<PathBuf> {
|
||||
let mut dirs: Vec<PathBuf> = tools_root().map(|r| managed_dirs(&r)).unwrap_or_default();
|
||||
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path_in(cwd)));
|
||||
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path()));
|
||||
if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
|
||||
for rel in [".cargo/bin", ".local/bin", "go/bin", ".dotnet/tools", ".bun/bin", ".npm-global/bin", ".volta/bin"]
|
||||
{
|
||||
@@ -319,7 +318,7 @@ fn is_executable(path: &Path, windows: bool) -> bool {
|
||||
/// extensionless script next to a shim is never started as a program.
|
||||
pub fn find_binary(command: &str, cwd: &Path) -> Option<PathBuf> {
|
||||
let pathext = std::env::var("PATHEXT").ok();
|
||||
find_binary_in(command, cwd, &search_dirs(cwd), cfg!(windows), pathext.as_deref())
|
||||
find_binary_in(command, cwd, &search_dirs(), cfg!(windows), pathext.as_deref())
|
||||
}
|
||||
|
||||
fn find_binary_in(
|
||||
@@ -378,10 +377,10 @@ pub async fn prepare_debugpy(spec: &mut AdapterSpec) -> IdeResult<()> {
|
||||
return Ok(()); // Reported as a missing adapter when it is started.
|
||||
};
|
||||
let mut probe = Command::new(&python);
|
||||
probe.current_dir(&spec.cwd);
|
||||
ide_core::process::prepare(probe.as_std_mut());
|
||||
let probe = probe
|
||||
.args(["-c", "import debugpy.adapter"])
|
||||
.current_dir(&spec.cwd)
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
@@ -453,13 +452,13 @@ pub fn parse_gdb_version(output: &str) -> Option<(u32, u32)> {
|
||||
/// Probe the already resolved and verified executable with its launch environment.
|
||||
async fn gdb_version(binary: &Path, spec: &AdapterSpec) -> IdeResult<Option<(u32, u32)>> {
|
||||
let mut probe = Command::new(binary);
|
||||
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
|
||||
if let Some(path) = adapter_path(&spec.env) {
|
||||
probe.env("PATH", path);
|
||||
}
|
||||
probe.current_dir(&spec.cwd);
|
||||
ide_core::process::prepare(probe.as_std_mut());
|
||||
let probe = probe
|
||||
.arg("--version")
|
||||
.current_dir(&spec.cwd)
|
||||
.envs(spec.env.iter().cloned())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
@@ -691,11 +690,9 @@ async fn spawn_adapter(
|
||||
) -> IdeResult<AdapterIo> {
|
||||
let stderr = Arc::new(parking_lot::Mutex::new(Vec::new()));
|
||||
let mut cmd = Command::new(binary);
|
||||
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
|
||||
if let Some(path) = adapter_path(&spec.env) {
|
||||
cmd.env("PATH", path);
|
||||
}
|
||||
// The working directory first: it picks the project's environment.
|
||||
cmd.current_dir(&spec.cwd);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
// Every adapter leads its own process group: the program an adapter launches itself
|
||||
// (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
|
||||
@@ -703,6 +700,7 @@ async fn spawn_adapter(
|
||||
ide_core::process::own_group(cmd.as_std_mut());
|
||||
cmd.args(args)
|
||||
.envs(spec.env.iter().map(|(k, v)| (k, v)))
|
||||
.current_dir(&spec.cwd)
|
||||
.stdin(if port.is_some() { Stdio::null() } else { Stdio::piped() })
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
@@ -845,11 +843,10 @@ mod tests {
|
||||
#[test]
|
||||
fn adapters_run_on_the_tool_search_path() {
|
||||
let search = ide_core::tool_path::search_path();
|
||||
let cwd = Path::new("/openidea-test-no-project");
|
||||
assert_eq!(adapter_path(&[], cwd), Some(search.clone()));
|
||||
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())], cwd), Some(search));
|
||||
assert_eq!(adapter_path(&[]), Some(search.clone()));
|
||||
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())]), Some(search));
|
||||
// A launch that sets its own (a selected Go SDK's bin first) keeps it.
|
||||
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())], cwd), None);
|
||||
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())]), None);
|
||||
// The search path reaches the usual install spots even when this process's `PATH` doesn't.
|
||||
#[cfg(unix)]
|
||||
{
|
||||
|
||||
@@ -55,10 +55,10 @@ pub async fn build(
|
||||
) -> IdeResult<PathBuf> {
|
||||
let cargo = find_binary("cargo", cwd).ok_or_else(|| IdeError::unavailable("`cargo` not found on PATH"))?;
|
||||
let mut cmd = tokio::process::Command::new(cargo);
|
||||
cmd.current_dir(cwd);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.args(args)
|
||||
.arg("--message-format=json-render-diagnostics")
|
||||
.current_dir(cwd)
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
|
||||
@@ -216,21 +216,7 @@ pub(crate) async fn serve(
|
||||
}
|
||||
}
|
||||
if holding {
|
||||
let (disable, command) = call("Fetch.disable", json!({}));
|
||||
if write.send(command).await.is_ok() {
|
||||
// Wait until the proxy has disabled interception before closing the
|
||||
// socket. Dropping it with unread replies can reset the connection.
|
||||
let _ = tokio::time::timeout(REQUEST_TIMEOUT, async {
|
||||
while let Some(Ok(message)) = read.next().await {
|
||||
let Ok(text) = message.to_text() else { continue };
|
||||
let Ok(reply) = serde_json::from_str::<Value>(text) else { continue };
|
||||
if reply.get("id").and_then(Value::as_u64) == Some(disable) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
}
|
||||
let _ = write.send(call("Fetch.disable", json!({})).1).await;
|
||||
}
|
||||
let _ = write.close().await;
|
||||
}
|
||||
|
||||
@@ -912,7 +912,7 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
|
||||
|
||||
/// A `runInTerminal` program and the pseudo-terminal it runs in.
|
||||
pub(crate) struct ProgramTerminal {
|
||||
writer: Arc<ide_core::input::InputWriter>,
|
||||
writer: ide_core::input::InputWriter,
|
||||
killer: Box<dyn portable_pty::ChildKiller + Send + Sync>,
|
||||
#[cfg_attr(not(unix), allow(dead_code))]
|
||||
pid: Option<u32>,
|
||||
@@ -979,18 +979,20 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
|
||||
let mut cmd = CommandBuilder::new(program);
|
||||
// CodeLLDB's launcher clears the terminal first; the console keeps the session's earlier output.
|
||||
cmd.args(rest.iter().filter(|a| *a != "--clear-screen"));
|
||||
let cwd = args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()).map_or(s.spec.cwd.as_path(), Path::new);
|
||||
for (k, v) in ide_core::process::host_env_fixes_in(cwd) {
|
||||
for (k, v) in ide_core::process::host_env_fixes() {
|
||||
match v {
|
||||
Some(v) => cmd.env(k, v),
|
||||
None => cmd.env_remove(k),
|
||||
}
|
||||
}
|
||||
for (k, v) in ide_core::process::shell_env_in(cwd) {
|
||||
for (k, v) in ide_core::process::shell_env() {
|
||||
cmd.env(k, v);
|
||||
}
|
||||
cmd.env("TERM", "xterm-256color");
|
||||
cmd.cwd(cwd);
|
||||
match args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {
|
||||
Some(cwd) => cmd.cwd(cwd),
|
||||
None => cmd.cwd(&s.spec.cwd),
|
||||
}
|
||||
if let Some(env) = args.get("env").and_then(Value::as_object) {
|
||||
for (k, v) in env {
|
||||
match v.as_str() {
|
||||
@@ -1025,12 +1027,10 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
|
||||
let _ = child.wait();
|
||||
})
|
||||
.map_err(|e| format!("terminal input worker: {e}"))?;
|
||||
let writer = Arc::new(writer);
|
||||
let pid = child.process_id();
|
||||
forward_terminal_output(
|
||||
s,
|
||||
reader,
|
||||
writer.clone(),
|
||||
#[cfg(unix)]
|
||||
wait_readable,
|
||||
);
|
||||
@@ -1045,35 +1045,10 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
|
||||
Ok(json!({ "processId": pid }))
|
||||
}
|
||||
|
||||
/// A terminal's cursor position query (DSR). ConPTY sends one when it starts and runs the program
|
||||
/// only once the terminal answers; programs that lay out a prompt ask it too.
|
||||
const CURSOR_QUERY: &[u8] = b"\x1b[6n";
|
||||
|
||||
/// `chunk` without its cursor position queries, and how many there were.
|
||||
pub(crate) fn take_cursor_queries(chunk: &[u8]) -> (Vec<u8>, usize) {
|
||||
let mut out = Vec::with_capacity(chunk.len());
|
||||
let mut queries = 0;
|
||||
let mut rest = chunk;
|
||||
while let Some(at) = rest.windows(CURSOR_QUERY.len()).position(|w| w == CURSOR_QUERY) {
|
||||
out.extend_from_slice(&rest[..at]);
|
||||
rest = &rest[at + CURSOR_QUERY.len()..];
|
||||
queries += 1;
|
||||
}
|
||||
out.extend_from_slice(rest);
|
||||
(out, queries)
|
||||
}
|
||||
|
||||
/// Length of the end of `pending` that may begin a cursor position query the next read completes.
|
||||
pub(crate) fn partial_cursor_query(pending: &[u8]) -> usize {
|
||||
(1..CURSOR_QUERY.len()).rev().find(|&n| pending.ends_with(&CURSOR_QUERY[..n])).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept). The debug
|
||||
/// console is no terminal, so cursor position queries are answered here (top-left corner).
|
||||
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).
|
||||
fn forward_terminal_output(
|
||||
s: &Session,
|
||||
mut reader: Box<dyn std::io::Read + Send>,
|
||||
answer: Arc<ide_core::input::InputWriter>,
|
||||
#[cfg(unix)] mut wait_readable: impl FnMut() -> std::io::Result<()> + Send + 'static,
|
||||
) {
|
||||
let session = s.id;
|
||||
@@ -1105,20 +1080,11 @@ fn forward_terminal_output(
|
||||
break;
|
||||
}
|
||||
}
|
||||
let (rest, queries) = take_cursor_queries(&pending);
|
||||
pending = rest;
|
||||
for _ in 0..queries {
|
||||
if let Err(e) = answer.write(b"\x1b[1;1R") {
|
||||
tracing::warn!(%session, "debug terminal cursor position: {e}");
|
||||
}
|
||||
}
|
||||
// Keep incomplete UTF-8 sequences, a `\r` that may start a `\r\n`, and the start of
|
||||
// a cursor position query for the next chunk.
|
||||
let keep = partial_cursor_query(&pending);
|
||||
let mut valid = match std::str::from_utf8(&pending[..pending.len() - keep]) {
|
||||
Ok(_) => pending.len() - keep,
|
||||
// Keep incomplete UTF-8 sequences, and a `\r` that may start a `\r\n`, for the next chunk.
|
||||
let mut valid = match std::str::from_utf8(&pending) {
|
||||
Ok(_) => pending.len(),
|
||||
Err(e) if e.error_len().is_none() => e.valid_up_to(),
|
||||
Err(_) => pending.len() - keep,
|
||||
Err(_) => pending.len(),
|
||||
};
|
||||
if valid > 0 && pending[valid - 1] == b'\r' {
|
||||
valid -= 1;
|
||||
@@ -1197,7 +1163,6 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
|
||||
let classpath =
|
||||
std::env::join_paths(strings("classPaths")).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
|
||||
let mut cmd = tokio::process::Command::new(java);
|
||||
cmd.current_dir(&s.spec.cwd);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.args(kotlin_jvm_args(strings("vmArguments"), cfg!(windows)))
|
||||
// Let the JVM pick its own port (`:0`) and report it below: pre-picking a free
|
||||
@@ -1216,7 +1181,8 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
|
||||
.ok_or_else(|| ide_core::IdeError::invalid("Missing Kotlin main class"))?,
|
||||
)
|
||||
.args(strings("programArgs"))
|
||||
.envs(ide_core::process::shell_env_in(&s.spec.cwd))
|
||||
.current_dir(&s.spec.cwd)
|
||||
.envs(ide_core::process::shell_env())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
|
||||
@@ -1010,44 +1010,6 @@ async fn run_in_terminal_spawns_debuggee() {
|
||||
assert!(response["body"]["processId"].as_u64().unwrap() > 0);
|
||||
}
|
||||
|
||||
/// The debug console answers a terminal's cursor position query: ConPTY asks one before it runs
|
||||
/// the program at all (Windows debuggees never started), and programs that lay out a prompt ask too.
|
||||
#[tokio::test]
|
||||
async fn run_in_terminal_answers_cursor_position_queries() {
|
||||
#[cfg(unix)]
|
||||
let program = vec![
|
||||
"sh".into(),
|
||||
"-c".into(),
|
||||
r"stty -echo -icanon min 6; printf '\033[6n'; reply=$(dd bs=6 count=1 2>/dev/null); stty sane; case $reply in *'[1;1R') echo answered;; esac".into(),
|
||||
];
|
||||
#[cfg(windows)]
|
||||
let program = vec!["cmd".into(), "/c".into(), "echo answered".into()];
|
||||
let h = harness(Script { run_in_terminal: Some(program), ..Script::default() });
|
||||
h.start(config()).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("answered"))).await;
|
||||
let output: String = h
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } => Some(output.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert!(!output.contains("\x1b[6n"), "{output:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cursor_position_queries_are_taken_out_of_the_output() {
|
||||
use crate::session::{partial_cursor_query, take_cursor_queries};
|
||||
assert_eq!(take_cursor_queries(b"a\x1b[6nb\x1b[6n"), (b"ab".to_vec(), 2));
|
||||
assert_eq!(take_cursor_queries(b"\x1b[0mtext"), (b"\x1b[0mtext".to_vec(), 0));
|
||||
assert_eq!(partial_cursor_query(b"text\x1b["), 2);
|
||||
assert_eq!(partial_cursor_query(b"text\x1b[6"), 3);
|
||||
assert_eq!(partial_cursor_query(b"text\x1b[0m"), 0);
|
||||
assert_eq!(partial_cursor_query(b"text"), 0);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn run_in_terminal_program_reads_typed_input() {
|
||||
|
||||
@@ -18,21 +18,14 @@ struct State {
|
||||
database: String,
|
||||
settings: Vec<(String, String)>,
|
||||
read_only: bool,
|
||||
session: Mutex<Session>,
|
||||
session_id: String,
|
||||
session: Mutex<bool>,
|
||||
closed: CancellationToken,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Session {
|
||||
id: Option<String>,
|
||||
initialized: bool,
|
||||
strict_read_only: bool,
|
||||
}
|
||||
|
||||
/// The response format: a names line, a types line, then one JSON array per row, so rows past
|
||||
/// the grid's limit are skipped without being parsed.
|
||||
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
|
||||
const SESSION_LOST: &str = "ClickHouse HTTP session not found on this node (code 372). Use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
|
||||
|
||||
pub(crate) fn transaction_error() -> IdeError {
|
||||
IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
|
||||
@@ -43,32 +36,11 @@ impl ClickhousePool {
|
||||
if source.options.transaction == DbTxMode::Manual {
|
||||
return Err(transaction_error());
|
||||
}
|
||||
let mut use_http_session = None;
|
||||
let mut settings = Vec::with_capacity(setup.params.len());
|
||||
for (name, value) in setup.params {
|
||||
if name.eq_ignore_ascii_case("use_http_session") {
|
||||
if use_http_session.is_some() {
|
||||
return Err(IdeError::invalid("ClickHouse use_http_session must be specified only once"));
|
||||
}
|
||||
use_http_session = Some(if value.eq_ignore_ascii_case("true") {
|
||||
true
|
||||
} else if value.eq_ignore_ascii_case("false") {
|
||||
false
|
||||
} else {
|
||||
return Err(IdeError::invalid("ClickHouse use_http_session must be true or false"));
|
||||
});
|
||||
} else if reserved_setting(&name) {
|
||||
for (name, _) in &setup.params {
|
||||
if reserved_setting(name) {
|
||||
return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
|
||||
} else {
|
||||
settings.push((name, value));
|
||||
}
|
||||
}
|
||||
let use_http_session = use_http_session.unwrap_or(true);
|
||||
if !use_http_session && (!setup.statements.is_empty() || !source.options.startup_script.trim().is_empty()) {
|
||||
return Err(IdeError::invalid(
|
||||
"ClickHouse use_http_session=false does not support startup scripts; configure database and settings on the data source for each request",
|
||||
));
|
||||
}
|
||||
let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
|
||||
let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
|
||||
if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
|
||||
@@ -134,49 +106,15 @@ impl ClickhousePool {
|
||||
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
|
||||
password: password.unwrap_or_default().to_owned(),
|
||||
database: if database.is_empty() { "default".into() } else { database.into() },
|
||||
settings,
|
||||
settings: setup.params,
|
||||
read_only: source.read_only,
|
||||
session: Mutex::new(Session {
|
||||
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
|
||||
..Session::default()
|
||||
}),
|
||||
session_id: uuid::Uuid::new_v4().to_string(),
|
||||
session: Mutex::new(false),
|
||||
closed: CancellationToken::new(),
|
||||
}));
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
if !rejects_driver_setting(&error) {
|
||||
return Err(error);
|
||||
}
|
||||
if !use_http_session {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
// USE once so later queries inherit the selection (and may change it).
|
||||
if use_http_session && !database.is_empty() {
|
||||
let name = crate::sql::quote_ident(crate::DbDriver::Clickhouse, database);
|
||||
pool.execute(&format!("USE {name}"), 0, &cancel).await?;
|
||||
}
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
for sql in setup.statements {
|
||||
pool.execute(&sql, 0, &cancel).await?;
|
||||
}
|
||||
@@ -213,30 +151,27 @@ impl ClickhousePool {
|
||||
}
|
||||
|
||||
/// `max_rows`: the rows the server may send (the skipped ones included).
|
||||
fn request(&self, client: &Client, query_id: &str, max_rows: usize, session: &Session) -> RequestBuilder {
|
||||
fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
|
||||
let mut request = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
|
||||
.query(&self.0.settings)
|
||||
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
|
||||
if !session.strict_read_only {
|
||||
request = request.query(&[
|
||||
.query(&[
|
||||
("session_id", self.0.session_id.clone()),
|
||||
("session_timeout", "3600".into()),
|
||||
("query_id", query_id.to_owned()),
|
||||
("default_format", FORMAT.into()),
|
||||
("output_format_json_quote_denormals", "1".into()),
|
||||
("max_result_rows", max_rows.saturating_add(1).to_string()),
|
||||
("result_overflow_mode", "break".into()),
|
||||
]);
|
||||
}
|
||||
if let Some(session_id) = &session.id {
|
||||
request = request.query(&[("session_id", session_id.as_str()), ("session_timeout", "3600")]);
|
||||
if session.initialized {
|
||||
request = request.query(&[("session_check", "1")]);
|
||||
}
|
||||
}
|
||||
if session.id.is_none() || !session.initialized {
|
||||
if initialized {
|
||||
request = request.query(&[("session_check", "1")]);
|
||||
} else {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
if self.0.read_only {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -265,7 +200,7 @@ impl ClickhousePool {
|
||||
};
|
||||
let client = self.client()?;
|
||||
let query_id = uuid::Uuid::new_v4().to_string();
|
||||
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), &session).body(sql.to_owned());
|
||||
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), *session).body(sql.to_owned());
|
||||
let started = Instant::now();
|
||||
let fetch = async {
|
||||
let mut response = request.send().await.map_err(http_error)?;
|
||||
@@ -319,7 +254,7 @@ impl ClickhousePool {
|
||||
match result {
|
||||
Some(result) => {
|
||||
if result.is_ok() {
|
||||
session.initialized = true;
|
||||
*session = true;
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -372,7 +307,11 @@ impl ClickhousePool {
|
||||
let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
|
||||
|| matches!(code, Some("193" | "194" | "195" | "516" | "497"));
|
||||
let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
|
||||
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
|
||||
let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
|
||||
"ClickHouse HTTP session expired; reconnect to restore session settings"
|
||||
} else {
|
||||
detail
|
||||
};
|
||||
self.redact_error(IdeError::new(
|
||||
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
|
||||
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
|
||||
@@ -384,9 +323,9 @@ type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);
|
||||
|
||||
/// Decodes a streamed [`FORMAT`] body. Reads past the first `skip` rows unparsed (a later
|
||||
/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
|
||||
/// unparsed, so a grid limit bounds memory even if a strict read-only server does not allow
|
||||
/// per-query result limits. A line that is not a JSON array starts the exception ClickHouse
|
||||
/// writes when a query fails mid-stream.
|
||||
/// unparsed, so a grid limit bounds memory however large the block
|
||||
/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
|
||||
/// starts the exception ClickHouse writes when a query fails mid-stream.
|
||||
struct RowReader {
|
||||
skip: usize,
|
||||
max_rows: usize,
|
||||
@@ -494,11 +433,7 @@ impl RowReader {
|
||||
let rest = std::mem::take(&mut self.pending);
|
||||
self.line(&rest)?;
|
||||
if let Some(exception) = self.exception {
|
||||
let detail = exception_text(&exception);
|
||||
return Err(IdeError::invalid(format!(
|
||||
"ClickHouse: {}",
|
||||
if session_not_found(detail) { SESSION_LOST } else { detail }
|
||||
)));
|
||||
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
|
||||
}
|
||||
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
|
||||
let types = self.types.unwrap_or_default();
|
||||
@@ -510,13 +445,6 @@ impl RowReader {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a server message reports a named HTTP session this node doesn't have.
|
||||
fn session_not_found(detail: &str) -> bool {
|
||||
detail.starts_with("Code: 372.")
|
||||
|| detail.starts_with("Session not found")
|
||||
|| detail.starts_with("SESSION_NOT_FOUND")
|
||||
}
|
||||
|
||||
/// The server's message in a failed response: rows already streamed and the
|
||||
/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
|
||||
fn exception_text(body: &str) -> &str {
|
||||
@@ -551,20 +479,6 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.is_some_and(|(name, _)| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
fn reserved_setting(name: &str) -> bool {
|
||||
let name = name.to_ascii_lowercase();
|
||||
name.starts_with("output_format_json_")
|
||||
@@ -661,19 +575,6 @@ mod tests {
|
||||
DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
|
||||
}
|
||||
|
||||
fn property(name: &str, value: &str) -> DbProperty {
|
||||
DbProperty { name: name.into(), value: value.into() }
|
||||
}
|
||||
|
||||
fn request_url(request: &str) -> Url {
|
||||
let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
Url::parse(&format!("http://localhost{target}")).unwrap()
|
||||
}
|
||||
|
||||
fn query_value(url: &Url, key: &str) -> Option<String> {
|
||||
url.query_pairs().find(|(name, _)| name == key).map(|(_, value)| value.into_owned())
|
||||
}
|
||||
|
||||
fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
|
||||
decode_from(body, 0, max_rows, chunk)
|
||||
}
|
||||
@@ -752,7 +653,6 @@ mod tests {
|
||||
let (port, requests) = server(vec![
|
||||
("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
|
||||
("200 OK", "", ""),
|
||||
("200 OK", "", ""),
|
||||
(
|
||||
"200 OK",
|
||||
"X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
|
||||
@@ -764,7 +664,7 @@ mod tests {
|
||||
user: "reader".into(),
|
||||
read_only: true,
|
||||
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
|
||||
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
|
||||
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
|
||||
@@ -787,7 +687,7 @@ mod tests {
|
||||
assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
|
||||
assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
|
||||
assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
|
||||
assert_eq!(value(&urls[3], "max_result_rows").as_deref(), Some("2"));
|
||||
assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
|
||||
for (request, url) in requests.iter().zip(&urls) {
|
||||
assert!(request.starts_with("POST /?"));
|
||||
assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
|
||||
@@ -795,10 +695,8 @@ mod tests {
|
||||
assert_eq!(value(url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
|
||||
assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(value(url, "use_http_session"), None);
|
||||
}
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("USE `analytics`"));
|
||||
assert!(pool.transaction(&[]).await.is_err());
|
||||
let cancel = CancellationToken::new();
|
||||
cancel.cancel();
|
||||
@@ -808,71 +706,6 @@ mod tests {
|
||||
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_requests_keep_database_settings_readonly_and_limits() {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE); 3]).await;
|
||||
let source = DataSource {
|
||||
database: "configured_database".into(),
|
||||
read_only: true,
|
||||
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
pool.execute("SELECT 2", 2, &CancellationToken::new()).await.unwrap();
|
||||
pool.execute("SELECT 3", 3, &CancellationToken::new()).await.unwrap();
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
let mut query_ids = std::collections::HashSet::new();
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name} must not be sent in stateless mode");
|
||||
}
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("analytics"));
|
||||
assert_eq!(query_value(&url, "session_timezone").as_deref(), Some("UTC"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "max_result_rows"), Some((index + 2).to_string()));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), Some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "default_format").as_deref(), Some(FORMAT));
|
||||
assert!(query_ids.insert(query_value(&url, "query_id").unwrap()));
|
||||
assert!(request.ends_with(&format!("SELECT {}", index + 1)));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn default_session_expiry_never_recreates_the_session_or_replays_sql() {
|
||||
for failure in [
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 372\r\n", "session unavailable"),
|
||||
("500 Internal Server Error", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
|
||||
("200 OK", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
|
||||
] {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE), failure, ("200 OK", "", ONE)]).await;
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let sql = "INSERT INTO events VALUES (1)";
|
||||
let error = pool.execute(sql, 0, &CancellationToken::new()).await.unwrap_err();
|
||||
assert!(error.message.contains("372"));
|
||||
assert!(error.message.contains("one node or session affinity"));
|
||||
assert!(error.message.contains("use_http_session=false"));
|
||||
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 3);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with(sql));
|
||||
assert!(requests[2].ends_with("SELECT 1"));
|
||||
let session_id = query_value(&request_url(&requests[0]), "session_id").unwrap();
|
||||
for request in &requests[1..] {
|
||||
let url = request_url(request);
|
||||
assert_eq!(query_value(&url, "session_id").as_deref(), Some(session_id.as_str()));
|
||||
assert_eq!(query_value(&url, "session_check").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database"), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sequential_queries_reuse_the_http_connection() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
@@ -893,144 +726,6 @@ mod tests {
|
||||
task.await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn connects_when_server_forbids_settings_in_readonly_mode() {
|
||||
let (port, requests) = server(vec![
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'output_format_json_quote_denormals' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", ONE),
|
||||
("200 OK", "", ""),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "system".into(),
|
||||
read_only: true,
|
||||
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let result = pool.execute("SELECT number FROM numbers(2)", 1, &CancellationToken::new()).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into())]]);
|
||||
assert!(result.has_more);
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[0].contains("output_format_json_quote_denormals=1"));
|
||||
assert!(requests[1].ends_with("SELECT getSetting('readonly')"));
|
||||
assert!(!requests[1].contains("session_check="));
|
||||
assert_eq!(query_value(&request_url(&requests[1]), "database").as_deref(), Some("system"));
|
||||
assert!(requests[2].contains("session_check=1"));
|
||||
let session_id = query_value(&request_url(&requests[1]), "session_id").unwrap();
|
||||
assert_ne!(query_value(&request_url(&requests[0]), "session_id").as_deref(), Some(session_id.as_str()));
|
||||
for request in &requests[1..] {
|
||||
assert_eq!(query_value(&request_url(request), "session_id").as_deref(), Some(session_id.as_str()));
|
||||
assert!(request.contains("default_format=JSONCompactEachRowWithNamesAndTypes"));
|
||||
assert!(request.contains("max_threads=2"));
|
||||
for setting in
|
||||
["output_format_json_quote_denormals=", "max_result_rows=", "result_overflow_mode=", "readonly="]
|
||||
{
|
||||
assert!(!request.contains(setting), "{setting} is not allowed in a strict read-only session");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
)])
|
||||
.await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
let url = request_url(&requests[0]);
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), read_only.then_some("1"));
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn incompatible_stateless_options_are_rejected_before_connecting() {
|
||||
for (properties, startup_script, expected) in [
|
||||
(vec![property("use_http_session", "false")], "SET max_threads = 2", "does not support startup scripts"),
|
||||
(vec![property("use_http_session", "invalid")], "", "must be true or false"),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("USE_HTTP_SESSION", "true")],
|
||||
"",
|
||||
"must be specified only once",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_id", "custom")],
|
||||
"",
|
||||
"manages the session_id",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_check", "0")],
|
||||
"",
|
||||
"manages the session_check",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_timeout", "60")],
|
||||
"",
|
||||
"manages the session_timeout",
|
||||
),
|
||||
] {
|
||||
let source = DataSource {
|
||||
properties,
|
||||
options: DbOptions { startup_script: startup_script.into(), ..Default::default() },
|
||||
..source(1)
|
||||
};
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("incompatible options must fail");
|
||||
assert!(error.message.contains(expected), "{}", error.message);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn readonly_probe_does_not_disable_settings_on_a_writable_session() {
|
||||
let (port, requests) = server(vec![
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"readonly\"]\n[\"UInt64\"]\n[0]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource { read_only: true, ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("writable session must stay rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(requests.await.unwrap()[1].ends_with("SELECT getSetting('readonly')"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn readonly_probe_matches_only_the_driver_settings() {
|
||||
for (code, setting, expected) in [
|
||||
(164, "max_result_rows", true),
|
||||
(164, "result_overflow_mode", true),
|
||||
(164, "readonly", true),
|
||||
(164, "max_threads", false),
|
||||
(516, "max_result_rows", false),
|
||||
] {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn server_errors_keep_details_and_hide_passwords() {
|
||||
let (port, requests) = server(vec![(
|
||||
|
||||
@@ -812,16 +812,16 @@ impl DbManager {
|
||||
let password = self.password(&source).await;
|
||||
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
|
||||
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
|
||||
let prepared = tools::prepare(job, executable, &target, password.as_deref())?;
|
||||
tools::run(executable, &prepared.args, &prepared.env, prepared.input.as_deref(), cancel, on_output).await
|
||||
let prepared = tools::prepare(job, &target, password.as_deref());
|
||||
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
|
||||
}
|
||||
|
||||
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
|
||||
/// own host and port (not a tunnel's local end), and no password.
|
||||
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
|
||||
let source = self.source(id)?;
|
||||
let prepared = tools::prepare(job, executable, &source, None)?;
|
||||
Ok(tools::command_line(executable, &prepared.args, job.input()))
|
||||
let prepared = tools::prepare(job, &source, None);
|
||||
Ok(tools::command_line(executable, &prepared.args))
|
||||
}
|
||||
|
||||
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
|
||||
@@ -916,37 +916,6 @@ impl DbManager {
|
||||
self.tunnels.lock().remove(id);
|
||||
}
|
||||
|
||||
/// Creates a database on the server of data source `id` by running `statement` on the data
|
||||
/// source's own database, after closing the IDE's connections to `template`, the database
|
||||
/// the server copies (PostgreSQL and SQL Server refuse to copy one that has sessions).
|
||||
pub async fn create_database(&self, id: &str, template: &str, statement: &str) -> IdeResult<()> {
|
||||
let id = split_target(id).0;
|
||||
if self.source(id)?.read_only {
|
||||
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
|
||||
}
|
||||
self.disconnect(&format!("{id}:{template}")).await;
|
||||
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
|
||||
self.remember_statement(id, statement);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Drops `database` of the server of data source `id` by running `statement` on the data
|
||||
/// source's own database, after closing the IDE's connections to `database`.
|
||||
/// Refuses the database the data source connects to and read-only data sources.
|
||||
pub async fn drop_database(&self, id: &str, database: &str, statement: &str) -> IdeResult<()> {
|
||||
let id = split_target(id).0;
|
||||
if self.source(id)?.read_only {
|
||||
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
|
||||
}
|
||||
if self.databases(id).await?.current == database {
|
||||
return Err(IdeError::invalid(format!("the data source connects to {database}; it cannot drop it")));
|
||||
}
|
||||
self.disconnect(&format!("{id}:{database}")).await;
|
||||
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
|
||||
self.remember_statement(id, statement);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The databases of the server of data source `id` (PostgreSQL), the connected one first.
|
||||
pub async fn databases(&self, id: &str) -> IdeResult<Databases> {
|
||||
let id = split_target(id).0;
|
||||
|
||||
@@ -2,7 +2,6 @@
|
||||
//! The connection arguments come from [`super::connection`]; these are the rest.
|
||||
|
||||
use super::DbTool;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
@@ -59,8 +58,6 @@ pub struct DbPgDumpOptions {
|
||||
pub struct DbPgRestoreOptions {
|
||||
pub content: DbDumpContent,
|
||||
pub schemas: Vec<String>,
|
||||
/// Creates the database the archive names; the target is only connected to.
|
||||
pub create: bool,
|
||||
pub clean: bool,
|
||||
pub if_exists: bool,
|
||||
pub no_owner: bool,
|
||||
@@ -78,40 +75,6 @@ pub struct DbPsqlOptions {
|
||||
pub stop_on_error: bool,
|
||||
}
|
||||
|
||||
/// Switches that `mysqldump` turns on by default (`--opt`) only take a flag when turned off.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbMysqldumpOptions {
|
||||
/// Empty: every database.
|
||||
pub databases: Vec<String>,
|
||||
/// Only with exactly one database.
|
||||
pub tables: Vec<String>,
|
||||
pub add_drop_table: bool,
|
||||
pub disable_keys: bool,
|
||||
pub add_locks: bool,
|
||||
pub add_drop_trigger: bool,
|
||||
pub no_data: bool,
|
||||
pub complete_insert: bool,
|
||||
pub create_options: bool,
|
||||
pub routines: bool,
|
||||
pub events: bool,
|
||||
/// A consistent InnoDB snapshot without locks; needs no RELOAD privilege.
|
||||
pub single_transaction: bool,
|
||||
/// Wins over `single_transaction`.
|
||||
pub lock_all_tables: bool,
|
||||
/// `None`: the client has no `--masking-policies`.
|
||||
pub masking_policies: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbMysqlOptions {
|
||||
/// Empty: the databases the dump names.
|
||||
pub database: String,
|
||||
/// Runs the remaining statements after an error.
|
||||
pub force: bool,
|
||||
}
|
||||
|
||||
/// A run of a client tool: which one, the file it writes or reads, and its options.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "tool", rename_all = "camelCase")]
|
||||
@@ -129,15 +92,6 @@ pub enum DbToolJob {
|
||||
file: String,
|
||||
options: DbPsqlOptions,
|
||||
},
|
||||
Mysqldump {
|
||||
file: String,
|
||||
options: DbMysqldumpOptions,
|
||||
},
|
||||
/// `file` goes to the standard input.
|
||||
Mysql {
|
||||
file: String,
|
||||
options: DbMysqlOptions,
|
||||
},
|
||||
}
|
||||
|
||||
impl DbToolJob {
|
||||
@@ -146,38 +100,15 @@ impl DbToolJob {
|
||||
DbToolJob::PgDump { .. } => DbTool::PgDump,
|
||||
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
|
||||
DbToolJob::Psql { .. } => DbTool::Psql,
|
||||
DbToolJob::Mysqldump { .. } => DbTool::Mysqldump,
|
||||
DbToolJob::Mysql { .. } => DbTool::Mysql,
|
||||
}
|
||||
}
|
||||
|
||||
/// The file piped to the tool's standard input.
|
||||
pub fn input(&self) -> Option<&str> {
|
||||
match self {
|
||||
DbToolJob::Mysql { file, .. } if !file.is_empty() => Some(file),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Refuses names that the tool would read as options: `mysqldump` takes databases and tables
|
||||
/// as plain arguments.
|
||||
pub fn check(&self) -> IdeResult<()> {
|
||||
if let DbToolJob::Mysqldump { options, .. } = self
|
||||
&& let Some(name) = options.databases.iter().chain(&options.tables).find(|n| n.trim().starts_with('-'))
|
||||
{
|
||||
return Err(IdeError::invalid(format!("mysqldump cannot dump a database or table named {name}")));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The arguments after the connection ones.
|
||||
pub fn args(&self) -> Vec<String> {
|
||||
match self {
|
||||
DbToolJob::PgDump { file, options } => pg_dump(options, file),
|
||||
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
|
||||
DbToolJob::Psql { file, options } => psql(options, file),
|
||||
DbToolJob::Mysqldump { file, options } => mysqldump(options, file),
|
||||
DbToolJob::Mysql { options, .. } => mysql(options),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -231,7 +162,6 @@ fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
|
||||
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
|
||||
let mut args: Vec<String> = content(o.content).into_iter().collect();
|
||||
args.extend(each(&o.schemas, "schema"));
|
||||
args.extend(flag(o.create, "--create"));
|
||||
args.extend(flag(o.clean, "--clean"));
|
||||
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
|
||||
args.extend(flag(o.no_owner, "--no-owner"));
|
||||
@@ -257,53 +187,8 @@ fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
|
||||
args
|
||||
}
|
||||
|
||||
fn names(list: &[String]) -> impl Iterator<Item = String> {
|
||||
list.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(str::to_owned)
|
||||
}
|
||||
|
||||
fn mysqldump(o: &DbMysqldumpOptions, file: &str) -> Vec<String> {
|
||||
let skip = |on: bool, option: &str| (!on).then(|| format!("--skip-{option}"));
|
||||
let mut args = vec![format!("--result-file={file}")];
|
||||
args.extend(skip(o.add_drop_table, "add-drop-table"));
|
||||
args.extend(skip(o.disable_keys, "disable-keys"));
|
||||
args.extend(skip(o.add_locks, "add-locks"));
|
||||
args.extend(skip(o.create_options, "create-options"));
|
||||
args.extend(flag(o.add_drop_trigger, "--add-drop-trigger"));
|
||||
args.extend(flag(o.no_data, "--no-data"));
|
||||
args.extend(flag(o.complete_insert, "--complete-insert"));
|
||||
args.extend(flag(o.routines, "--routines"));
|
||||
args.extend(flag(o.events, "--events"));
|
||||
args.extend(flag(o.lock_all_tables, "--lock-all-tables"));
|
||||
args.extend(flag(!o.lock_all_tables && o.single_transaction, "--single-transaction"));
|
||||
// On by default where it exists; reading the policies needs privileges most users lack.
|
||||
args.extend(flag(o.masking_policies == Some(false), "--skip-masking-policies"));
|
||||
// Tablespace statements need the PROCESS privilege and rarely matter in a dump.
|
||||
args.push("--no-tablespaces".into());
|
||||
args.push("--verbose".into());
|
||||
let databases: Vec<String> = names(&o.databases).collect();
|
||||
match databases.as_slice() {
|
||||
[] => args.push("--all-databases".into()),
|
||||
[one] => {
|
||||
args.push(one.clone());
|
||||
args.extend(names(&o.tables));
|
||||
}
|
||||
_ => {
|
||||
args.push("--databases".into());
|
||||
args.extend(databases);
|
||||
}
|
||||
}
|
||||
args
|
||||
}
|
||||
|
||||
fn mysql(o: &DbMysqlOptions) -> Vec<String> {
|
||||
let database = o.database.trim();
|
||||
let mut args: Vec<String> = (!database.is_empty()).then(|| format!("--database={database}")).into_iter().collect();
|
||||
args.extend(flag(o.force, "--force"));
|
||||
args
|
||||
}
|
||||
|
||||
/// The command as a shell would need it typed: the dialogs' preview. `input` is piped in.
|
||||
pub fn command_line(program: &Path, args: &[String], input: Option<&str>) -> String {
|
||||
/// The command as a shell would need it typed: the dialogs' preview.
|
||||
pub fn command_line(program: &Path, args: &[String]) -> String {
|
||||
let quote = |s: &str| {
|
||||
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
|
||||
s.to_owned()
|
||||
@@ -311,15 +196,11 @@ pub fn command_line(program: &Path, args: &[String], input: Option<&str>) -> Str
|
||||
format!("'{}'", s.replace('\'', "'\\''"))
|
||||
}
|
||||
};
|
||||
let line = std::iter::once(program.to_string_lossy().into_owned())
|
||||
std::iter::once(program.to_string_lossy().into_owned())
|
||||
.chain(args.iter().cloned())
|
||||
.map(|a| quote(&a))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ");
|
||||
match input {
|
||||
Some(file) => format!("{line} < {}", quote(file)),
|
||||
None => line,
|
||||
}
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -347,7 +228,6 @@ mod tests {
|
||||
DbPgRestoreOptions {
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
create: false,
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
no_owner: false,
|
||||
@@ -428,13 +308,6 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn creates_the_database_of_the_archive_when_asked() {
|
||||
let options = DbPgRestoreOptions { create: true, ..restore() };
|
||||
let a = args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options });
|
||||
assert_eq!(a, ["--create", "--exit-on-error", "--verbose", "/tmp/shop.dump"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn leaves_out_an_archive_not_chosen_yet() {
|
||||
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
|
||||
@@ -455,92 +328,8 @@ mod tests {
|
||||
let line = command_line(
|
||||
Path::new("/usr/bin/pg_dump"),
|
||||
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
|
||||
None,
|
||||
);
|
||||
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
|
||||
let line = command_line(Path::new("mysql"), &["--force".into()], Some("/tmp/my dump.sql"));
|
||||
assert_eq!(line, "mysql --force < '/tmp/my dump.sql'");
|
||||
}
|
||||
|
||||
fn mysqldump_options() -> DbMysqldumpOptions {
|
||||
DbMysqldumpOptions {
|
||||
databases: vec!["shop".into()],
|
||||
tables: vec![],
|
||||
add_drop_table: true,
|
||||
disable_keys: true,
|
||||
add_locks: true,
|
||||
add_drop_trigger: false,
|
||||
no_data: false,
|
||||
complete_insert: false,
|
||||
create_options: true,
|
||||
routines: false,
|
||||
events: false,
|
||||
single_transaction: true,
|
||||
lock_all_tables: false,
|
||||
masking_policies: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysqldump_flags_only_what_differs_from_its_defaults() {
|
||||
let job = DbToolJob::Mysqldump { file: "/tmp/shop.sql".into(), options: mysqldump_options() };
|
||||
assert_eq!(
|
||||
args(job),
|
||||
["--result-file=/tmp/shop.sql", "--single-transaction", "--no-tablespaces", "--verbose", "shop"]
|
||||
);
|
||||
let options = DbMysqldumpOptions {
|
||||
add_drop_table: false,
|
||||
create_options: false,
|
||||
routines: true,
|
||||
lock_all_tables: true,
|
||||
masking_policies: Some(false),
|
||||
..mysqldump_options()
|
||||
};
|
||||
let a = args(DbToolJob::Mysqldump { file: "/tmp/x.sql".into(), options });
|
||||
for expected in ["--skip-add-drop-table", "--skip-create-options", "--routines", "--lock-all-tables"] {
|
||||
assert!(a.contains(&expected.to_owned()), "{expected} missing from {a:?}");
|
||||
}
|
||||
assert!(a.contains(&"--skip-masking-policies".to_owned()), "{a:?}");
|
||||
assert!(!a.contains(&"--single-transaction".to_owned()), "{a:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysqldump_names_tables_only_of_a_single_database() {
|
||||
let tables = vec!["orders".to_owned(), "items".to_owned()];
|
||||
let one = DbMysqldumpOptions { tables: tables.clone(), ..mysqldump_options() };
|
||||
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: one }).ends_with(&[
|
||||
"shop".into(),
|
||||
"orders".into(),
|
||||
"items".into()
|
||||
]));
|
||||
let two = DbMysqldumpOptions { databases: vec!["a".into(), "b".into()], tables, ..mysqldump_options() };
|
||||
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: two }).ends_with(&[
|
||||
"--databases".into(),
|
||||
"a".into(),
|
||||
"b".into()
|
||||
]));
|
||||
let all = DbMysqldumpOptions { databases: vec![], ..mysqldump_options() };
|
||||
assert_eq!(args(DbToolJob::Mysqldump { file: "f".into(), options: all }).last().unwrap(), "--all-databases");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysqldump_refuses_names_it_would_read_as_options() {
|
||||
let options = DbMysqldumpOptions { tables: vec!["--result-file=/etc/x".into()], ..mysqldump_options() };
|
||||
assert!(DbToolJob::Mysqldump { file: "f".into(), options }.check().is_err());
|
||||
assert!(DbToolJob::Mysqldump { file: "f".into(), options: mysqldump_options() }.check().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_reads_the_dump_from_its_standard_input() {
|
||||
let job = DbToolJob::Mysql {
|
||||
file: "/tmp/shop.sql".into(),
|
||||
options: DbMysqlOptions { database: " shop ".into(), force: true },
|
||||
};
|
||||
assert_eq!(args(job.clone()), ["--database=shop", "--force"]);
|
||||
assert_eq!(job.input(), Some("/tmp/shop.sql"));
|
||||
let none =
|
||||
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: String::new(), force: false } };
|
||||
assert!(args(none.clone()).is_empty() && none.input().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`, `mysqldump`, `mysql`): finding
|
||||
//! installed copies, the arguments and environment that connect them like the data source, and
|
||||
//! running them.
|
||||
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
|
||||
//! arguments and environment that connect them like the data source, and running them.
|
||||
|
||||
mod jobs;
|
||||
pub use jobs::*;
|
||||
@@ -21,8 +20,6 @@ pub enum DbTool {
|
||||
PgDump,
|
||||
PgRestore,
|
||||
Psql,
|
||||
Mysqldump,
|
||||
Mysql,
|
||||
}
|
||||
|
||||
impl DbTool {
|
||||
@@ -30,25 +27,20 @@ impl DbTool {
|
||||
self.programs()[0]
|
||||
}
|
||||
|
||||
/// Executable names, MariaDB's own after MySQL's.
|
||||
/// Executable names.
|
||||
pub fn programs(self) -> &'static [&'static str] {
|
||||
match self {
|
||||
DbTool::PgDump => &["pg_dump"],
|
||||
DbTool::PgRestore => &["pg_restore"],
|
||||
DbTool::Psql => &["psql"],
|
||||
DbTool::Mysqldump => &["mysqldump", "mariadb-dump"],
|
||||
DbTool::Mysql => &["mysql", "mariadb"],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn driver(self) -> DbDriver {
|
||||
match self {
|
||||
DbTool::PgDump | DbTool::PgRestore | DbTool::Psql => DbDriver::Postgres,
|
||||
DbTool::Mysqldump | DbTool::Mysql => DbDriver::Mysql,
|
||||
}
|
||||
DbDriver::Postgres
|
||||
}
|
||||
|
||||
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`, `mariadb-dump`…).
|
||||
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
|
||||
/// The data source's password is handed only to such a program.
|
||||
pub fn is_program(self, path: &Path) -> bool {
|
||||
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
|
||||
@@ -61,12 +53,6 @@ impl DbTool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether `executable` is MariaDB's client (`mariadb`, `mariadb-dump`), whose SSL options differ
|
||||
/// from MySQL's.
|
||||
fn is_mariadb(executable: &Path) -> bool {
|
||||
executable.file_stem().and_then(OsStr::to_str).is_some_and(|s| s.starts_with("mariadb"))
|
||||
}
|
||||
|
||||
/// An installed copy of a tool.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
|
||||
@@ -84,41 +70,28 @@ pub struct ToolLine {
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
/// Directories holding the tools of `driver` that are often missing from `PATH`, by platform.
|
||||
fn known_dirs(driver: DbDriver) -> Vec<PathBuf> {
|
||||
let mysql = driver == DbDriver::Mysql;
|
||||
/// Directories holding the tools that are often missing from `PATH`, by platform.
|
||||
fn known_dirs() -> Vec<PathBuf> {
|
||||
let mut dirs = Vec::new();
|
||||
if cfg!(target_os = "macos") {
|
||||
for prefix in ["/opt/homebrew", "/usr/local"] {
|
||||
dirs.push(PathBuf::from(format!("{prefix}/bin")));
|
||||
let opt = PathBuf::from(format!("{prefix}/opt"));
|
||||
let kegs: &[&str] = if mysql { &["mysql-client", "mysql", "mariadb"] } else { &["libpq", "postgresql"] };
|
||||
for keg in kegs {
|
||||
for keg in ["libpq", "postgresql"] {
|
||||
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
}
|
||||
if mysql {
|
||||
dirs.push(PathBuf::from("/usr/local/mysql/bin"));
|
||||
} else {
|
||||
dirs.extend(
|
||||
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "")
|
||||
.into_iter()
|
||||
.map(|d| d.join("bin")),
|
||||
);
|
||||
}
|
||||
dirs.extend(
|
||||
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
|
||||
);
|
||||
} else if cfg!(windows) {
|
||||
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
|
||||
if let Some(base) = std::env::var_os(var) {
|
||||
let base = PathBuf::from(base);
|
||||
// MySQL installs to `MySQL\MySQL Server 8.4`, MariaDB to `MariaDB 11.4`.
|
||||
let roots: &[(&str, &str)] =
|
||||
if mysql { &[("MySQL", "MySQL"), ("", "MariaDB")] } else { &[("PostgreSQL", "")] };
|
||||
for (dir, prefix) in roots {
|
||||
dirs.extend(children(&base.join(dir), prefix).into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
let root = PathBuf::from(base).join("PostgreSQL");
|
||||
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
}
|
||||
} else if !mysql {
|
||||
} else {
|
||||
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
|
||||
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
@@ -148,7 +121,7 @@ fn version_key(text: &str) -> Vec<u32> {
|
||||
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
|
||||
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
|
||||
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
|
||||
dirs.extend(known_dirs(tool.driver()));
|
||||
dirs.extend(known_dirs());
|
||||
let mut seen = Vec::new();
|
||||
let mut out = Vec::new();
|
||||
for dir in dirs {
|
||||
@@ -177,29 +150,6 @@ pub fn version_of(path: &Path) -> IdeResult<String> {
|
||||
}
|
||||
}
|
||||
|
||||
/// The long options `path --help` lists (`masking-policies` for `--masking-policies`), so a
|
||||
/// dialog offers only options this copy knows. Blocking.
|
||||
pub fn options_of(path: &Path) -> IdeResult<Vec<String>> {
|
||||
let (_, text) = capture(path, "--help")?;
|
||||
Ok(help_options(&text))
|
||||
}
|
||||
|
||||
fn help_options(help: &str) -> Vec<String> {
|
||||
let mut out: Vec<String> = help
|
||||
.lines()
|
||||
.filter(|l| l.starts_with(' ') && l.trim_start().starts_with('-'))
|
||||
.filter_map(|l| {
|
||||
let at = l.find("--")?;
|
||||
let name: String =
|
||||
l[at + 2..].chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_').collect();
|
||||
(!name.is_empty()).then_some(name)
|
||||
})
|
||||
.collect();
|
||||
out.sort();
|
||||
out.dedup();
|
||||
out
|
||||
}
|
||||
|
||||
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
|
||||
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
|
||||
if !path.is_file() {
|
||||
@@ -239,41 +189,23 @@ pub enum DbDumpKind {
|
||||
PostgresArchive,
|
||||
/// Plain SQL from `pg_dump`: `psql`.
|
||||
PostgresSql,
|
||||
/// `mysqldump` / `mariadb-dump`: `mysql`.
|
||||
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
|
||||
MysqlSql,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
/// What a restore needs to know about a dump before it runs.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase", rename = "DbDumpInfo")]
|
||||
pub struct DumpInfo {
|
||||
pub kind: DbDumpKind,
|
||||
/// An SQL dump that runs `CREATE DATABASE` itself: `mysqldump --databases` / `--all-databases`,
|
||||
/// or `pg_dump --create`. Archives say `false`; `pg_restore --create` decides for them.
|
||||
pub creates_database: bool,
|
||||
}
|
||||
|
||||
/// Blocking: reads at most the first 64 KiB, where both tools write their `CREATE DATABASE`.
|
||||
pub fn dump_info(path: &Path) -> IdeResult<DumpInfo> {
|
||||
/// Blocking: reads at most the first 4 KiB.
|
||||
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
|
||||
use std::io::Read;
|
||||
if path.is_dir() {
|
||||
let kind = if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown };
|
||||
return Ok(DumpInfo { kind, creates_database: false });
|
||||
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
|
||||
}
|
||||
let mut head = Vec::with_capacity(64 * 1024);
|
||||
let mut head = Vec::with_capacity(4096);
|
||||
std::fs::File::open(path)
|
||||
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
|
||||
.take(64 * 1024)
|
||||
.take(4096)
|
||||
.read_to_end(&mut head)?;
|
||||
Ok(info_of(&head))
|
||||
}
|
||||
|
||||
fn info_of(head: &[u8]) -> DumpInfo {
|
||||
let kind = kind_of(head);
|
||||
let sql = matches!(kind, DbDumpKind::PostgresSql | DbDumpKind::MysqlSql);
|
||||
let creates_database = sql && String::from_utf8_lossy(head).lines().any(|l| l.starts_with("CREATE DATABASE "));
|
||||
DumpInfo { kind, creates_database }
|
||||
Ok(kind_of(&head))
|
||||
}
|
||||
|
||||
fn kind_of(head: &[u8]) -> DbDumpKind {
|
||||
@@ -292,12 +224,9 @@ fn kind_of(head: &[u8]) -> DbDumpKind {
|
||||
}
|
||||
}
|
||||
|
||||
/// Arguments and environment that connect `tool` at `executable` to `source` (already resolved,
|
||||
/// through its tunnel when it has one). The password is left to [`prepare`].
|
||||
pub fn connection(tool: DbTool, executable: &Path, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
|
||||
if tool.driver() == DbDriver::Mysql {
|
||||
return (mysql_connection(tool, executable, source), Vec::new());
|
||||
}
|
||||
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
|
||||
/// tunnel when it has one). The password is left to [`prepare`].
|
||||
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
|
||||
let mut args = Vec::new();
|
||||
let host = source.host.trim();
|
||||
if !host.is_empty() {
|
||||
@@ -342,50 +271,6 @@ pub fn connection(tool: DbTool, executable: &Path, source: &DataSource) -> (Vec<
|
||||
(args, env)
|
||||
}
|
||||
|
||||
/// The database is the job's: a dump may name several.
|
||||
fn mysql_connection(tool: DbTool, executable: &Path, source: &DataSource) -> Vec<String> {
|
||||
let mut args = Vec::new();
|
||||
let host = source.host.trim();
|
||||
if !host.is_empty() {
|
||||
args.push(format!("--host={host}"));
|
||||
}
|
||||
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(3306)));
|
||||
if !source.user.trim().is_empty() {
|
||||
args.push(format!("--user={}", source.user.trim()));
|
||||
}
|
||||
// `localhost` would otherwise mean the Unix socket, not the port or the tunnel.
|
||||
args.push("--protocol=TCP".into());
|
||||
if is_mariadb(executable) {
|
||||
let flags: &[&str] = match source.ssl {
|
||||
DbSslMode::Disable => &["--skip-ssl"],
|
||||
DbSslMode::Prefer => &["--skip-ssl-verify-server-cert"],
|
||||
DbSslMode::Require => &["--ssl", "--skip-ssl-verify-server-cert"],
|
||||
DbSslMode::VerifyCa | DbSslMode::VerifyFull => &["--ssl", "--ssl-verify-server-cert"],
|
||||
};
|
||||
args.extend(flags.iter().map(|f| f.to_string()));
|
||||
} else {
|
||||
let mode = match source.ssl {
|
||||
DbSslMode::Disable => "DISABLED",
|
||||
DbSslMode::Prefer => "PREFERRED",
|
||||
DbSslMode::Require => "REQUIRED",
|
||||
DbSslMode::VerifyCa => "VERIFY_CA",
|
||||
DbSslMode::VerifyFull => "VERIFY_IDENTITY",
|
||||
};
|
||||
args.push(format!("--ssl-mode={mode}"));
|
||||
}
|
||||
for (flag, file) in
|
||||
[("--ssl-ca", &source.ssl_ca_file), ("--ssl-cert", &source.ssl_cert_file), ("--ssl-key", &source.ssl_key_file)]
|
||||
{
|
||||
if !file.trim().is_empty() {
|
||||
args.push(format!("{flag}={}", ide_ssh::expand(file.trim()).to_string_lossy()));
|
||||
}
|
||||
}
|
||||
if tool == DbTool::Mysql && source.read_only {
|
||||
args.push("--init-command=SET SESSION TRANSACTION READ ONLY".into());
|
||||
}
|
||||
args
|
||||
}
|
||||
|
||||
/// `--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 {
|
||||
@@ -396,88 +281,36 @@ fn dbname_arg(name: &str) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// A MySQL client option file holding the password, readable by the user only; deleted on drop.
|
||||
struct SecretFile(PathBuf);
|
||||
|
||||
impl SecretFile {
|
||||
fn mysql_password(password: &str) -> IdeResult<Self> {
|
||||
use std::io::Write;
|
||||
let path = std::env::temp_dir().join(format!("openidea-mysql-{}.cnf", uuid::Uuid::new_v4()));
|
||||
let mut options = std::fs::OpenOptions::new();
|
||||
options.write(true).create_new(true);
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
|
||||
let mut file = options.open(&path)?;
|
||||
let secret = SecretFile(path);
|
||||
let escaped = password.replace('\\', "\\\\").replace('"', "\\\"");
|
||||
writeln!(file, "[client]\npassword=\"{escaped}\"")?;
|
||||
Ok(secret)
|
||||
}
|
||||
|
||||
/// `mysqldump` / `mysql` accept it only as their first argument.
|
||||
fn arg(&self) -> String {
|
||||
format!("--defaults-extra-file={}", self.0.display())
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for SecretFile {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// How a tool is started: connection arguments, then the job's, the environment, and the file
|
||||
/// piped to its standard input. Keep it until the tool exits: it owns the password file.
|
||||
/// How a tool is started: connection arguments, then the job's, and the environment.
|
||||
pub struct Prepared {
|
||||
pub args: Vec<String>,
|
||||
pub env: Vec<(String, String)>,
|
||||
pub input: Option<PathBuf>,
|
||||
_secret: Option<SecretFile>,
|
||||
}
|
||||
|
||||
/// The command for `job` at `executable` against `source`. The password goes in `PGPASSWORD` or
|
||||
/// a MySQL option file, never in the arguments, which other users of the machine can read in the
|
||||
/// process list.
|
||||
pub fn prepare(job: &DbToolJob, executable: &Path, source: &DataSource, password: Option<&str>) -> IdeResult<Prepared> {
|
||||
job.check()?;
|
||||
let tool = job.tool();
|
||||
let (mut args, mut env) = connection(tool, executable, source);
|
||||
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
|
||||
/// arguments, which other users of the machine can read in the process list.
|
||||
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
|
||||
let (mut args, mut env) = connection(job.tool(), source);
|
||||
args.extend(job.args());
|
||||
let mut secret = None;
|
||||
match password.filter(|p| !p.is_empty()) {
|
||||
Some(p) if tool.driver() == DbDriver::Mysql => {
|
||||
let file = SecretFile::mysql_password(p)?;
|
||||
args.insert(0, file.arg());
|
||||
secret = Some(file);
|
||||
}
|
||||
Some(p) => env.push(("PGPASSWORD".into(), p.to_owned())),
|
||||
None => {}
|
||||
if let Some(p) = password.filter(|p| !p.is_empty()) {
|
||||
env.push(("PGPASSWORD".into(), p.to_owned()));
|
||||
}
|
||||
Ok(Prepared { args, env, input: job.input().map(PathBuf::from), _secret: secret })
|
||||
Prepared { args, env }
|
||||
}
|
||||
|
||||
/// Runs `program` until it exits, passing its output in batches; `input` is piped to its standard
|
||||
/// input. Returns the exit code (`None`: ended by a signal). Cancelling kills it and everything it
|
||||
/// started.
|
||||
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
|
||||
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
|
||||
pub async fn run(
|
||||
program: &Path,
|
||||
args: &[String],
|
||||
env: &[(String, String)],
|
||||
input: Option<&Path>,
|
||||
cancel: &CancellationToken,
|
||||
mut on_output: impl FnMut(Vec<ToolLine>),
|
||||
) -> IdeResult<Option<i32>> {
|
||||
let stdin = match input {
|
||||
Some(path) => Stdio::from(
|
||||
std::fs::File::open(path)
|
||||
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?,
|
||||
),
|
||||
None => Stdio::null(),
|
||||
};
|
||||
let mut cmd = tokio::process::Command::new(program);
|
||||
cmd.args(args)
|
||||
.envs(env.iter().map(|(k, v)| (k, v)))
|
||||
.stdin(stdin)
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
@@ -575,7 +408,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn connects_like_the_data_source_without_prompting() {
|
||||
let (args, env) = connection(DbTool::PgDump, Path::new("pg_dump"), &pg());
|
||||
let (args, env) = connection(DbTool::PgDump, &pg());
|
||||
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
|
||||
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
|
||||
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
|
||||
@@ -588,8 +421,7 @@ mod tests {
|
||||
(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, Path::new("pg_dump"), &DataSource { database: name.into(), ..pg() });
|
||||
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
|
||||
assert!(args.contains(&arg.to_owned()), "{args:?}");
|
||||
}
|
||||
}
|
||||
@@ -597,14 +429,14 @@ mod tests {
|
||||
#[test]
|
||||
fn default_port_and_optional_fields() {
|
||||
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
|
||||
let (args, _) = connection(DbTool::Psql, Path::new("psql"), &source);
|
||||
let (args, _) = connection(DbTool::Psql, &source);
|
||||
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_only_sources_refuse_writes() {
|
||||
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
|
||||
let (_, env) = connection(DbTool::PgRestore, Path::new("pg_restore"), &source);
|
||||
let (_, env) = connection(DbTool::PgRestore, &source);
|
||||
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
|
||||
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
|
||||
}
|
||||
@@ -619,77 +451,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_tools_accept_mariadb_names_only_for_themselves() {
|
||||
assert!(DbTool::Mysqldump.is_program(Path::new("/usr/bin/mariadb-dump")));
|
||||
assert!(DbTool::Mysql.is_program(Path::new("/opt/homebrew/opt/mysql-client/bin/mysql")));
|
||||
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mysqldump")));
|
||||
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mariadb-dump")));
|
||||
assert!(!DbTool::Mysqldump.is_program(Path::new("/usr/bin/mysqlpump")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_connects_over_tcp_with_the_ssl_flags_of_its_client() {
|
||||
let source = DataSource {
|
||||
driver: DbDriver::Mysql,
|
||||
host: "localhost".into(),
|
||||
port: None,
|
||||
user: "app".into(),
|
||||
read_only: true,
|
||||
..DataSource::default()
|
||||
};
|
||||
let (args, env) = connection(DbTool::Mysql, Path::new("/usr/bin/mysql"), &source);
|
||||
assert_eq!(
|
||||
args,
|
||||
[
|
||||
"--host=localhost",
|
||||
"--port=3306",
|
||||
"--user=app",
|
||||
"--protocol=TCP",
|
||||
"--ssl-mode=PREFERRED",
|
||||
"--init-command=SET SESSION TRANSACTION READ ONLY"
|
||||
]
|
||||
);
|
||||
assert!(env.is_empty());
|
||||
let (args, _) = connection(DbTool::Mysqldump, Path::new("/usr/bin/mariadb-dump"), &source);
|
||||
assert!(args.contains(&"--skip-ssl-verify-server-cert".to_owned()));
|
||||
assert!(!args.iter().any(|a| a.starts_with("--ssl-mode") || a.starts_with("--init-command")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_password_file_is_private_and_removed() {
|
||||
let file = SecretFile::mysql_password(r#"p"a\ss"#).unwrap();
|
||||
let path = file.arg().trim_start_matches("--defaults-extra-file=").to_owned();
|
||||
let text = std::fs::read_to_string(&path).unwrap();
|
||||
assert_eq!(text, "[client]\npassword=\"p\\\"a\\\\ss\"\n");
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
|
||||
}
|
||||
drop(file);
|
||||
assert!(!Path::new(&path).exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_long_options_from_help() {
|
||||
let help = "Usage: mysqldump [OPTIONS]\n -A, --all-databases Dump all.\n --masking-policies Dump masking\n policies (--not-an-option).\n -y, --no-tablespaces \n -f, --file=FILENAME output file\n";
|
||||
assert_eq!(help_options(help), ["all-databases", "file", "masking-policies", "no-tablespaces"]);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn pipes_the_input_file() {
|
||||
let file = std::env::temp_dir().join(format!("openidea-input-{}", uuid::Uuid::new_v4()));
|
||||
std::fs::write(&file, "from the file\n").unwrap();
|
||||
let mut lines = Vec::new();
|
||||
run(Path::new("/bin/cat"), &[], &[], Some(&file), &CancellationToken::new(), |b| lines.extend(b))
|
||||
.await
|
||||
.unwrap();
|
||||
std::fs::remove_file(&file).unwrap();
|
||||
assert_eq!(lines, [ToolLine { stderr: false, text: "from the file".into() }]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tells_dumps_apart_by_their_header() {
|
||||
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
|
||||
@@ -700,17 +461,6 @@ mod tests {
|
||||
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sees_a_dump_that_creates_its_own_database() {
|
||||
let one = b"-- MySQL dump 10.13\n--\n-- Host: localhost Database: shop\nCREATE TABLE `items` (id int);\n";
|
||||
assert!(!info_of(one).creates_database);
|
||||
let several = b"-- MySQL dump 10.13\n--\n-- Current Database: `shop`\n--\n\nCREATE DATABASE /*!32312 IF NOT EXISTS*/ `shop`;\nUSE `shop`;\n";
|
||||
assert!(info_of(several).creates_database);
|
||||
let pg = b"--\n-- PostgreSQL database dump\n--\nSET client_encoding = 'UTF8';\nCREATE DATABASE shop WITH TEMPLATE = template0;\n\\connect shop\n";
|
||||
assert_eq!(info_of(pg), DumpInfo { kind: DbDumpKind::PostgresSql, creates_database: true });
|
||||
assert!(!info_of(b"CREATE DATABASE x;\n").creates_database, "only for a dump the tools wrote");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn newer_versions_sort_first() {
|
||||
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
|
||||
@@ -724,7 +474,6 @@ mod tests {
|
||||
Path::new("/bin/sh"),
|
||||
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
|
||||
&[],
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
|batch| lines.extend(batch),
|
||||
)
|
||||
@@ -744,25 +493,19 @@ mod tests {
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
stop.cancel();
|
||||
});
|
||||
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], None, &cancel, |_| {}).await;
|
||||
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
|
||||
assert!(result.is_err());
|
||||
}
|
||||
|
||||
/// A stand-in for `tool` that prints each argument on a line, then whether it got a password
|
||||
/// from `PGPASSWORD` or a MySQL option file.
|
||||
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
|
||||
/// holds the expected password.
|
||||
#[cfg(unix)]
|
||||
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = dir.join(tool.program());
|
||||
std::fs::write(
|
||||
&path,
|
||||
concat!(
|
||||
"#!/bin/sh\n",
|
||||
"for a in \"$@\"; do echo \"arg:$a\"; case \"$a\" in --defaults-extra-file=*)\n",
|
||||
" grep -q '^password=' \"${a#*=}\" && echo env:set;; esac; done\n",
|
||||
"[ -n \"$PGPASSWORD\" ] && echo env:set\n",
|
||||
"exit 0\n",
|
||||
),
|
||||
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
@@ -798,48 +541,17 @@ mod tests {
|
||||
file: file.clone(),
|
||||
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
|
||||
},
|
||||
DbToolJob::Mysqldump {
|
||||
file: file.clone(),
|
||||
options: DbMysqldumpOptions {
|
||||
databases: vec!["shop".into()],
|
||||
tables: vec![],
|
||||
add_drop_table: true,
|
||||
disable_keys: true,
|
||||
add_locks: true,
|
||||
add_drop_trigger: false,
|
||||
no_data: false,
|
||||
complete_insert: false,
|
||||
create_options: true,
|
||||
routines: false,
|
||||
events: false,
|
||||
single_transaction: true,
|
||||
lock_all_tables: false,
|
||||
masking_policies: None,
|
||||
},
|
||||
},
|
||||
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: "shop".into(), force: false } },
|
||||
];
|
||||
for job in jobs {
|
||||
let mysql = job.tool().driver() == DbDriver::Mysql;
|
||||
let source = if mysql { DataSource { driver: DbDriver::Mysql, ..pg() } } else { pg() };
|
||||
let program = echo_tool(&dir, job.tool());
|
||||
let prepared = prepare(&job, &program, &source, Some(SECRET)).unwrap();
|
||||
let prepared = prepare(&job, &pg(), Some(SECRET));
|
||||
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
|
||||
assert!(!mysql || prepared.env.is_empty(), "{:?}", prepared.env);
|
||||
let mut lines = Vec::new();
|
||||
run(&program, &prepared.args, &prepared.env, None, &CancellationToken::new(), |b| lines.extend(b))
|
||||
.await
|
||||
.unwrap();
|
||||
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
|
||||
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
|
||||
let database = if mysql { "shop" } else { "--dbname=shop" };
|
||||
assert!(text.iter().any(|l| l.strip_prefix("arg:").is_some_and(|a| a.ends_with(database))), "{text:?}");
|
||||
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
|
||||
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
|
||||
assert!(text.contains(&"env:set"), "the tool gets the password: {text:?}");
|
||||
if mysql {
|
||||
let file = prepared.args[0].trim_start_matches("--defaults-extra-file=").to_owned();
|
||||
drop(prepared);
|
||||
assert!(!Path::new(&file).exists(), "the password file outlives the run");
|
||||
}
|
||||
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
|
||||
}
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
|
||||
@@ -231,70 +231,3 @@ async fn servers_that_advertise_deprecate_eof_but_send_legacy_eof_packets() -> I
|
||||
assert_eq!(r.rows, vec![vec![Some("a".into())], vec![Some("b".into())]]);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `mysqldump` into a file and `mysql` reading it back, with the data source's password.
|
||||
#[tokio::test]
|
||||
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
|
||||
use ide_db::tools::{DbMysqlOptions, DbMysqldumpOptions, DbTool, DbToolJob, find_installs};
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp, "").await else { return Ok(()) };
|
||||
let (Some(dump), Some(client)) =
|
||||
(find_installs(DbTool::Mysqldump).into_iter().next(), find_installs(DbTool::Mysql).into_iter().next())
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
let c = CancellationToken::new();
|
||||
for stmt in [
|
||||
"DROP DATABASE IF EXISTS oi_dump_src",
|
||||
"DROP DATABASE IF EXISTS oi_dump_dst",
|
||||
"CREATE DATABASE oi_dump_src",
|
||||
"CREATE DATABASE oi_dump_dst",
|
||||
"CREATE TABLE oi_dump_src.items (id INT PRIMARY KEY, tag VARCHAR(20))",
|
||||
"INSERT INTO oi_dump_src.items VALUES (1, 'dumped')",
|
||||
] {
|
||||
db.execute("m", stmt, 1, &c).await?;
|
||||
}
|
||||
let file = tmp.path().join("src.sql").to_string_lossy().into_owned();
|
||||
let run = |executable: String, job: DbToolJob| {
|
||||
let db = &db;
|
||||
async move {
|
||||
let mut lines = Vec::new();
|
||||
let code =
|
||||
db.run_tool("m", executable.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
|
||||
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
|
||||
IdeResult::Ok(())
|
||||
}
|
||||
};
|
||||
let masking = ide_db::tools::options_of(dump.path.as_ref())?.iter().any(|o| o == "masking-policies");
|
||||
let options = DbMysqldumpOptions {
|
||||
databases: vec!["oi_dump_src".into()],
|
||||
tables: vec![],
|
||||
add_drop_table: true,
|
||||
disable_keys: true,
|
||||
add_locks: true,
|
||||
add_drop_trigger: false,
|
||||
no_data: false,
|
||||
complete_insert: false,
|
||||
create_options: true,
|
||||
routines: false,
|
||||
events: false,
|
||||
single_transaction: true,
|
||||
lock_all_tables: false,
|
||||
masking_policies: masking.then_some(false),
|
||||
};
|
||||
run(dump.path.clone(), DbToolJob::Mysqldump { file: file.clone(), options: options.clone() }).await?;
|
||||
assert!(!ide_db::tools::dump_info(file.as_ref())?.creates_database, "one database: restored into a chosen one");
|
||||
let both = tmp.path().join("both.sql").to_string_lossy().into_owned();
|
||||
let two = DbMysqldumpOptions { databases: vec!["oi_dump_src".into(), "oi_dump_dst".into()], ..options };
|
||||
run(dump.path, DbToolJob::Mysqldump { file: both.clone(), options: two }).await?;
|
||||
assert!(ide_db::tools::dump_info(both.as_ref())?.creates_database, "several databases: created by the dump");
|
||||
let restore = DbMysqlOptions { database: "oi_dump_dst".into(), force: false };
|
||||
run(client.path, DbToolJob::Mysql { file, options: restore }).await?;
|
||||
|
||||
let r = db.execute("m", "SELECT tag FROM oi_dump_dst.items", 1, &c).await?;
|
||||
assert_eq!(r.rows[0][0].as_deref(), Some("dumped"));
|
||||
for stmt in ["DROP DATABASE oi_dump_src", "DROP DATABASE oi_dump_dst"] {
|
||||
db.execute("m", stmt, 1, &c).await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -230,44 +230,6 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
|
||||
}
|
||||
|
||||
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
|
||||
#[tokio::test]
|
||||
async fn drops_a_database_the_ide_holds_connections_to() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_drop_me", 0, &c).await?;
|
||||
db.execute("p", "CREATE DATABASE oi_drop_me TEMPLATE template0", 0, &c).await?;
|
||||
|
||||
// What the tree and a manual-commit console leave open on the database.
|
||||
db.schemas("p:oi_drop_me").await?;
|
||||
db.set_manual_commit("p:oi_drop_me", true).await?;
|
||||
db.execute("p:oi_drop_me", "SELECT 1", 1, &c).await?;
|
||||
|
||||
db.drop_database("p", "oi_drop_me", "drop database oi_drop_me").await?;
|
||||
assert!(!db.is_connected("p:oi_drop_me"));
|
||||
assert!(!db.databases("p").await?.names.iter().any(|n| n == "oi_drop_me"));
|
||||
|
||||
let current = db.databases("p").await?.current;
|
||||
let refused = db.drop_database("p", ¤t, &format!("drop database \"{current}\"")).await;
|
||||
assert!(refused.is_err());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn creates_a_database_from_a_template_the_ide_holds_connections_to() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_from_template", 0, &c).await?;
|
||||
db.schemas("p:template1").await?;
|
||||
|
||||
db.create_database("p", "template1", "create database oi_from_template").await?;
|
||||
assert!(!db.is_connected("p:template1"));
|
||||
assert!(db.databases("p").await?.names.iter().any(|n| n == "oi_from_template"));
|
||||
db.execute("p", "DROP DATABASE oi_from_template", 0, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
|
||||
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
|
||||
let mut lines = Vec::new();
|
||||
@@ -320,7 +282,6 @@ async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
|
||||
let restore = DbPgRestoreOptions {
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
create: false,
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
no_owner: false,
|
||||
|
||||
@@ -95,44 +95,3 @@ async fn sqlserver_values_paging_transactions_and_cancellation() {
|
||||
task.await.unwrap();
|
||||
assert_eq!(pool.rows("SELECT 1", 1).await.unwrap()[0][0].as_deref(), Some("1"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sqlserver_creates_from_a_held_model_and_force_drops_a_held_database() {
|
||||
let Ok(server) = std::env::var("OPENIDEA_TEST_SQLSERVER") else { return };
|
||||
let mut parts = server.splitn(4, ':');
|
||||
let (host, port, user, password) = (
|
||||
parts.next().unwrap(),
|
||||
parts.next().unwrap().parse().unwrap(),
|
||||
parts.next().unwrap(),
|
||||
parts.next().unwrap_or(""),
|
||||
);
|
||||
let source = |database: &str| DataSource {
|
||||
id: "s".into(),
|
||||
name: "sqlserver".into(),
|
||||
driver: DbDriver::SqlServer,
|
||||
host: host.into(),
|
||||
port: Some(port),
|
||||
user: user.into(),
|
||||
database: database.into(),
|
||||
ssl: DbSslMode::Disable,
|
||||
..Default::default()
|
||||
};
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().to_path_buf();
|
||||
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
|
||||
let db = ide_db::DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);
|
||||
db.save_sources(vec![source("master")]).await.unwrap();
|
||||
db.set_password("s", Some(password.into()), false).await.unwrap();
|
||||
let name = format!("oi_force_drop_{}", std::process::id());
|
||||
// The tree's connection to `model` would keep SQL Server from copying it.
|
||||
db.schemas("s:model").await.unwrap();
|
||||
db.create_database("s", "model", &format!("create database {name};")).await.unwrap();
|
||||
assert!(!db.is_connected("s:model"));
|
||||
|
||||
let other = Pool::connect(&source(&name), Some(password), None).await.unwrap();
|
||||
let held = Held::acquire(&other).await.unwrap();
|
||||
let force = format!("alter database {name} set single_user with rollback immediate;\ndrop database {name};");
|
||||
db.drop_database("s", &name, &force).await.unwrap();
|
||||
assert!(!db.databases("s").await.unwrap().names.contains(&name));
|
||||
drop(held);
|
||||
}
|
||||
@@ -38,8 +38,6 @@ pub enum Capability {
|
||||
InputEvents,
|
||||
/// The system clipboard, from the plugin's web views.
|
||||
Clipboard,
|
||||
/// Read the clipboard from commands and view actions the user ran (API 1.11).
|
||||
ClipboardRead,
|
||||
/// HTTPS (and loopback HTTP) to one host (`*.example.com` matches subdomains).
|
||||
Net(String),
|
||||
/// Ask the user when the first request goes to an HTTPS (or loopback) host
|
||||
@@ -90,8 +88,7 @@ impl Capability {
|
||||
| Self::NetHttp(_)
|
||||
| Self::Secrets
|
||||
| Self::InputEvents
|
||||
| Self::Clipboard
|
||||
| Self::ClipboardRead => Risk::Medium,
|
||||
| Self::Clipboard => Risk::Medium,
|
||||
// A trusted project's own files name the programs the IDE starts (its settings, its
|
||||
// build scripts), so writing them is running code.
|
||||
Self::ProjectWrite
|
||||
@@ -130,7 +127,6 @@ impl Capability {
|
||||
Self::Clipboard => {
|
||||
"Copy to the clipboard from its commands, and read and write it from its web views".into()
|
||||
}
|
||||
Self::ClipboardRead => "Read the clipboard's text and images when you run one of its commands".into(),
|
||||
Self::Net(host) => format!("Connect to {host} (from the machine the project is on)"),
|
||||
Self::NetAsk => {
|
||||
"Ask to connect to a host that is not on the list the first time it tries; you allow or refuse each host, and can revoke the allowed ones"
|
||||
@@ -266,7 +262,6 @@ impl fmt::Display for Capability {
|
||||
Self::Events => f.write_str("events"),
|
||||
Self::InputEvents => f.write_str("events.input"),
|
||||
Self::Clipboard => f.write_str("clipboard"),
|
||||
Self::ClipboardRead => f.write_str("clipboard.read"),
|
||||
Self::Net(h) => write!(f, "net:{h}"),
|
||||
Self::NetAsk => f.write_str("net:ask"),
|
||||
Self::NetHttp(h) => write!(f, "net.http:{h}"),
|
||||
@@ -353,7 +348,6 @@ impl FromStr for Capability {
|
||||
"events" => Self::Events,
|
||||
"events.input" => Self::InputEvents,
|
||||
"clipboard" => Self::Clipboard,
|
||||
"clipboard.read" => Self::ClipboardRead,
|
||||
"java.agent" => Self::JavaAgent,
|
||||
_ => return Err(format!("unknown capability {s:?}")),
|
||||
})
|
||||
@@ -404,7 +398,6 @@ mod tests {
|
||||
"project.write",
|
||||
"vcs.write",
|
||||
"build.read",
|
||||
"clipboard.read",
|
||||
"storage",
|
||||
"secrets",
|
||||
"events",
|
||||
@@ -446,10 +439,6 @@ mod tests {
|
||||
assert_eq!(Capability::InputEvents.risk(), Risk::Medium);
|
||||
assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
|
||||
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
|
||||
// Reading is its own grant: neither clipboard capability covers the other.
|
||||
assert_eq!(Capability::ClipboardRead.risk(), Risk::Medium);
|
||||
assert!(!Capability::Clipboard.covers(&Capability::ClipboardRead));
|
||||
assert!(!Capability::ClipboardRead.covers(&Capability::Clipboard));
|
||||
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
|
||||
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
|
||||
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
|
||||
|
||||
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
|
||||
|
||||
pub const MANIFEST_FILE: &str = "plugin.toml";
|
||||
/// The plugin API (engine) version this host implements.
|
||||
pub const ENGINE_VERSION: &str = "1.11.0";
|
||||
pub const ENGINE_VERSION: &str = "1.10.0";
|
||||
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
|
||||
pub const LEGACY_API: &str = "0.1";
|
||||
/// Marketplace categories, in the order they are shown.
|
||||
@@ -363,9 +363,6 @@ impl Manifest {
|
||||
if matches!(cap, Capability::BuildRead) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 10)?;
|
||||
}
|
||||
if matches!(cap, Capability::ClipboardRead) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 11)?;
|
||||
}
|
||||
if matches!(cap, Capability::JavaAgent) {
|
||||
return Err(
|
||||
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
|
||||
@@ -749,14 +746,6 @@ required = [\"lsp:phoxite\"]
|
||||
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_clipboard_read_capability_needs_api_1_11() {
|
||||
let caps = "[capabilities]\noptional = [\"clipboard.read\"]\n";
|
||||
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("new in plugin API 1.11"));
|
||||
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.11"))).unwrap();
|
||||
assert_eq!(m.capabilities.optional, [Capability::ClipboardRead]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_agent_capability_is_not_declared() {
|
||||
for list in ["required", "optional"] {
|
||||
|
||||
@@ -1,426 +0,0 @@
|
||||
//! The project's direnv environment: when the project root has an `.envrc`, `direnv export
|
||||
//! json` runs there and every child started in the project gets what it exports
|
||||
//! ([`ide_core::project_env`]): terminals, runs, language servers (which wait for it), build
|
||||
//! tools and debuggers, locally and on a remote host alike. An `.envrc` with `use flake`
|
||||
//! loads a Nix flake's devshell this way.
|
||||
//!
|
||||
//! `.envrc` is project code: it runs in trusted projects only, and only once the user
|
||||
//! allowed it with `direnv allow`, which the IDE never does for them.
|
||||
|
||||
use ide_core::event::DirenvStatus;
|
||||
use ide_core::{CancellationToken, IdeEvent, SharedSink, TaskId};
|
||||
use std::collections::BTreeMap;
|
||||
use std::ffi::OsString;
|
||||
use std::io::{BufRead, BufReader, Read};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Stdio};
|
||||
use std::sync::mpsc::RecvTimeoutError;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
pub(crate) const ENVRC: &str = ".envrc";
|
||||
|
||||
/// Files in the project root whose change offers a reload: the `.envrc` and the flake
|
||||
/// `use flake` evaluates.
|
||||
const WATCHED: [&str; 3] = [ENVRC, "flake.nix", "flake.lock"];
|
||||
|
||||
/// A cold `use flake` builds or downloads the devshell: minutes, not seconds.
|
||||
pub(crate) const TIMEOUT: Duration = Duration::from_secs(10 * 60);
|
||||
|
||||
/// Output lines kept for a failure's notification.
|
||||
const TAIL_LINES: usize = 12;
|
||||
|
||||
pub(crate) type Changes = Vec<(OsString, Option<OsString>)>;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub(crate) enum Failure {
|
||||
/// The user hasn't allowed this `.envrc` (`direnv allow`).
|
||||
Blocked,
|
||||
Failed(String),
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
pub(crate) fn has_envrc(root: &Path) -> bool {
|
||||
root.join(ENVRC).is_file()
|
||||
}
|
||||
|
||||
/// `direnv` on the IDE's search path.
|
||||
pub(crate) fn program() -> Option<PathBuf> {
|
||||
ide_core::process::find_executable("direnv", &ide_core::tool_path::search_path())
|
||||
}
|
||||
|
||||
/// The watched file among `paths` (changed or removed below `root`), when the project has an
|
||||
/// `.envrc` or just lost it: what a reload would pick up.
|
||||
pub(crate) fn reload_offer<'a>(root: &Path, paths: impl IntoIterator<Item = &'a PathBuf>) -> Option<String> {
|
||||
let file = paths
|
||||
.into_iter()
|
||||
.filter(|p| p.parent() == Some(root))
|
||||
.filter_map(|p| p.file_name()?.to_str())
|
||||
.find(|name| WATCHED.contains(name))?;
|
||||
(file == ENVRC || has_envrc(root)).then(|| file.to_owned())
|
||||
}
|
||||
|
||||
/// Runs `program export json` in `root` from the environment children outside any project
|
||||
/// get (not the project's last one: a reload must not see its own result), reporting
|
||||
/// direnv's progress lines to `on_line`. Gives up after `timeout` or once `cancel` fires,
|
||||
/// stopping what direnv started (`nix`) too.
|
||||
pub(crate) fn export(
|
||||
program: &Path,
|
||||
root: &Path,
|
||||
timeout: Duration,
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(&str),
|
||||
) -> Result<Changes, Failure> {
|
||||
let mut cmd = Command::new(program);
|
||||
ide_core::process::prepare(ide_core::process::own_group(&mut cmd));
|
||||
let mut child = cmd
|
||||
.args(["export", "json"])
|
||||
.current_dir(root)
|
||||
.env_clear()
|
||||
.envs(ide_core::process::host_vars())
|
||||
.envs(ide_core::process::shell_env())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()
|
||||
.map_err(|e| Failure::Failed(format!("cannot start {}: {e}", program.display())))?;
|
||||
let mut stdout = child.stdout.take().expect("piped");
|
||||
let out = std::thread::spawn(move || {
|
||||
let mut buf = Vec::new();
|
||||
stdout.read_to_end(&mut buf).map(|_| buf)
|
||||
});
|
||||
let (tx, rx) = std::sync::mpsc::channel::<String>();
|
||||
let stderr = child.stderr.take().expect("piped");
|
||||
std::thread::spawn(move || {
|
||||
for line in BufReader::new(stderr).split(b'\n').map_while(Result::ok) {
|
||||
let line = ide_core::output_encoding::decode_tool_output(&line).trim_end_matches('\r').to_owned();
|
||||
if tx.send(line).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
let deadline = Instant::now() + timeout;
|
||||
let mut tail: Vec<String> = Vec::new();
|
||||
let mut keep = |line: String| {
|
||||
on_line(&line);
|
||||
tail.push(line);
|
||||
let excess = tail.len().saturating_sub(TAIL_LINES);
|
||||
tail.drain(..excess);
|
||||
};
|
||||
loop {
|
||||
if cancel.is_cancelled() {
|
||||
ide_core::process::kill_tree(&mut child);
|
||||
return Err(Failure::Cancelled);
|
||||
}
|
||||
if Instant::now() > deadline {
|
||||
ide_core::process::kill_tree(&mut child);
|
||||
return Err(Failure::Failed(format!(
|
||||
"direnv did not finish within {} minutes.\n\n{}",
|
||||
timeout.as_secs() / 60,
|
||||
tail.join("\n")
|
||||
)));
|
||||
}
|
||||
match rx.recv_timeout(Duration::from_millis(50)) {
|
||||
Ok(line) => keep(line),
|
||||
Err(RecvTimeoutError::Timeout) => {}
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
let status = child.wait().map_err(|e| Failure::Failed(e.to_string()))?;
|
||||
let stdout = out.join().ok().and_then(Result::ok).unwrap_or_default();
|
||||
if tail.iter().any(|l| l.contains("is blocked") || l.contains("is not allowed")) {
|
||||
return Err(Failure::Blocked);
|
||||
}
|
||||
if !status.success() {
|
||||
let tail = tail.join("\n");
|
||||
return Err(Failure::Failed(if tail.is_empty() { format!("direnv exited with {status}") } else { tail }));
|
||||
}
|
||||
parse(&stdout).map_err(Failure::Failed)
|
||||
}
|
||||
|
||||
/// `direnv export json`'s output: the variables to set, `null` for those to unset; nothing
|
||||
/// when there is nothing to change.
|
||||
fn parse(stdout: &[u8]) -> Result<Changes, String> {
|
||||
if stdout.iter().all(u8::is_ascii_whitespace) {
|
||||
return Ok(Changes::new());
|
||||
}
|
||||
let vars: BTreeMap<String, Option<String>> =
|
||||
serde_json::from_slice(stdout).map_err(|e| format!("unexpected output from direnv: {e}"))?;
|
||||
Ok(vars.into_iter().map(|(k, v)| (k.into(), v.map(Into::into))).collect())
|
||||
}
|
||||
|
||||
/// Loads `root`'s environment with `program` (`None`: direnv isn't installed) into
|
||||
/// [`ide_core::project_env`], as a cancellable background task; what went wrong is a
|
||||
/// [`IdeEvent::Direnv`]. `current` says whether this load still owns `root` (not closed or
|
||||
/// superseded by a newer one meanwhile) and is checked again before anything is applied.
|
||||
pub(crate) fn load(
|
||||
root: &Path,
|
||||
program: Option<&Path>,
|
||||
sink: &SharedSink,
|
||||
cancel: &CancellationToken,
|
||||
timeout: Duration,
|
||||
hint_missing: bool,
|
||||
current: &dyn Fn(&dyn Fn()),
|
||||
) {
|
||||
let report = |status: DirenvStatus| sink.emit(IdeEvent::Direnv { root: root.to_path_buf().into(), status });
|
||||
let Some(program) = program else {
|
||||
current(&|| ide_core::project_env::settle(root));
|
||||
if hint_missing {
|
||||
report(DirenvStatus::NotInstalled);
|
||||
}
|
||||
return;
|
||||
};
|
||||
let task = TaskId::next();
|
||||
let _cancel_handle = ide_core::task::on_cancel(task, {
|
||||
let cancel = cancel.clone();
|
||||
move || cancel.cancel()
|
||||
});
|
||||
let progress = |message: Option<String>, done: bool| {
|
||||
sink.emit(IdeEvent::Task {
|
||||
id: task,
|
||||
title: "Loading the direnv environment".into(),
|
||||
message,
|
||||
fraction: None,
|
||||
done,
|
||||
cancellable: !done,
|
||||
});
|
||||
};
|
||||
progress(Some(format!("{} export json", program.display())), false);
|
||||
let result = export(program, root, timeout, cancel, &|line| progress(Some(line.to_owned()), false));
|
||||
progress(None, true);
|
||||
match result {
|
||||
Ok(changes) => {
|
||||
tracing::info!("direnv: {} variables for {}", changes.len(), root.display());
|
||||
current(&|| ide_core::project_env::set(root, changes.clone()));
|
||||
}
|
||||
Err(Failure::Blocked) => {
|
||||
// As in a shell: a blocked `.envrc` isn't loaded.
|
||||
current(&|| ide_core::project_env::set(root, Changes::new()));
|
||||
report(DirenvStatus::Blocked);
|
||||
}
|
||||
Err(Failure::Failed(message)) => {
|
||||
tracing::warn!("direnv in {}: {message}", root.display());
|
||||
current(&|| ide_core::project_env::settle(root));
|
||||
report(DirenvStatus::Failed { message });
|
||||
}
|
||||
// Closed or superseded (that one settles), or stopped from the task list.
|
||||
Err(Failure::Cancelled) => current(&|| ide_core::project_env::settle(root)),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(test, unix))]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::EventSink;
|
||||
use parking_lot::Mutex;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// A stand-in `direnv`: checks its arguments, then prints `stderr` and `out.json` of the
|
||||
/// folder it runs in and exits with `code`, or blocks like direnv on an `.envrc` not allowed.
|
||||
fn fake_direnv(dir: &Path) -> PathBuf {
|
||||
let program = dir.join("direnv");
|
||||
std::fs::write(
|
||||
&program,
|
||||
r#"#!/bin/sh
|
||||
[ "$1 $2" = "export json" ] || { echo "direnv: unexpected arguments $*" >&2; exit 2; }
|
||||
echo "direnv: loading $PWD/.envrc" >&2
|
||||
[ -f slow ] && sleep 30
|
||||
[ -f blocked ] && { echo "direnv: error $PWD/.envrc is blocked. Run \`direnv allow\` to approve its content" >&2; exit 1; }
|
||||
[ -f stderr ] && cat stderr >&2
|
||||
[ -f out.json ] && cat out.json
|
||||
echo "direnv: export +NIX_DEV" >&2
|
||||
exit "$(cat code 2>/dev/null || echo 0)"
|
||||
"#,
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
program
|
||||
}
|
||||
|
||||
fn project() -> (tempfile::TempDir, PathBuf, PathBuf) {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
|
||||
std::fs::create_dir(&root).unwrap();
|
||||
std::fs::write(root.join(ENVRC), "use flake\n").unwrap();
|
||||
let program = fake_direnv(tmp.path());
|
||||
(tmp, root, program)
|
||||
}
|
||||
|
||||
fn run(program: &Path, root: &Path) -> (Result<Changes, Failure>, Vec<String>) {
|
||||
let lines = Mutex::new(Vec::new());
|
||||
let result = export(program, root, Duration::from_secs(20), &CancellationToken::new(), &|l| {
|
||||
lines.lock().push(l.to_owned())
|
||||
});
|
||||
(result, lines.into_inner())
|
||||
}
|
||||
|
||||
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
|
||||
(k.into(), v.map(Into::into))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exported_variables_are_set_and_unset() {
|
||||
let (_tmp, root, program) = project();
|
||||
std::fs::write(
|
||||
root.join("out.json"),
|
||||
r#"{"PATH":"/nix/store/abc-devshell/bin:/usr/bin","IN_NIX_SHELL":"impure","OLD":null}"#,
|
||||
)
|
||||
.unwrap();
|
||||
let (result, lines) = run(&program, &root);
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
[
|
||||
change("IN_NIX_SHELL", Some("impure")),
|
||||
change("OLD", None),
|
||||
change("PATH", Some("/nix/store/abc-devshell/bin:/usr/bin")),
|
||||
]
|
||||
);
|
||||
assert_eq!(lines, [format!("direnv: loading {}/.envrc", root.display()), "direnv: export +NIX_DEV".into()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_to_export_changes_nothing() {
|
||||
let (_tmp, root, program) = project();
|
||||
assert_eq!(run(&program, &root).0, Ok(Changes::new()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_blocked_envrc_is_reported_as_such() {
|
||||
let (_tmp, root, program) = project();
|
||||
std::fs::write(root.join("blocked"), "").unwrap();
|
||||
assert_eq!(run(&program, &root).0, Err(Failure::Blocked));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failure_reports_the_end_of_the_output() {
|
||||
let (_tmp, root, program) = project();
|
||||
std::fs::write(root.join("stderr"), "error: flake 'path:/p' does not provide attribute 'devShells'\n").unwrap();
|
||||
std::fs::write(root.join("code"), "1").unwrap();
|
||||
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
|
||||
assert!(message.contains("does not provide attribute 'devShells'"), "{message}");
|
||||
|
||||
std::fs::remove_file(root.join("code")).unwrap();
|
||||
std::fs::write(root.join("out.json"), "not json").unwrap();
|
||||
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
|
||||
assert!(message.starts_with("unexpected output from direnv"), "{message}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_slow_direnv_times_out_or_is_cancelled() {
|
||||
let (_tmp, root, program) = project();
|
||||
std::fs::write(root.join("slow"), "").unwrap();
|
||||
let started = Instant::now();
|
||||
let result = export(&program, &root, Duration::from_secs(2), &CancellationToken::new(), &|_| {});
|
||||
let Err(Failure::Failed(message)) = result else { panic!("a timeout") };
|
||||
assert!(message.starts_with("direnv did not finish within"), "{message}");
|
||||
assert!(message.contains("direnv: loading"), "{message}");
|
||||
|
||||
let cancel = CancellationToken::new();
|
||||
let c = cancel.clone();
|
||||
std::thread::spawn(move || {
|
||||
std::thread::sleep(Duration::from_millis(200));
|
||||
c.cancel();
|
||||
});
|
||||
assert_eq!(export(&program, &root, Duration::from_secs(60), &cancel, &|_| {}), Err(Failure::Cancelled));
|
||||
assert!(started.elapsed() < Duration::from_secs(20));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_program_is_a_start_failure() {
|
||||
let (_tmp, root, _) = project();
|
||||
let Err(Failure::Failed(message)) = run(Path::new("/openidea-no-such/direnv"), &root).0 else { panic!() };
|
||||
assert!(message.starts_with("cannot start"), "{message}");
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Events(Mutex<Vec<IdeEvent>>);
|
||||
impl EventSink for Events {
|
||||
fn emit(&self, e: IdeEvent) {
|
||||
self.0.lock().push(e);
|
||||
}
|
||||
}
|
||||
|
||||
fn statuses(events: &Events) -> Vec<DirenvStatus> {
|
||||
events
|
||||
.0
|
||||
.lock()
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
IdeEvent::Direnv { status, .. } => Some(status.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn load_with(root: &Path, program: Option<&Path>, hint: bool) -> Arc<Events> {
|
||||
let events = Arc::new(Events::default());
|
||||
let sink: SharedSink = events.clone();
|
||||
ide_core::project_env::begin_loading(root);
|
||||
load(root, program, &sink, &CancellationToken::new(), Duration::from_secs(20), hint, &|apply| apply());
|
||||
events
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn children_in_the_project_get_what_direnv_exported() {
|
||||
let (_tmp, root, program) = project();
|
||||
std::fs::write(root.join("out.json"), r#"{"OPENIDEA_TEST_DEVSHELL":"1"}"#).unwrap();
|
||||
let events = load_with(&root, Some(&program), true);
|
||||
assert!(statuses(&events).is_empty());
|
||||
assert!(!ide_core::project_env::is_loading(&root));
|
||||
let mut cmd = Command::new("true");
|
||||
cmd.current_dir(root.join("src"));
|
||||
ide_core::process::host_env(&mut cmd);
|
||||
assert!(cmd.get_envs().any(|(k, v)| k == "OPENIDEA_TEST_DEVSHELL" && v == Some("1".as_ref())));
|
||||
// A task shows the progress, and ends.
|
||||
let tasks: Vec<_> = events
|
||||
.0
|
||||
.lock()
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
IdeEvent::Task { message, done, .. } => Some((message.clone(), *done)),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert!(tasks.iter().any(|(m, _)| m.as_deref() == Some("direnv: export +NIX_DEV")), "{tasks:?}");
|
||||
assert_eq!(tasks.last(), Some(&(None, true)));
|
||||
|
||||
// Blocked after an edit: the environment goes, as in a shell.
|
||||
std::fs::write(root.join("blocked"), "").unwrap();
|
||||
let events = load_with(&root, Some(&program), true);
|
||||
assert_eq!(statuses(&events), [DirenvStatus::Blocked]);
|
||||
assert!(ide_core::project_env::for_dir(&root).is_empty());
|
||||
|
||||
// A failure keeps the last environment and says why.
|
||||
std::fs::remove_file(root.join("blocked")).unwrap();
|
||||
load_with(&root, Some(&program), true);
|
||||
std::fs::write(root.join("stderr"), "error: syntax error in flake.nix\n").unwrap();
|
||||
std::fs::write(root.join("code"), "1").unwrap();
|
||||
let events = load_with(&root, Some(&program), true);
|
||||
let [DirenvStatus::Failed { message }] = &statuses(&events)[..] else { panic!("{:?}", statuses(&events)) };
|
||||
assert!(message.contains("syntax error in flake.nix"), "{message}");
|
||||
assert!(!ide_core::project_env::for_dir(&root).is_empty());
|
||||
ide_core::project_env::remove(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direnv_not_installed_is_hinted_once_and_does_not_block() {
|
||||
let (_tmp, root, _) = project();
|
||||
let events = load_with(&root, None, true);
|
||||
assert_eq!(statuses(&events), [DirenvStatus::NotInstalled]);
|
||||
assert!(!ide_core::project_env::is_loading(&root), "language servers start anyway");
|
||||
assert!(statuses(&load_with(&root, None, false)).is_empty());
|
||||
ide_core::project_env::remove(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changes_to_the_envrc_or_flake_offer_a_reload() {
|
||||
let (_tmp, root, _) = project();
|
||||
let paths = |names: &[&str]| names.iter().map(|n| root.join(n)).collect::<Vec<_>>();
|
||||
assert_eq!(reload_offer(&root, &paths(&["src/main.rs", "flake.lock"])), Some("flake.lock".into()));
|
||||
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()));
|
||||
assert_eq!(reload_offer(&root, &paths(&["sub/flake.nix", "src/main.rs"])), None, "the project root's only");
|
||||
std::fs::remove_file(root.join(ENVRC)).unwrap();
|
||||
assert_eq!(reload_offer(&root, &paths(&["flake.nix"])), None, "no .envrc: nothing loads the flake");
|
||||
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()), "removed: reload unloads");
|
||||
}
|
||||
}
|
||||
@@ -1,11 +1,9 @@
|
||||
//! The environment child processes get beyond this process's own: the login shell's as
|
||||
//! re-read by Reload Environment, (remote server) the project's `devcontainer.json`
|
||||
//! `remoteEnv`, plus its `postStartCommand` once per server start, and each trusted
|
||||
//! project's direnv `.envrc` ([`crate::direnv`]).
|
||||
//! re-read by Reload Environment, and (remote server) the project's
|
||||
//! `devcontainer.json` `remoteEnv`, plus its `postStartCommand` once per server start.
|
||||
//!
|
||||
//! The first two reach every child through `ide_core::process::set_env_overlay`, a project's
|
||||
//! direnv environment the children started inside it (`ide_core::project_env`): terminals,
|
||||
//! runs, language servers, debug adapters, build tools and git all spawn through
|
||||
//! Both reach every child through `ide_core::process::set_env_overlay`: terminals, runs,
|
||||
//! language servers, debug adapters, build tools and git all spawn through
|
||||
//! `ide_core::process::prepare` / `host_env`.
|
||||
|
||||
use ide_core::event::NotifyLevel;
|
||||
@@ -20,7 +18,6 @@ use std::io::{BufRead, BufReader, Read};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Stdio};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
||||
use std::time::Duration;
|
||||
|
||||
type Changes = Vec<(OsString, Option<OsString>)>;
|
||||
@@ -54,87 +51,18 @@ struct State {
|
||||
post_commands: std::collections::HashMap<PathBuf, CancellationToken>,
|
||||
}
|
||||
|
||||
/// Project roots whose direnv environment is loaded or loading, with the load that owns
|
||||
/// each (a generation) and what stops it.
|
||||
type DirenvLoads = Arc<Mutex<std::collections::HashMap<PathBuf, (u64, CancellationToken)>>>;
|
||||
|
||||
pub struct Environment {
|
||||
/// Whether the open project's `devcontainer.json` applies (the remote server: one project per process).
|
||||
project_env: bool,
|
||||
data_dir: PathBuf,
|
||||
state: Mutex<State>,
|
||||
/// Stops running `postStartCommand`s and direnv loads when the host shuts down.
|
||||
/// Stops running `postStartCommand`s when the host shuts down.
|
||||
cancel: CancellationToken,
|
||||
direnv: DirenvLoads,
|
||||
/// "direnv is not installed" is said once per process.
|
||||
direnv_hinted: AtomicBool,
|
||||
}
|
||||
|
||||
impl Environment {
|
||||
pub(crate) fn new(project_env: bool, data_dir: PathBuf) -> Self {
|
||||
Self {
|
||||
project_env,
|
||||
data_dir,
|
||||
state: Mutex::default(),
|
||||
cancel: CancellationToken::new(),
|
||||
direnv: DirenvLoads::default(),
|
||||
direnv_hinted: AtomicBool::new(false),
|
||||
}
|
||||
}
|
||||
|
||||
/// A trusted project at `root` opened or became trusted: loads its direnv environment in
|
||||
/// the background, unless another window of it already did. Its language servers wait.
|
||||
pub(crate) fn direnv_opened(&self, root: &Path, sink: &SharedSink) {
|
||||
if !self.direnv.lock().contains_key(root) {
|
||||
self.load_direnv(root, sink, true);
|
||||
}
|
||||
}
|
||||
|
||||
/// The project at `root` closed in its last window, or is no longer trusted.
|
||||
pub(crate) fn direnv_closed(&self, root: &Path) {
|
||||
if let Some((_, cancel)) = self.direnv.lock().remove(root) {
|
||||
cancel.cancel();
|
||||
}
|
||||
ide_core::project_env::remove(root);
|
||||
}
|
||||
|
||||
/// (Re)loads `root`'s direnv environment, replacing a load still running; on this thread
|
||||
/// unless `background`. Without an `.envrc` the project has none.
|
||||
fn load_direnv(&self, root: &Path, sink: &SharedSink, background: bool) {
|
||||
static GENERATION: AtomicU64 = AtomicU64::new(0);
|
||||
let generation = GENERATION.fetch_add(1, Ordering::Relaxed);
|
||||
let cancel = self.cancel.child_token();
|
||||
{
|
||||
let mut loads = self.direnv.lock();
|
||||
if let Some((_, previous)) = loads.insert(root.to_path_buf(), (generation, cancel.clone())) {
|
||||
previous.cancel();
|
||||
}
|
||||
if !crate::direnv::has_envrc(root) {
|
||||
ide_core::project_env::remove(root);
|
||||
return;
|
||||
}
|
||||
// Before this returns: a language server starting next waits for it.
|
||||
ide_core::project_env::begin_loading(root);
|
||||
}
|
||||
let program = crate::direnv::program();
|
||||
let hint = program.is_none() && !self.direnv_hinted.swap(true, Ordering::AcqRel);
|
||||
let (loads, dir, sink) = (self.direnv.clone(), root.to_path_buf(), sink.clone());
|
||||
let run = move || {
|
||||
let current = |apply: &dyn Fn()| {
|
||||
let loads = loads.lock();
|
||||
if loads.get(&dir).is_some_and(|(g, _)| *g == generation) {
|
||||
apply();
|
||||
}
|
||||
};
|
||||
crate::direnv::load(&dir, program.as_deref(), &sink, &cancel, crate::direnv::TIMEOUT, hint, ¤t);
|
||||
};
|
||||
if !background {
|
||||
run();
|
||||
} else if let Err(e) = std::thread::Builder::new().name("openidea-direnv".into()).spawn(run) {
|
||||
tracing::warn!("direnv: {e}");
|
||||
// Language servers must not wait for a load that never runs.
|
||||
ide_core::project_env::settle(root);
|
||||
}
|
||||
Self { project_env, data_dir, state: Mutex::default(), cancel: CancellationToken::new() }
|
||||
}
|
||||
|
||||
pub(crate) fn shutdown(&self) {
|
||||
@@ -190,17 +118,11 @@ impl Environment {
|
||||
ide_core::process::set_env_overlay(merge(&state.login, &state.project));
|
||||
}
|
||||
|
||||
/// Reload Environment: reads the login shell again, re-applies the project's `remoteEnv`
|
||||
/// and loads its direnv environment again (`root`, a trusted project). Blocking (it runs
|
||||
/// the shell and direnv); children already running keep their environment.
|
||||
/// Reload Environment: reads the login shell again and re-applies the project's
|
||||
/// `remoteEnv` (`root`). Blocking (it runs the shell); children already running keep
|
||||
/// their environment.
|
||||
pub fn reload(&self, root: Option<&Path>, sink: &SharedSink) -> IdeResult<EnvReloaded> {
|
||||
let vars = || -> Vec<_> {
|
||||
match root {
|
||||
Some(root) => ide_core::process::host_vars_in(root).collect(),
|
||||
None => ide_core::process::host_vars().collect(),
|
||||
}
|
||||
};
|
||||
let before = vars();
|
||||
let before: Vec<_> = ide_core::process::host_vars().collect();
|
||||
let fresh = crate::shell_env::read_login_env_now().map_err(IdeError::unavailable)?;
|
||||
let shell_read = fresh.is_some();
|
||||
if let Some(fresh) = fresh {
|
||||
@@ -224,10 +146,7 @@ impl Environment {
|
||||
None
|
||||
}
|
||||
};
|
||||
if let Some(root) = root {
|
||||
self.load_direnv(root, sink, false);
|
||||
}
|
||||
let after = vars();
|
||||
let after: Vec<_> = ide_core::process::host_vars().collect();
|
||||
Ok(EnvReloaded { changed: changed_names(&before, &after), devcontainer, shell_read })
|
||||
}
|
||||
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
|
||||
use crate::Host;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::settings::{ExternalFormatter, LanguagesSettings, Settings};
|
||||
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, Pos, Range, TextEdit};
|
||||
use ide_language::{LanguageConfig, PhpAlignment, Syntax};
|
||||
use ide_core::settings::{ExternalFormatter, LanguagesSettings};
|
||||
use ide_core::{DocId, IdeError, IdeEvent, IdeResult, Pos, Range, TextEdit};
|
||||
use ide_language::LanguageConfig;
|
||||
use ide_lsp::types::FormatOptions;
|
||||
use ide_tools::{Tools, formatter};
|
||||
use std::path::Path;
|
||||
@@ -129,101 +129,12 @@ pub async fn format(
|
||||
let project = host.project(window)?;
|
||||
let snap = project.documents.snapshot(doc)?;
|
||||
let settings = project.settings.effective();
|
||||
let alignment = php_alignment(&settings, &snap.language);
|
||||
let original = alignment.any().then(|| (snap.language.clone(), snap.text.clone()));
|
||||
let Some(edits) = provider_edits(host, window, &project, snap, settings, range, options).await? else {
|
||||
return Ok(Vec::new());
|
||||
};
|
||||
let Some((language, text)) = original else {
|
||||
return Ok(edits);
|
||||
};
|
||||
let syntax = host.syntax();
|
||||
tokio::task::spawn_blocking(move || align_formatted(&syntax, &language, &text, edits, range, alignment))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// PHP Code Style › Align key-value pairs / Align consecutive assignments (off by default, as in PhpStorm).
|
||||
fn php_alignment(settings: &Settings, language: &LanguageId) -> PhpAlignment {
|
||||
let style = settings.editor.code_style.languages.get(language.as_str());
|
||||
PhpAlignment {
|
||||
key_value_pairs: style.and_then(|s| s.align_key_value_pairs).unwrap_or(false),
|
||||
assignments: style.and_then(|s| s.align_consecutive_assignments).unwrap_or(false),
|
||||
}
|
||||
}
|
||||
|
||||
/// The formatter's `edits` to `text` followed by the alignment, as one set of edits to `text`.
|
||||
/// With a `range`, only its lines (where the formatter left them) are aligned.
|
||||
fn align_formatted(
|
||||
syntax: &Syntax,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
edits: Vec<TextEdit>,
|
||||
range: Option<Range>,
|
||||
alignment: PhpAlignment,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let mut formatted = ide_text::Document::new(text);
|
||||
// Edits the editor has to sort out itself (overlapping ones) are passed on unaligned.
|
||||
let Ok((changes, _)) = formatted.apply_edits(&edits) else {
|
||||
return Ok(edits);
|
||||
};
|
||||
let lines = range.map(|range| {
|
||||
let original = ide_text::Document::new(text);
|
||||
let start = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.start), false));
|
||||
let end = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.end), true));
|
||||
let last = if end.col == 0 && end.line > start.line { end.line - 1 } else { end.line };
|
||||
(start.line as usize, last as usize)
|
||||
});
|
||||
let Some(aligned) = syntax.align_php(language, &formatted.text(), lines, alignment) else {
|
||||
return Ok(edits);
|
||||
};
|
||||
let original = ide_text::Document::new(text);
|
||||
Ok(original
|
||||
.diff(&aligned)
|
||||
.changes
|
||||
.into_iter()
|
||||
.map(|c| TextEdit {
|
||||
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
|
||||
new_text: c.insert,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Where UTF-16 `offset` of the text before `changes` ends up after them; inside a replaced
|
||||
/// part, at its start or (`end`) its end.
|
||||
fn map_offset(changes: &ChangeSet, offset: u32, end: bool) -> u32 {
|
||||
let mut shift: i64 = 0;
|
||||
for c in &changes.changes {
|
||||
let inserted = c.insert.encode_utf16().count() as i64;
|
||||
if c.to < offset || (c.to == offset && (c.from < c.to || end)) {
|
||||
shift += inserted - i64::from(c.to - c.from);
|
||||
} else if c.from < offset {
|
||||
return (i64::from(c.from) + shift + if end { inserted } else { 0 }) as u32;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
(i64::from(offset) + shift) as u32
|
||||
}
|
||||
|
||||
/// The edits of the formatter that handles the document; `None` when it doesn't run
|
||||
/// (formatting on save is off for it).
|
||||
async fn provider_edits(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
project: &crate::Project,
|
||||
snap: ide_workspace::documents::DocumentInfo,
|
||||
settings: Settings,
|
||||
range: Option<Range>,
|
||||
options: FormatOptions,
|
||||
) -> IdeResult<Option<Vec<TextEdit>>> {
|
||||
let doc = snap.id;
|
||||
let language = project.languages.get(&snap.language);
|
||||
if options.tool.is_none()
|
||||
&& let Some(id) = settings.languages.plugin_formatters.get(snap.language.as_str()).filter(|s| !s.is_empty())
|
||||
{
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
if snap.read_only {
|
||||
return Err(IdeError::invalid("The file is read-only"));
|
||||
@@ -249,8 +160,7 @@ async fn provider_edits(
|
||||
)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.map(Some);
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
}
|
||||
// A committed PHP-CS-Fixer configuration takes over Reformat Code for `.php` files.
|
||||
if options.tool.is_none()
|
||||
@@ -258,7 +168,7 @@ async fn provider_edits(
|
||||
&& let Some(fixer) = formatter::php_cs_fixer(&snap.path)
|
||||
{
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
host.require_trust(window)?;
|
||||
if snap.read_only {
|
||||
@@ -278,7 +188,7 @@ async fn provider_edits(
|
||||
body: Some("PHP-CS-Fixer does not support selection formatting; formatted the whole file".into()),
|
||||
});
|
||||
}
|
||||
return Ok(Some(edits));
|
||||
return Ok(edits);
|
||||
}
|
||||
let mut selected = external_tool(options.tool, language.as_ref(), &snap.path, &settings.languages)?;
|
||||
if let Some(tool) = selected
|
||||
@@ -290,13 +200,13 @@ async fn provider_edits(
|
||||
}
|
||||
let Some(selected) = selected else {
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
return project.lsp.format(doc, range, options).await.map(Some);
|
||||
return project.lsp.format(doc, range, options).await;
|
||||
};
|
||||
let tool_settings = settings.languages.formatter(selected);
|
||||
if options.on_save && !tool_settings.run_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
host.require_trust(window)?;
|
||||
if snap.read_only {
|
||||
@@ -352,7 +262,7 @@ async fn provider_edits(
|
||||
)),
|
||||
});
|
||||
}
|
||||
edits.map(Some).map_err(|e| e.with_tool(tool))
|
||||
edits.map_err(|e| e.with_tool(tool))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -503,103 +413,6 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
fn after(text: &str, edits: &[TextEdit]) -> String {
|
||||
let mut doc = ide_text::Document::new(text);
|
||||
doc.apply_edits(edits).unwrap();
|
||||
doc.text()
|
||||
}
|
||||
|
||||
fn whole_file(text: &str, formatted: &str) -> Vec<TextEdit> {
|
||||
let doc = ide_text::Document::new(text);
|
||||
doc.diff(formatted)
|
||||
.changes
|
||||
.into_iter()
|
||||
.map(|c| TextEdit {
|
||||
range: Range::new(doc.offset_to_pos(c.from), doc.offset_to_pos(c.to)),
|
||||
new_text: c.insert,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
|
||||
|
||||
#[test]
|
||||
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
|
||||
let php = LanguageId::new("php");
|
||||
let mut settings = Settings::default();
|
||||
assert_eq!(php_alignment(&settings, &php), PhpAlignment::default());
|
||||
let style =
|
||||
ide_core::editor_settings::LanguageCodeStyle { align_key_value_pairs: Some(true), ..Default::default() };
|
||||
settings.editor.code_style.languages.insert("php".into(), style);
|
||||
assert_eq!(php_alignment(&settings, &php), PhpAlignment { key_value_pairs: true, assignments: false });
|
||||
assert_eq!(php_alignment(&settings, &LanguageId::new("javascript")), PhpAlignment::default());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn alignment_follows_the_formatter_edits_even_when_there_are_none() {
|
||||
let syntax = Syntax::new();
|
||||
let php = LanguageId::new("php");
|
||||
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
|
||||
let edits = align_formatted(&syntax, &php, text, Vec::new(), None, ALIGN).unwrap();
|
||||
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
|
||||
|
||||
// The language server re-indents the array: the alignment applies to its result.
|
||||
let text = "<?php\n$a = [\n'a' => 1,\n'bbb' => 2,\n];\n";
|
||||
let formatted = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
|
||||
let edits = align_formatted(&syntax, &php, text, whole_file(text, formatted), None, ALIGN).unwrap();
|
||||
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
|
||||
|
||||
let unchanged = whole_file(text, formatted);
|
||||
let off = align_formatted(&syntax, &php, text, unchanged.clone(), None, PhpAlignment::default()).unwrap();
|
||||
assert_eq!(off, unchanged);
|
||||
|
||||
let overlapping = vec![
|
||||
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 4)), new_text: "x".into() },
|
||||
TextEdit { range: Range::new(Pos::new(1, 2), Pos::new(1, 6)), new_text: "y".into() },
|
||||
];
|
||||
let passed = align_formatted(&syntax, &php, text, overlapping.clone(), None, ALIGN).unwrap();
|
||||
assert_eq!(passed, overlapping);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_selection_aligns_only_its_lines_whatever_the_formatter_changed() {
|
||||
let syntax = Syntax::new();
|
||||
let php = LanguageId::new("php");
|
||||
let text = "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
|
||||
// PHP-CS-Fixer formats the whole file (here: adds a line at the top) whatever the selection.
|
||||
let formatted = format!("<?php\n\ndeclare(strict_types=1);\n{}", &text["<?php\n".len()..]);
|
||||
let edits = whole_file(text, &formatted);
|
||||
// Lines 3..=6 select the array, up to the start of the line after it.
|
||||
let range = Range::new(Pos::new(3, 0), Pos::new(7, 0));
|
||||
let aligned = align_formatted(&syntax, &php, text, edits, Some(range), ALIGN).unwrap();
|
||||
assert_eq!(aligned.len(), 2, "one edit per changed region: {aligned:?}");
|
||||
assert_eq!(
|
||||
after(text, &aligned),
|
||||
"<?php\n\ndeclare(strict_types=1);\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n"
|
||||
);
|
||||
let range = Range::new(Pos::new(1, 0), Pos::new(2, 9));
|
||||
let aligned = align_formatted(&syntax, &php, text, Vec::new(), Some(range), ALIGN).unwrap();
|
||||
assert_eq!(after(text, &aligned), "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn offsets_map_through_changes() {
|
||||
let changes = ChangeSet {
|
||||
changes: vec![
|
||||
ide_core::TextChange { from: 2, to: 2, insert: "ab".into() },
|
||||
ide_core::TextChange { from: 5, to: 8, insert: "x".into() },
|
||||
],
|
||||
};
|
||||
assert_eq!(map_offset(&changes, 0, false), 0);
|
||||
assert_eq!(map_offset(&changes, 2, false), 2);
|
||||
assert_eq!(map_offset(&changes, 2, true), 4);
|
||||
assert_eq!(map_offset(&changes, 4, false), 6);
|
||||
assert_eq!(map_offset(&changes, 6, false), 7);
|
||||
assert_eq!(map_offset(&changes, 6, true), 8);
|
||||
assert_eq!(map_offset(&changes, 8, false), 8);
|
||||
assert_eq!(map_offset(&changes, 10, false), 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ruff_ranges_are_one_based_unicode_columns() {
|
||||
let text = ide_text::Document::new("😀x = 1\ny = 2\n");
|
||||
|
||||
@@ -7,7 +7,6 @@ pub mod agent_secrets;
|
||||
pub mod catalogue;
|
||||
pub mod data_dirs;
|
||||
pub mod diagnostics_store;
|
||||
mod direnv;
|
||||
pub mod environment;
|
||||
mod formatter;
|
||||
mod java_runtime;
|
||||
@@ -253,16 +252,6 @@ impl Host {
|
||||
self.project(window)?.require_trust()
|
||||
}
|
||||
|
||||
/// [`Self::require_trust`] for IDE-wide toolchain work (SDK detection, tool installs) that
|
||||
/// also runs from a window without a project, such as Settings opened from the Welcome
|
||||
/// screen: there is no project there to trust.
|
||||
pub fn require_trust_if_project(&self, window: &str) -> IdeResult<()> {
|
||||
match self.project(window) {
|
||||
Ok(project) => project.require_trust(),
|
||||
Err(_) => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
/// The window that owns what `window` starts.
|
||||
pub fn owner_window<'a>(&self, window: &'a str) -> &'a str {
|
||||
(self.owner)(window)
|
||||
@@ -329,9 +318,6 @@ impl Host {
|
||||
}
|
||||
if !project.light {
|
||||
self.environment.project_closed();
|
||||
if self.windows_for_root(&project.root).is_empty() {
|
||||
self.environment.direnv_closed(&project.root);
|
||||
}
|
||||
}
|
||||
if let Some(bridge) = &project.kotlin_bridge {
|
||||
bridge.stop();
|
||||
|
||||
@@ -40,7 +40,6 @@ fn tools() -> Vec<tool::Tool> {
|
||||
tools.push(check::check_files());
|
||||
tools.push(symbols::get_symbol_info());
|
||||
tools.push(symbols::find_references());
|
||||
tools.push(symbols::get_call_hierarchy());
|
||||
tools.extend(edit::tools());
|
||||
tools.extend(run::tools());
|
||||
tools.extend(vcs::tools());
|
||||
|
||||
@@ -356,13 +356,6 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
|
||||
t.drain(..cut);
|
||||
}
|
||||
});
|
||||
let config = match resolve_jvm_application(call, config, errors).await? {
|
||||
Ok(config) => config,
|
||||
Err(reason) => {
|
||||
errors.process_outputs.push(reason);
|
||||
return Ok(false);
|
||||
}
|
||||
};
|
||||
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) {
|
||||
@@ -374,177 +367,6 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
/// Run configuration kinds launched as a JVM main class (`JVM_APPLICATION_KINDS` in the UI).
|
||||
const JVM_APPLICATION_KINDS: [&str; 2] = ["application", "spring-boot"];
|
||||
const CLASSPATH: &str = "${classpath}";
|
||||
const TEST_CLASSPATH: &str = "${testClasspath}";
|
||||
|
||||
/// `java` options whose value is the next argument (`parseJavaArgs` in the UI).
|
||||
const JAVA_OPTIONS_WITH_VALUE: [&str; 13] = [
|
||||
"-cp",
|
||||
"-classpath",
|
||||
"--class-path",
|
||||
"-p",
|
||||
"--module-path",
|
||||
"--upgrade-module-path",
|
||||
"--add-modules",
|
||||
"--add-opens",
|
||||
"--add-exports",
|
||||
"--add-reads",
|
||||
"--patch-module",
|
||||
"--limit-modules",
|
||||
"--enable-native-access",
|
||||
];
|
||||
|
||||
/// The main class of `java` arguments and which classpath placeholder they use (`Some(true)`:
|
||||
/// `${testClasspath}`; `None`: an explicit classpath or none).
|
||||
fn java_main_class(args: &[String]) -> (Option<&str>, Option<bool>) {
|
||||
let mut test = None;
|
||||
let mut i = 0;
|
||||
while i < args.len() {
|
||||
let a = args[i].as_str();
|
||||
if a == "-jar" {
|
||||
return (None, test);
|
||||
}
|
||||
if matches!(a, "-cp" | "-classpath" | "--class-path") {
|
||||
match args.get(i + 1).map(String::as_str) {
|
||||
Some(CLASSPATH) => test = Some(false),
|
||||
Some(TEST_CLASSPATH) => test = Some(true),
|
||||
_ => {}
|
||||
}
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
if JAVA_OPTIONS_WITH_VALUE.contains(&a) {
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
if !a.starts_with('-') {
|
||||
return (Some(a), test);
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
(None, test)
|
||||
}
|
||||
|
||||
/// `args` with the classpath placeholders replaced and the module path added (`resolveJavaCommand`).
|
||||
fn resolved_java_args(args: &[String], info: &ide_lsp::jdtls::JavaLaunchInfo) -> Vec<String> {
|
||||
let cp = info.class_paths.join(&info.path_list_separator);
|
||||
let mut out = Vec::with_capacity(args.len() + 2);
|
||||
if !info.module_paths.is_empty() && !args.iter().any(|a| a == "-p" || a == "--module-path") {
|
||||
out.push("--module-path".to_owned());
|
||||
out.push(info.module_paths.join(&info.path_list_separator));
|
||||
}
|
||||
out.extend(args.iter().map(|a| if a == CLASSPATH || a == TEST_CLASSPATH { cp.clone() } else { a.clone() }));
|
||||
out
|
||||
}
|
||||
|
||||
/// The module (relative to the project root) of a JVM source file: the part before
|
||||
/// `src/<set>/<language>/` (`jvmModuleDir` without a build model).
|
||||
fn jvm_module_of(rel: &str) -> Option<String> {
|
||||
let rel = rel.replace('\\', "/");
|
||||
let parts: Vec<&str> = rel.split('/').collect();
|
||||
(0..parts.len().saturating_sub(3)).find_map(|i| {
|
||||
(parts[i] == "src" && matches!(parts[i + 2], "java" | "kotlin" | "scala" | "groovy"))
|
||||
.then(|| parts[..i].join("/"))
|
||||
})
|
||||
}
|
||||
|
||||
/// The module of a configuration saved without one, found from its main class's source
|
||||
/// (`findJavaModule`): `None` unless exactly one module declares it.
|
||||
async fn find_java_module(call: &Call, main: &str) -> IdeResult<Option<String>> {
|
||||
let outer = main.split('$').next().unwrap_or(main);
|
||||
let (pkg, simple) = outer.rsplit_once('.').unwrap_or(("", outer));
|
||||
let mut names = vec![format!("{simple}.java"), format!("{simple}.kt")];
|
||||
if let Some(stem) = simple.strip_suffix("Kt") {
|
||||
names.push(format!("{stem}.kt"));
|
||||
}
|
||||
let mut modules = std::collections::BTreeSet::new();
|
||||
for name in names {
|
||||
for path in crate::ops::nav::find_files_named(&call.host(), call.window(), name).await? {
|
||||
let path = std::path::PathBuf::from(path);
|
||||
let Ok(text) = std::fs::read_to_string(&path) else { continue };
|
||||
let declared = text
|
||||
.lines()
|
||||
.map(str::trim)
|
||||
.find_map(|l| l.strip_prefix("package "))
|
||||
.map(|p| p.trim_end_matches(';').trim())
|
||||
.unwrap_or("");
|
||||
if declared != pkg {
|
||||
continue;
|
||||
}
|
||||
let rel = path.strip_prefix(call.root()).unwrap_or(&path).to_string_lossy().into_owned();
|
||||
modules.insert(jvm_module_of(&rel).unwrap_or_default());
|
||||
}
|
||||
}
|
||||
Ok((modules.len() == 1).then(|| modules.into_iter().next().unwrap_or_default()))
|
||||
}
|
||||
|
||||
/// A JVM application configuration ready to start, as the Run tool window launches it:
|
||||
/// built per its before-launch build policy, with `${classpath}` / `${testClasspath}`, the
|
||||
/// module path and the module's `java` resolved through jdtls. `Err` says why it cannot start
|
||||
/// (compile errors are added to `errors`). Other configurations are returned as they are.
|
||||
async fn resolve_jvm_application(
|
||||
call: &Call,
|
||||
config: RunConfig,
|
||||
errors: &mut BuildErrors,
|
||||
) -> IdeResult<Result<RunConfig, String>> {
|
||||
if !JVM_APPLICATION_KINDS.contains(&config.kind.as_str()) {
|
||||
return Ok(Ok(config));
|
||||
}
|
||||
let (main, test) = java_main_class(&config.args);
|
||||
let Some(main) = main.map(str::to_owned) else {
|
||||
return Ok(Err(format!("No main class in '{}'", config.name)));
|
||||
};
|
||||
let module = match config.extras.module.clone() {
|
||||
Some(module) => module,
|
||||
None => match find_java_module(call, &main).await? {
|
||||
Some(module) => module,
|
||||
None => return Ok(Err(format!("Cannot determine the module for main class '{main}'"))),
|
||||
},
|
||||
};
|
||||
let policy = config.extras.build_policy.unwrap_or_default();
|
||||
let cancel = ide_core::CancellationToken::new();
|
||||
let host = call.host();
|
||||
let info = crate::ops::java::resolve_launch(
|
||||
&host,
|
||||
call.window(),
|
||||
std::path::PathBuf::from(&module),
|
||||
test == Some(true),
|
||||
policy,
|
||||
&cancel,
|
||||
)
|
||||
.await?;
|
||||
use ide_lsp::jdtls::JavaBuildStatus;
|
||||
if matches!(info.build, Some(JavaBuildStatus::Failed | JavaBuildStatus::WithErrors))
|
||||
&& policy != ide_run::BuildPolicy::MakeAndContinueOnErrors
|
||||
{
|
||||
for e in &info.errors {
|
||||
errors.errors.push(format!(
|
||||
"{}:{}: {}",
|
||||
std::path::PathBuf::from(e.path.clone()).display(),
|
||||
e.line,
|
||||
e.message
|
||||
));
|
||||
}
|
||||
let reason = if info.build == Some(JavaBuildStatus::Failed) {
|
||||
format!("Build failed; '{}' was not started.", config.name)
|
||||
} else {
|
||||
format!("Build has compile errors; '{}' was not started.", config.name)
|
||||
};
|
||||
return Ok(Err(reason));
|
||||
}
|
||||
if test.is_some() && info.class_paths.is_empty() {
|
||||
return Ok(Err("The classpath is empty: is the module imported by the Java language server?".to_owned()));
|
||||
}
|
||||
let args = resolved_java_args(&config.args, &info);
|
||||
let command = match (&info.java_exec, config.command.as_str()) {
|
||||
(Some(exec), "java") => exec.clone(),
|
||||
_ => config.command.clone(),
|
||||
};
|
||||
Ok(Ok(RunConfig { command, args, ..config }))
|
||||
}
|
||||
|
||||
/// The configuration's before-launch tasks, as the Run tool window runs them; returns why
|
||||
/// the launch is aborted, if it is. Tool windows are not activated.
|
||||
async fn before_launch(
|
||||
@@ -786,10 +608,6 @@ one by one",
|
||||
if let Some(reason) = before_launch(&call, &config, &configs, &mut Vec::new(), &mut errors).await? {
|
||||
return Err(execution_failed(&[errors.text(), Some(reason)]));
|
||||
}
|
||||
let config = match resolve_jvm_application(&call, config, &mut errors).await? {
|
||||
Ok(config) => config,
|
||||
Err(reason) => return Err(execution_failed(&[errors.text(), Some(reason)])),
|
||||
};
|
||||
let collector = Arc::new(Mutex::new(OutputCollector::create(&config.name)?));
|
||||
let output_path = collector.lock().path.clone();
|
||||
let sink = collector.clone();
|
||||
@@ -866,40 +684,6 @@ provided, values are merged over existing env.",
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn strings(args: &[&str]) -> Vec<String> {
|
||||
args.iter().map(|a| (*a).to_owned()).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_arguments_name_the_main_class_and_classpath_placeholder() {
|
||||
let run = strings(&["-Xmx1g", "-cp", CLASSPATH, "--add-opens", "a/b=ALL-UNNAMED", "com.example.App", "x"]);
|
||||
assert_eq!(java_main_class(&run), (Some("com.example.App"), Some(false)));
|
||||
assert_eq!(java_main_class(&strings(&["-classpath", TEST_CLASSPATH, "T"])), (Some("T"), Some(true)));
|
||||
assert_eq!(java_main_class(&strings(&["-cp", "lib/*", "Main"])), (Some("Main"), None));
|
||||
assert_eq!(java_main_class(&strings(&["-jar", "app.jar"])), (None, None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolved_java_arguments_replace_the_placeholder_and_add_the_module_path() {
|
||||
let info = ide_lsp::jdtls::JavaLaunchInfo {
|
||||
class_paths: vec!["/p/target/classes".into(), "/m2/a.jar".into()],
|
||||
module_paths: vec!["/m2/mod.jar".into()],
|
||||
path_list_separator: ":".into(),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(
|
||||
resolved_java_args(&strings(&["-cp", CLASSPATH, "App"]), &info),
|
||||
strings(&["--module-path", "/m2/mod.jar", "-cp", "/p/target/classes:/m2/a.jar", "App"])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_source_file_belongs_to_the_module_before_its_source_set() {
|
||||
assert_eq!(jvm_module_of("repro-dto/src/main/java/com/example/App.java").as_deref(), Some("repro-dto"));
|
||||
assert_eq!(jvm_module_of("src/test/kotlin/AppTest.kt").as_deref(), Some(""));
|
||||
assert_eq!(jvm_module_of("scripts/App.java"), None);
|
||||
}
|
||||
|
||||
fn config() -> RunConfig {
|
||||
RunConfig {
|
||||
id: "user:x".into(),
|
||||
|
||||
@@ -280,7 +280,7 @@ fn context(call: &Call) -> IdeResult<(u32, u32)> {
|
||||
|
||||
/// `line`, or when longer than [`MAX_LINE_TEXT`] UTF-16 units, the part from [`SNIPPET_AROUND`]
|
||||
/// units before 0-based UTF-16 column `start` to as many after `end`, with `…` where it was cut.
|
||||
pub(super) fn snippet(line: &str, start: usize, end: usize) -> String {
|
||||
fn snippet(line: &str, start: usize, end: usize) -> String {
|
||||
let units: usize = line.chars().map(char::len_utf16).sum();
|
||||
if units <= MAX_LINE_TEXT {
|
||||
return line.to_owned();
|
||||
|
||||
@@ -1,13 +1,10 @@
|
||||
//! Quick Documentation through the project's language services.
|
||||
use super::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Pos, Range, RequestId, SymbolKind};
|
||||
use ide_lsp::types::{CallHierarchy, GotoKind, HierarchyDirection, HierarchyItem, ReferencesIncomplete};
|
||||
use ide_core::{IdeError, IdeResult, Pos, Range};
|
||||
use ide_lsp::types::GotoKind;
|
||||
use serde::Serialize;
|
||||
use serde_json::json;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use std::path::Path;
|
||||
|
||||
pub fn get_symbol_info() -> Tool {
|
||||
Tool::new("get_symbol_info", "Retrieves information about the symbol at the specified position in the specified file.
|
||||
@@ -215,10 +212,26 @@ pub fn find_references() -> Tool {
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
|
||||
let dir = super::scope::Scope::of(&call)?;
|
||||
let opened = open_at(&call, path).await?;
|
||||
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
|
||||
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
|
||||
let project = call.project.clone();
|
||||
let (doc, text) = call.host.blocking(move || {
|
||||
let text = project.text_of(&path)?;
|
||||
let doc = project.documents.open(&path)?;
|
||||
Ok((doc.id, text))
|
||||
}).await?;
|
||||
struct Close(std::sync::Arc<crate::Project>, ide_core::DocId);
|
||||
impl Drop for Close { fn drop(&mut self) { self.0.documents.close(self.1); } }
|
||||
let _close = Close(call.project.clone(), doc);
|
||||
let pos = mcp_position(&text, line, column)?;
|
||||
let request = super::tool::request_id();
|
||||
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, opened.doc, opened.pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
|
||||
let result = race(&call, request, work, "references timed out; retry when analysis finishes").await?;
|
||||
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, doc, pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
|
||||
tokio::pin!(work);
|
||||
let result = tokio::select! {
|
||||
result = &mut work => result?,
|
||||
_ = call.cancel.cancelled() => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::cancelled()); }
|
||||
_ = tokio::time::sleep(std::time::Duration::from_secs(60)) => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::unavailable("references timed out; retry when analysis finishes")); }
|
||||
};
|
||||
let mut value = serde_json::to_value(&result).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
// Convert every Location range at this boundary, including declarations.
|
||||
fn positions(value: &mut serde_json::Value) {
|
||||
@@ -261,266 +274,6 @@ pub fn find_references() -> Tool {
|
||||
/// References `find_references` lists by default.
|
||||
const REFERENCES_LIMIT: usize = 100;
|
||||
|
||||
/// A document a tool opened for the language services and the position it asked about;
|
||||
/// dropping it closes the document.
|
||||
#[must_use]
|
||||
struct Opened {
|
||||
project: Arc<crate::Project>,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
}
|
||||
|
||||
impl Drop for Opened {
|
||||
fn drop(&mut self) {
|
||||
self.project.documents.close(self.doc);
|
||||
}
|
||||
}
|
||||
|
||||
/// Opens `path` at the call's 1-based `line` and `column`.
|
||||
async fn open_at(call: &Call, path: PathBuf) -> IdeResult<Opened> {
|
||||
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
|
||||
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
|
||||
let project = call.project.clone();
|
||||
let (doc, text) = call
|
||||
.host
|
||||
.blocking(move || {
|
||||
let text = project.text_of(&path)?;
|
||||
let doc = project.documents.open(&path)?;
|
||||
Ok((doc.id, text))
|
||||
})
|
||||
.await?;
|
||||
let mut opened = Opened { project: call.project.clone(), doc, pos: Pos::default() };
|
||||
opened.pos = mcp_position(&text, line, column)?;
|
||||
Ok(opened)
|
||||
}
|
||||
|
||||
/// How long a tool waits for a language service request.
|
||||
const LANGUAGE_SERVICE_TIMEOUT: Duration = Duration::from_secs(60);
|
||||
|
||||
/// `work`, the language service `request`, until it ends; when the client cancels or
|
||||
/// [`LANGUAGE_SERVICE_TIMEOUT`] passes first, the request is cancelled and `work` runs to its end.
|
||||
async fn race<T>(
|
||||
call: &Call,
|
||||
request: RequestId,
|
||||
work: impl Future<Output = IdeResult<T>>,
|
||||
timed_out: &'static str,
|
||||
) -> IdeResult<T> {
|
||||
tokio::pin!(work);
|
||||
tokio::select! {
|
||||
result = &mut work => result,
|
||||
_ = call.cancel.cancelled() => {
|
||||
call.host.cancel_request(request);
|
||||
let _ = work.await;
|
||||
Err(IdeError::cancelled())
|
||||
}
|
||||
_ = tokio::time::sleep(LANGUAGE_SERVICE_TIMEOUT) => {
|
||||
call.host.cancel_request(request);
|
||||
let _ = work.await;
|
||||
Err(IdeError::unavailable(timed_out))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_call_hierarchy() -> Tool {
|
||||
Tool::new(
|
||||
"get_call_hierarchy",
|
||||
"Callers (incoming) or callees (outgoing) of the function or method at the position, from \
|
||||
the language server's call hierarchy. A position inside a function body means that function. \
|
||||
One level per call: to go deeper, call again with an item's filePath, startLine and startColumn \
|
||||
(items in libraries show a URI as filePath and cannot be expanded). \
|
||||
Positions are 1-based UTF-16. `root` is the symbol the hierarchy is for; each item's callSites \
|
||||
are where the call happens. Reports incomplete results when analysis is still running.",
|
||||
call_hierarchy,
|
||||
)
|
||||
.param(Param::required("filePath", ParamType::String, "Path relative to the project root"))
|
||||
.param(Param::required("line", ParamType::Integer, "1-based line"))
|
||||
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
|
||||
.param(Param::optional("direction", ParamType::String, "incoming (callers, default) or outgoing (callees)"))
|
||||
.param(super::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
|
||||
}
|
||||
|
||||
/// Items `get_call_hierarchy` lists by default.
|
||||
const CALLS_LIMIT: usize = 100;
|
||||
/// Call sites shown per item; `callSiteCount` gives the total when there are more.
|
||||
const MAX_CALL_SITES: usize = 20;
|
||||
const CALLS_TIMED_OUT: &str = "call hierarchy timed out; retry when analysis finishes";
|
||||
|
||||
async fn call_hierarchy(call: Call) -> IdeResult<Output> {
|
||||
let direction = match call.opt_str("direction")?.as_deref() {
|
||||
None | Some("incoming") => HierarchyDirection::Incoming,
|
||||
Some("outgoing") => HierarchyDirection::Outgoing,
|
||||
Some(_) => return Err(IdeError::invalid("direction must be incoming or outgoing")),
|
||||
};
|
||||
let page = super::page::Page::of(&call, CALLS_LIMIT)?;
|
||||
let scope = super::scope::Scope::of(&call)?;
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let opened = open_at(&call, path).await?;
|
||||
let hierarchy_at = |pos| {
|
||||
let request = super::tool::request_id();
|
||||
let work = crate::ops::lsp::lsp_call_hierarchy(&call.host, &call.window, request, opened.doc, pos, direction);
|
||||
race(&call, request, work, CALLS_TIMED_OUT)
|
||||
};
|
||||
let mut found = match hierarchy_at(opened.pos).await {
|
||||
// IDEA: inside a function body the hierarchy is the enclosing function's.
|
||||
Err(e) if e.kind == ErrorKind::NotFound => {
|
||||
let outline = tokio::select! {
|
||||
outline = crate::ops::doc::doc_outline(&call.host, &call.window, opened.doc) => outline?,
|
||||
_ = call.cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
};
|
||||
let at = enclosing_callable(&outline, opened.pos).map(|f| f.selection_range.start);
|
||||
let Some(at) = at.filter(|at| *at != opened.pos) else {
|
||||
let Pos { line, col } = opened.pos;
|
||||
return Err(IdeError::not_found(format!("no function or method at {}:{}", line + 1, col + 1)));
|
||||
};
|
||||
hierarchy_at(at).await?
|
||||
}
|
||||
result => result?,
|
||||
};
|
||||
if scope.dir().is_some() {
|
||||
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
|
||||
}
|
||||
let incomplete = found.incomplete;
|
||||
let (mut root, items) = call_items(found, |p| call.display(p));
|
||||
let mut out = serde_json::Map::new();
|
||||
let mut items = page.take(items, &mut out);
|
||||
// One file in memory at a time, as `search::fill_lines` reads them.
|
||||
let mut places: Vec<&mut Place> = root
|
||||
.iter_mut()
|
||||
.chain(&mut items)
|
||||
.flat_map(|i| std::iter::once(&mut i.at).chain(&mut i.call_sites))
|
||||
.filter(|place| place.file.is_some())
|
||||
.collect();
|
||||
places.sort_by(|a, b| a.file.cmp(&b.file));
|
||||
for in_file in places.chunk_by_mut(|a, b| a.file == b.file) {
|
||||
if call.cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let Some(path) = in_file[0].file.clone() else { continue };
|
||||
if let Ok(text) = crate::ops::fs::fs_read_text(&call.host, call.window(), path).await {
|
||||
fill_line_texts(in_file, &text);
|
||||
}
|
||||
}
|
||||
Output::json(CallHierarchyOutput { root, items, page: out, incomplete })
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct CallHierarchyOutput {
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
root: Option<CallItem>,
|
||||
items: Vec<CallItem>,
|
||||
/// `total`, and `more` and `nextOffset` when items follow.
|
||||
#[serde(flatten)]
|
||||
page: serde_json::Map<String, serde_json::Value>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
incomplete: Option<ReferencesIncomplete>,
|
||||
}
|
||||
|
||||
/// A function or method in the call hierarchy, at its name.
|
||||
#[derive(Serialize, Debug)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct CallItem {
|
||||
name: String,
|
||||
kind: SymbolKind,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
detail: Option<String>,
|
||||
#[serde(flatten)]
|
||||
at: Place,
|
||||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||||
call_sites: Vec<Place>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
call_site_count: Option<usize>,
|
||||
}
|
||||
|
||||
/// A range as the tools show it: 1-based UTF-16, with the text of its first line.
|
||||
#[derive(Serialize, Debug)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Place {
|
||||
file_path: String,
|
||||
start_line: u32,
|
||||
start_column: u32,
|
||||
end_line: u32,
|
||||
end_column: u32,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
line_text: Option<String>,
|
||||
/// The file `line_text` is read from; none in a library.
|
||||
#[serde(skip)]
|
||||
file: Option<PathBuf>,
|
||||
}
|
||||
|
||||
/// The root and the items of `h`, sorted by file and position, with call sites in source
|
||||
/// order, at most [`MAX_CALL_SITES`] per item. Library items show their URI.
|
||||
fn call_items(h: CallHierarchy, display: impl Fn(&Path) -> String) -> (Option<CallItem>, Vec<CallItem>) {
|
||||
let CallHierarchy { root, items, .. } = h;
|
||||
// A file path, or the URI of a virtual document, which has no lines to read here.
|
||||
let target = |path: &Path, uri: Option<&String>| match uri {
|
||||
Some(uri) => (None, uri.clone()),
|
||||
None => (Some(path.to_path_buf()), display(path)),
|
||||
};
|
||||
let place = |(file, file_path): (Option<PathBuf>, String), r: Range| Place {
|
||||
file_path,
|
||||
start_line: r.start.line + 1,
|
||||
start_column: r.start.col + 1,
|
||||
end_line: r.end.line + 1,
|
||||
end_column: r.end.col + 1,
|
||||
line_text: None,
|
||||
file,
|
||||
};
|
||||
let convert = |i: HierarchyItem| {
|
||||
let at = target(&i.path.0, i.uri.as_ref());
|
||||
let sites_in = match &i.from_path {
|
||||
Some(p) => {
|
||||
let shown = p.0.to_string_lossy();
|
||||
target(&p.0, ide_core::is_virtual_uri(&shown).then(|| shown.into_owned()).as_ref())
|
||||
}
|
||||
None => at.clone(),
|
||||
};
|
||||
let mut sites = i.from_ranges;
|
||||
sites.sort();
|
||||
sites.dedup();
|
||||
let count = sites.len();
|
||||
CallItem {
|
||||
call_sites: sites.into_iter().take(MAX_CALL_SITES).map(|r| place(sites_in.clone(), r)).collect(),
|
||||
call_site_count: (count > MAX_CALL_SITES).then_some(count),
|
||||
at: place(at, i.selection_range),
|
||||
name: i.name,
|
||||
kind: i.kind,
|
||||
detail: i.detail,
|
||||
}
|
||||
};
|
||||
let mut items: Vec<CallItem> = items.into_iter().map(&convert).collect();
|
||||
items.sort_by(|a, b| {
|
||||
(&a.at.file_path, a.at.start_line, a.at.start_column).cmp(&(
|
||||
&b.at.file_path,
|
||||
b.at.start_line,
|
||||
b.at.start_column,
|
||||
))
|
||||
});
|
||||
(root.map(convert), items)
|
||||
}
|
||||
|
||||
/// Fills `lineText` of `places`, which are all in the file whose text is `text`.
|
||||
fn fill_line_texts(places: &mut [&mut Place], text: &str) {
|
||||
let lines: Vec<&str> = text.split('\n').collect();
|
||||
for place in places {
|
||||
let Some(line) = lines.get(place.start_line as usize - 1) else { continue };
|
||||
let line = line.strip_suffix('\r').unwrap_or(line);
|
||||
let start = place.start_column as usize - 1;
|
||||
let end = if place.end_line == place.start_line { place.end_column as usize - 1 } else { start };
|
||||
place.line_text = Some(super::search::snippet(line, start, end));
|
||||
}
|
||||
}
|
||||
|
||||
/// The innermost function, method or constructor of `outline` whose extent holds `pos`,
|
||||
/// as the IDE's Call Hierarchy finds it.
|
||||
fn enclosing_callable(outline: &[OutlineItem], pos: Pos) -> Option<&OutlineItem> {
|
||||
let item = outline.iter().find(|i| i.range.start <= pos && pos <= i.range.end)?;
|
||||
enclosing_callable(&item.children, pos).or_else(|| {
|
||||
matches!(item.kind, SymbolKind::Function | SymbolKind::Method | SymbolKind::Constructor).then_some(item)
|
||||
})
|
||||
}
|
||||
|
||||
fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
|
||||
if line < 1 || line > u32::MAX as i64 || column < 1 || column > u32::MAX as i64 {
|
||||
return Err(IdeError::invalid("line and column must be positive 1-based positions"));
|
||||
@@ -531,156 +284,3 @@ fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
|
||||
}
|
||||
Ok(Pos::new((line - 1) as u32, (column - 1) as u32))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn range(line: u32, col: u32, end_line: u32, end_col: u32) -> Range {
|
||||
Range::new(Pos::new(line, col), Pos::new(end_line, end_col))
|
||||
}
|
||||
|
||||
fn item(name: &str, path: &str, line: u32, from_ranges: Vec<Range>) -> HierarchyItem {
|
||||
HierarchyItem {
|
||||
name: name.into(),
|
||||
kind: SymbolKind::Function,
|
||||
detail: Some(format!("fn {name}()")),
|
||||
path: PathBuf::from(path).into(),
|
||||
uri: None,
|
||||
range: range(line, 0, line + 2, 1),
|
||||
selection_range: range(line, 3, line, 3 + name.len() as u32),
|
||||
from_ranges,
|
||||
from_path: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn shown(path: &Path) -> String {
|
||||
path.strip_prefix("/p").unwrap_or(path).to_string_lossy().into_owned()
|
||||
}
|
||||
|
||||
fn hierarchy(root: HierarchyItem, items: Vec<HierarchyItem>) -> CallHierarchy {
|
||||
CallHierarchy { root: Some(root), items, incomplete: None }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incoming_call_sites_are_in_the_callers_file_one_based() {
|
||||
let h = hierarchy(
|
||||
item("price", "/p/src/lib.rs", 10, Vec::new()),
|
||||
vec![item("main", "/p/src/main.rs", 2, vec![range(4, 8, 4, 13)])],
|
||||
);
|
||||
let (root, items) = call_items(h, shown);
|
||||
let root = serde_json::to_value(root.unwrap()).unwrap();
|
||||
assert_eq!(
|
||||
root,
|
||||
json!({"name":"price","kind":"function","detail":"fn price()","filePath":"src/lib.rs",
|
||||
"startLine":11,"startColumn":4,"endLine":11,"endColumn":9})
|
||||
);
|
||||
assert_eq!(
|
||||
serde_json::to_value(&items).unwrap(),
|
||||
json!([{"name":"main","kind":"function","detail":"fn main()","filePath":"src/main.rs",
|
||||
"startLine":3,"startColumn":4,"endLine":3,"endColumn":8,
|
||||
"callSites":[{"filePath":"src/main.rs","startLine":5,"startColumn":9,"endLine":5,"endColumn":14}]}])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn outgoing_call_sites_are_in_the_file_ide_lsp_names() {
|
||||
let mut price = item("price", "/p/src/lib.rs", 10, vec![range(4, 8, 4, 13)]);
|
||||
price.from_path = Some(PathBuf::from("/p/src/main.rs").into());
|
||||
let (_, items) = call_items(hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![price]), shown);
|
||||
assert_eq!(items[0].at.file_path, "src/lib.rs");
|
||||
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
|
||||
assert_eq!(items[0].call_sites[0].file.as_deref(), Some(Path::new("/p/src/main.rs")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn library_items_show_their_uri() {
|
||||
let mut library = item("len", "/virtual", 0, vec![range(4, 8, 4, 11)]);
|
||||
library.uri = Some("jar:file:///lib.jar!/Str.class".into());
|
||||
library.from_path = Some(PathBuf::from("/p/src/main.rs").into());
|
||||
let mut called_from_library = item("parse", "/p/src/a.rs", 3, vec![range(1, 0, 1, 4)]);
|
||||
called_from_library.from_path = Some(PathBuf::from("jdt://contents/lib.jar/Caller.class").into());
|
||||
let h = hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![library, called_from_library]);
|
||||
let (_, items) = call_items(h, shown);
|
||||
assert_eq!(items[0].at.file_path, "jar:file:///lib.jar!/Str.class");
|
||||
assert_eq!(items[0].at.file, None, "no line text for a library item");
|
||||
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
|
||||
assert_eq!(items[1].call_sites[0].file_path, "jdt://contents/lib.jar/Caller.class");
|
||||
assert_eq!(items[1].call_sites[0].file, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn call_items_are_sorted_by_file_and_line() {
|
||||
let h = hierarchy(
|
||||
item("price", "/p/src/lib.rs", 10, Vec::new()),
|
||||
vec![
|
||||
item("c", "/p/src/main.rs", 9, Vec::new()),
|
||||
item("b", "/p/src/main.rs", 2, Vec::new()),
|
||||
item("a", "/p/src/a.rs", 5, Vec::new()),
|
||||
],
|
||||
);
|
||||
let (_, items) = call_items(h, shown);
|
||||
assert_eq!(items.iter().map(|i| i.name.as_str()).collect::<Vec<_>>(), ["a", "b", "c"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn call_sites_are_capped_with_their_count() {
|
||||
let sites = (0..MAX_CALL_SITES as u32 + 5).map(|l| range(l, 0, l, 1)).collect();
|
||||
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
|
||||
let (_, items) = call_items(h, shown);
|
||||
assert_eq!(items[0].call_sites.len(), MAX_CALL_SITES);
|
||||
assert_eq!(items[0].call_site_count, Some(MAX_CALL_SITES + 5));
|
||||
let one = hierarchy(
|
||||
item("price", "/p/src/lib.rs", 10, Vec::new()),
|
||||
vec![item("main", "/p/a.rs", 0, vec![range(1, 0, 1, 1)])],
|
||||
);
|
||||
assert_eq!(call_items(one, shown).1[0].call_site_count, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn call_sites_are_in_source_order_without_duplicates() {
|
||||
let sites = vec![range(5, 0, 5, 1), range(1, 4, 1, 5), range(5, 0, 5, 1), range(1, 2, 1, 3)];
|
||||
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
|
||||
let (_, items) = call_items(h, shown);
|
||||
let at: Vec<_> = items[0].call_sites.iter().map(|s| (s.start_line, s.start_column)).collect();
|
||||
assert_eq!(at, [(2, 3), (2, 5), (6, 1)]);
|
||||
assert_eq!(items[0].call_site_count, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn line_text_is_cut_from_the_line_of_each_place() {
|
||||
let h = hierarchy(item("price", "/p/src/lib.rs", 3, vec![range(0, 4, 0, 9), range(1, 0, 3, 1)]), Vec::new());
|
||||
let mut root = call_items(h, shown).0.unwrap();
|
||||
let mut places: Vec<&mut Place> = std::iter::once(&mut root.at).chain(&mut root.call_sites).collect();
|
||||
fill_line_texts(&mut places, " price();\r\nfn other() {\n\nfn price() {}");
|
||||
assert_eq!(root.at.line_text.as_deref(), Some("fn price() {}"));
|
||||
assert_eq!(root.call_sites[0].line_text.as_deref(), Some(" price();"));
|
||||
assert_eq!(root.call_sites[1].line_text.as_deref(), Some("fn other() {"), "a range over lines");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enclosing_callable_is_the_innermost_function() {
|
||||
let outline = |name: &str, kind, range, children| OutlineItem {
|
||||
name: name.into(),
|
||||
detail: None,
|
||||
kind,
|
||||
range,
|
||||
selection_range: Range::new(range.start, range.start),
|
||||
children,
|
||||
visibility: None,
|
||||
};
|
||||
let method = outline(
|
||||
"total",
|
||||
SymbolKind::Method,
|
||||
range(2, 4, 8, 5),
|
||||
vec![outline("add", SymbolKind::Function, range(3, 8, 5, 9), Vec::new())],
|
||||
);
|
||||
let items = vec![outline("Cart", SymbolKind::Struct, range(0, 0, 9, 1), vec![method])];
|
||||
let name = |pos| enclosing_callable(&items, pos).map(|i| i.name.as_str());
|
||||
assert_eq!(name(Pos::new(4, 0)), Some("add"));
|
||||
assert_eq!(name(Pos::new(5, 9)), Some("add"), "the end is inside");
|
||||
assert_eq!(name(Pos::new(7, 0)), Some("total"));
|
||||
assert_eq!(name(Pos::new(0, 3)), None, "a struct is not callable");
|
||||
assert_eq!(name(Pos::new(12, 0)), None);
|
||||
}
|
||||
}
|
||||
@@ -236,7 +236,7 @@ impl Tool {
|
||||
destructive: false,
|
||||
output_schema: None,
|
||||
input_schema: json!({ "type": "object", "properties": {
|
||||
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
|
||||
"projectPath": { "type": "string", "description": "Any directory inside an open project. Optional when only one project is open." }
|
||||
}, "required": [] }),
|
||||
},
|
||||
handler: Arc::new(move |call| Box::pin(handler(call))),
|
||||
|
||||
@@ -268,19 +268,6 @@ pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: Agent
|
||||
host.project(window)?.agents.prompt(&task, prompt, now).await
|
||||
}
|
||||
|
||||
/// Answers a non-blocking question, without cancelling the current turn.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_answer_question(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
question: String,
|
||||
answer: Option<String>,
|
||||
) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.answer_question(&task, &question, answer).await
|
||||
}
|
||||
|
||||
/// Drops a queued message and returns it (to edit it).
|
||||
#[command(trust = always)]
|
||||
pub fn agent_unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
|
||||
@@ -369,21 +356,10 @@ pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktr
|
||||
host.project(window)?.agents.delete(&task, remove_worktree).await
|
||||
}
|
||||
|
||||
/// The task's changed files as `view` compares them (without: since it started).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_changes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
view: Option<AgentChangesView>,
|
||||
) -> IdeResult<Vec<AgentChange>> {
|
||||
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
|
||||
host.require_trust(window)?;
|
||||
let agents = &host.project(window)?.agents;
|
||||
match view.unwrap_or_default() {
|
||||
AgentChangesView::SinceStart => agents.changes(&task).await,
|
||||
AgentChangesView::Group => Ok(agents.grouped_changes(&task).await?.uncommitted),
|
||||
AgentChangesView::LastTurn => agents.turn_changes(&task).await,
|
||||
}
|
||||
host.project(window)?.agents.changes(&task).await
|
||||
}
|
||||
|
||||
/// The task's uncommitted changes and the commits made since it started.
|
||||
@@ -393,17 +369,11 @@ pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> I
|
||||
host.project(window)?.agents.grouped_changes(&task).await
|
||||
}
|
||||
|
||||
/// Content of `path` as `view` compares it (without: when the task started), the left side of its diff.
|
||||
/// Content of `path` when the task started (left side of its diff).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_base_text(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
path: IpcPath,
|
||||
view: Option<AgentChangesView>,
|
||||
) -> IdeResult<Option<String>> {
|
||||
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(), view.unwrap_or_default()).await
|
||||
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.
|
||||
@@ -1045,7 +1015,6 @@ mod tests {
|
||||
ide_command::domain!(
|
||||
agent:
|
||||
agent_accept_changes,
|
||||
agent_answer_question,
|
||||
agent_archive,
|
||||
agent_base_text,
|
||||
agent_cancel,
|
||||
|
||||
@@ -139,32 +139,6 @@ pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_create_database(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
template: String,
|
||||
statement: String,
|
||||
) -> IdeResult<()> {
|
||||
// Creates a database on the server of data source `id` with `statement`, copied from `template` (New › Database).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.create_database(&id, &template, &statement).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_drop_database(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
database: String,
|
||||
statement: String,
|
||||
) -> IdeResult<()> {
|
||||
// Drops `database` of the server of data source `id` with `statement` (Drop… on a database node).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.drop_database(&id, &database, &statement).await
|
||||
}
|
||||
|
||||
#[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>`.
|
||||
@@ -504,12 +478,10 @@ ide_command::domain!(
|
||||
db_connected,
|
||||
db_console_path,
|
||||
db_consoles,
|
||||
db_create_database,
|
||||
db_database_catalog,
|
||||
db_databases,
|
||||
db_ddl,
|
||||
db_disconnect,
|
||||
db_drop_database,
|
||||
db_execute,
|
||||
db_explain,
|
||||
db_finish_transaction,
|
||||
|
||||
@@ -141,11 +141,8 @@ impl DependencyVersionSource for GoModules {
|
||||
}
|
||||
|
||||
fn fetch(&self, package: &str, cancel: &CancellationToken) -> IdeResult<Vec<String>> {
|
||||
let search = self
|
||||
.env
|
||||
.get("PATH")
|
||||
.map(std::ffi::OsString::from)
|
||||
.unwrap_or_else(|| ide_core::tool_path::search_path_in(&self.root));
|
||||
let search =
|
||||
self.env.get("PATH").map(std::ffi::OsString::from).unwrap_or_else(ide_core::tool_path::search_path);
|
||||
let go = ide_core::tool_path::find_command("go", &search, &self.root)
|
||||
.ok_or_else(|| IdeError::unavailable("Go SDK is unavailable"))?;
|
||||
// A partially edited go.mod is often invalid. Query outside it while
|
||||
|
||||
@@ -70,18 +70,6 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
/// An automatic save: `false` (nothing written) when the file changed on disk after the
|
||||
/// buffer was edited, which only an explicit save overwrites.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_autosave(host: &Host, window: &str, doc: DocId) -> IdeResult<bool> {
|
||||
let project = host.project(window)?;
|
||||
let saved = host.blocking(move || project.documents.autosave(doc)).await?;
|
||||
if saved {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await?;
|
||||
}
|
||||
Ok(saved)
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
@@ -121,7 +109,6 @@ ide_command::domain!(
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_save,
|
||||
doc_autosave,
|
||||
doc_save_all,
|
||||
doc_save_as,
|
||||
doc_snapshot,
|
||||
|
||||
@@ -311,11 +311,6 @@ async fn shutdown_does_not_wait_forever_for_a_stuck_capture() {
|
||||
shutdown_within(&f.host, std::time::Duration::from_millis(200)).await;
|
||||
assert!(started.elapsed() < std::time::Duration::from_secs(5));
|
||||
assert!(cancel.is_cancelled());
|
||||
// The cleanup is only waited for briefly and finishes in the background on a busy machine.
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
while stuck_dir.exists() && std::time::Instant::now() < deadline {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
|
||||
}
|
||||
assert!(!stuck_dir.exists(), "its directory is removed once the wait is over");
|
||||
}
|
||||
|
||||
|
||||
@@ -34,7 +34,7 @@ pub async fn java_resolve_launch(
|
||||
result
|
||||
}
|
||||
|
||||
pub(crate) async fn resolve_launch(
|
||||
async fn resolve_launch(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
module: PathBuf,
|
||||
|
||||
@@ -359,22 +359,10 @@ pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: Got
|
||||
if kind != GotoKind::Definition {
|
||||
return result;
|
||||
}
|
||||
// A Maven placeholder (`@profileActive@` in `application.yml` or `.properties`) navigates to its pom.
|
||||
let maven = super::maven_placeholder::definition(host, window, doc, pos).await;
|
||||
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else {
|
||||
return match maven {
|
||||
None => result,
|
||||
Some(found) => {
|
||||
let in_string = in_string_literal(host, window, doc, pos).await;
|
||||
definition_targets(result, vec![found], in_string)
|
||||
}
|
||||
};
|
||||
};
|
||||
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else { return result };
|
||||
let found = plugin_call(move || plugins.provide_definition(&d, pos)).await.unwrap_or_default();
|
||||
let found: Vec<Location> = maven
|
||||
.into_iter()
|
||||
.chain(found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }))
|
||||
.collect();
|
||||
let found: Vec<Location> =
|
||||
found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }).collect();
|
||||
let in_string = !found.is_empty() && in_string_literal(host, window, doc, pos).await;
|
||||
definition_targets(result, found, in_string)
|
||||
}
|
||||
|
||||
@@ -1,154 +0,0 @@
|
||||
//! ⌘B on a Maven resource-filtering placeholder: `@property@` in a YAML or properties
|
||||
//! resource (Spring's `application.yml` / `application.properties`) jumps to the `<properties>` entry that defines it,
|
||||
//! in the nearest `pom.xml` above the file, up through the project root. Parent
|
||||
//! poms the nearest pom declares itself are followed from there; a parent outside
|
||||
//! that walk that no pom declares is not.
|
||||
|
||||
use super::doc::blocking;
|
||||
use crate::Host;
|
||||
use ide_build::maven;
|
||||
use ide_core::{DocId, Location, Pos};
|
||||
use std::path::Path;
|
||||
|
||||
/// The definition location of the placeholder under `pos` in `doc`, when `doc` is a
|
||||
/// YAML or properties file holding a `@token@` there and a pom above it defines that property.
|
||||
pub(crate) async fn definition(host: &Host, window: &str, doc: DocId, pos: Pos) -> Option<Location> {
|
||||
let project = host.project(window).ok()?;
|
||||
blocking(move || {
|
||||
let snap = project.documents.text_snapshot(doc)?;
|
||||
if snap.large || !matches!(snap.language.as_str(), "yaml" | "properties") {
|
||||
return Ok(None);
|
||||
}
|
||||
let path = project.documents.identity(doc)?.0;
|
||||
let Some((name, _token_at)) = placeholder_at(&snap.text, pos) else { return Ok(None) };
|
||||
Ok(pom_defining(&project.root, &path, &name))
|
||||
})
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
}
|
||||
|
||||
/// The `@token@` enclosing `pos` on its line, with the token's range (UTF-16 columns).
|
||||
fn placeholder_at(text: &str, pos: Pos) -> Option<(String, ide_core::Range)> {
|
||||
let line = text.split_inclusive('\n').nth(pos.line as usize)?;
|
||||
let line = line.trim_end_matches(['\n', '\r']);
|
||||
let cursor = utf16_to_byte(line, pos.col)?;
|
||||
let mut opener: Option<usize> = None;
|
||||
for (i, b) in line.as_bytes().iter().enumerate() {
|
||||
if *b != b'@' {
|
||||
continue;
|
||||
}
|
||||
if let Some(start) = opener.replace(i) {
|
||||
let token = &line[start + 1..i];
|
||||
let valid =
|
||||
!token.is_empty() && token.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'));
|
||||
if valid && start <= cursor && cursor <= i {
|
||||
let col = |byte: usize| line[..byte].encode_utf16().count() as u32;
|
||||
return Some((
|
||||
token.to_owned(),
|
||||
ide_core::Range::new(Pos::new(pos.line, col(start)), Pos::new(pos.line, col(i + 1))),
|
||||
));
|
||||
}
|
||||
opener = None;
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The nearest `pom.xml` above `from` (up to and including `root`) defining `name`.
|
||||
fn pom_defining(root: &Path, from: &Path, name: &str) -> Option<Location> {
|
||||
let mut dir = from.parent()?.to_path_buf();
|
||||
loop {
|
||||
let pom = dir.join("pom.xml");
|
||||
if pom.is_file()
|
||||
&& let Some(found) = maven::property_declaration(&pom, name, maven::default_local_repo())
|
||||
{
|
||||
return Some(Location::file(found.path, found.range));
|
||||
}
|
||||
if dir == root || !dir.starts_with(root) {
|
||||
return None;
|
||||
}
|
||||
dir = dir.parent()?.to_path_buf();
|
||||
}
|
||||
}
|
||||
|
||||
/// UTF-16 column → byte offset within one line.
|
||||
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
|
||||
let col = col as usize;
|
||||
let mut units = 0usize;
|
||||
for (byte, c) in line.char_indices() {
|
||||
if units == col {
|
||||
return Some(byte);
|
||||
}
|
||||
units += c.len_utf16();
|
||||
if units > col {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
(units == col).then_some(line.len())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::Pos;
|
||||
|
||||
fn at(line: u32, col: u32) -> Pos {
|
||||
Pos::new(line, col)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finds_the_placeholder_under_the_cursor_and_its_range() {
|
||||
let text = "spring:\n profiles:\n active: @profileActive@\n";
|
||||
let (name, range) = placeholder_at(text, at(2, 20)).unwrap();
|
||||
assert_eq!(name, "profileActive");
|
||||
assert_eq!(range.start, at(2, 12));
|
||||
assert_eq!(range.end, at(2, 27));
|
||||
// The `@`s themselves and inside the token navigate; just past the token does not.
|
||||
for col in [12u32, 13, 26] {
|
||||
assert_eq!(placeholder_at(text, at(2, col)).unwrap().0, "profileActive");
|
||||
}
|
||||
// A second pair on the line and unrelated cursors stay unresolved.
|
||||
let multi = "a: @one@ @two@\n";
|
||||
assert_eq!(placeholder_at(multi, at(0, 4)).unwrap().0, "one");
|
||||
assert_eq!(placeholder_at(multi, at(0, 10)).unwrap().0, "two");
|
||||
assert!(placeholder_at(multi, at(0, 8)).is_none(), "between the pairs");
|
||||
assert!(placeholder_at(multi, at(0, 9)).is_some(), "the opening @ of the next pair");
|
||||
assert!(placeholder_at(multi, at(0, 14)).is_none(), "just past the last pair");
|
||||
assert!(placeholder_at("value: plain\n", at(0, 7)).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_nearest_pom_wins_and_the_walk_stops_at_the_project_root() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
let deep = root.join("core/src/main/resources");
|
||||
std::fs::create_dir_all(&deep).unwrap();
|
||||
std::fs::write(
|
||||
root.join("pom.xml"),
|
||||
"<project>\n <properties>\n <parentName>parent</parentName>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::create_dir_all(root.join("core")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("core/pom.xml"),
|
||||
"<project>\n <properties>\n <name>module</name>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
let from = deep.join("application.yml");
|
||||
// The module pom defines `name` first: its file wins, pointing at its `<name>` entry.
|
||||
let found = pom_defining(&root, &from, "name").unwrap();
|
||||
assert_eq!(found.path, root.join("core/pom.xml"));
|
||||
assert_eq!(found.range.start.line, 2);
|
||||
// A property only the parent defines resolves there; unknown ones resolve nowhere.
|
||||
let parent = pom_defining(&root, &from, "parentName").unwrap();
|
||||
assert_eq!(parent.path, root.join("pom.xml"));
|
||||
assert_eq!(parent.range.start.line, 2);
|
||||
assert!(pom_defining(&root, &from, "missing").is_none());
|
||||
// A file outside the project root has no pom walk.
|
||||
let outside = tmp.path().join("elsewhere/application.yml");
|
||||
std::fs::create_dir_all(tmp.path().join("elsewhere")).unwrap();
|
||||
assert!(pom_defining(&root, &outside, "name").is_none());
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,6 @@ pub mod history;
|
||||
pub mod java;
|
||||
pub mod jvm_icons;
|
||||
pub mod lsp;
|
||||
pub mod maven_placeholder;
|
||||
pub mod nav;
|
||||
pub mod notebook;
|
||||
pub mod project;
|
||||
|
||||
@@ -93,13 +93,12 @@ fn detected_and_saved(
|
||||
.linked_projects
|
||||
.as_ref()
|
||||
.map(|_| ide_build::gradle::load_linked(root, &settings.languages.java.gradle));
|
||||
let mut detected = ide_run::detect_with_profiles(root, &excluded_poms, settings.cmake.profiles.as_deref());
|
||||
detected.extend(ide_run::detect_builds(root, &linked_build_dirs(root, settings, gradle.as_deref(), &detected)));
|
||||
let mut all: Vec<RunConfig> = detected
|
||||
.into_iter()
|
||||
.filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id))
|
||||
.filter(|d| linked_config(root, gradle.as_deref(), &excluded_poms, d))
|
||||
.collect();
|
||||
let mut all: Vec<RunConfig> =
|
||||
ide_run::detect_with_profiles(root, &excluded_poms, settings.cmake.profiles.as_deref())
|
||||
.into_iter()
|
||||
.filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id))
|
||||
.filter(|d| linked_config(root, gradle.as_deref(), &excluded_poms, d))
|
||||
.collect();
|
||||
all.extend(saved.iter().cloned());
|
||||
for config in all.iter_mut().filter(|c| !matches!(c.kind.as_str(), "gradle" | "maven")) {
|
||||
ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(config), root, settings);
|
||||
@@ -107,56 +106,6 @@ fn detected_and_saved(
|
||||
all
|
||||
}
|
||||
|
||||
/// Folders of the Maven / Gradle builds linked explicitly (Add Maven Projects, linked Gradle
|
||||
/// builds) that detection did not reach: deeper than its folder search, or inside the folder of
|
||||
/// a build it found without being one of that build's projects (a separate build nested there).
|
||||
fn linked_build_dirs(
|
||||
root: &Path,
|
||||
settings: &ide_core::settings::Settings,
|
||||
gradle: Option<&[ide_build::GradleModel]>,
|
||||
detected: &[RunConfig],
|
||||
) -> Vec<std::path::PathBuf> {
|
||||
let found = |kind: &str| -> Vec<std::path::PathBuf> {
|
||||
let mut dirs: Vec<_> = detected
|
||||
.iter()
|
||||
.filter(|c| c.kind == kind)
|
||||
.map(|c| ide_core::project_roots::resolve(root, c.cwd.as_deref().unwrap_or(Path::new(""))))
|
||||
.collect();
|
||||
dirs.dedup();
|
||||
dirs
|
||||
};
|
||||
let canonical = |dir: &Path| dunce::canonicalize(dir).unwrap_or_else(|_| dir.to_path_buf());
|
||||
let profiles = settings.languages.java.maven.profiles(&[]);
|
||||
let maven_builds = found("maven");
|
||||
let poms = settings.languages.java.maven.linked_projects.iter().filter_map(|pom| {
|
||||
let pom = root.join(pom.trim());
|
||||
pom.is_file().then(|| pom.parent().map(Path::to_path_buf)).flatten()
|
||||
});
|
||||
let maven = poms.map(|dir| ide_core::project_roots::resolve(root, &dir)).filter(|dir| {
|
||||
let dir_canon = canonical(dir);
|
||||
!maven_builds.iter().any(|build| {
|
||||
dir.starts_with(build) && ide_build::maven::reactor_member_dirs(build, &profiles).contains(&dir_canon)
|
||||
})
|
||||
});
|
||||
let models = gradle.unwrap_or_default();
|
||||
let gradle_builds = found("gradle");
|
||||
let gradle =
|
||||
models.iter().map(|build| ide_core::project_roots::resolve(root, &root.join(&build.dir))).filter(|dir| {
|
||||
!gradle_builds.iter().any(|build| {
|
||||
dir == build
|
||||
|| (dir.starts_with(build)
|
||||
&& models.iter().filter(|m| root.join(&m.dir) == *build).any(|m| {
|
||||
m.projects
|
||||
.iter()
|
||||
.any(|p| ide_core::project_roots::resolve(root, &root.join(&p.dir)) == *dir)
|
||||
}))
|
||||
})
|
||||
});
|
||||
let mut dirs: Vec<_> = maven.chain(gradle).collect();
|
||||
dirs.dedup();
|
||||
dirs
|
||||
}
|
||||
|
||||
fn linked_config(
|
||||
root: &std::path::Path,
|
||||
gradle: Option<&[ide_build::GradleModel]>,
|
||||
@@ -656,143 +605,6 @@ mod ownership_tests {
|
||||
let configs = detected_and_saved(root, &settings, &[], &[]);
|
||||
assert!(configs.is_empty(), "{configs:?}");
|
||||
}
|
||||
|
||||
/// #4066: a build linked explicitly is detected beyond the folder search depth.
|
||||
#[test]
|
||||
fn linked_builds_are_detected_at_any_depth() {
|
||||
const BOOT_POM: &str = "<project><build><plugins><plugin><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>";
|
||||
const APP: &str = "package com.example;\n@SpringBootApplication public class DemoApplication { public static void main(String[] a) {} }";
|
||||
let deep = "site/service/03_src/demo-monitor";
|
||||
let tool = "a/b/c/tool";
|
||||
type Case =
|
||||
(&'static str, Vec<(String, &'static str)>, Vec<&'static str>, Option<Vec<&'static str>>, Vec<String>);
|
||||
let cases: Vec<Case> = vec![
|
||||
(
|
||||
"reporter: Maven module four levels deep, no root POM, linked",
|
||||
vec![
|
||||
(format!("{deep}/pom.xml"), BOOT_POM),
|
||||
(format!("{deep}/src/main/java/com/example/DemoApplication.java"), APP),
|
||||
],
|
||||
vec!["site/service/03_src/demo-monitor/pom.xml"],
|
||||
None,
|
||||
vec![
|
||||
format!("maven:package:{deep}"),
|
||||
format!("maven:test:{deep}"),
|
||||
format!("maven:spring-boot:run:{deep}"),
|
||||
format!("application:{deep}:com.example.DemoApplication"),
|
||||
],
|
||||
),
|
||||
(
|
||||
"the same module, not linked: depth limit unchanged",
|
||||
vec![(format!("{deep}/pom.xml"), BOOT_POM)],
|
||||
vec![],
|
||||
None,
|
||||
vec![],
|
||||
),
|
||||
(
|
||||
"Gradle build four levels deep, linked",
|
||||
vec![(format!("{tool}/build.gradle.kts"), "plugins {\n application\n}")],
|
||||
vec![],
|
||||
Some(vec![tool]),
|
||||
vec![format!("gradle:build:{tool}"), format!("gradle:test:{tool}"), format!("gradle:run:{tool}")],
|
||||
),
|
||||
(
|
||||
"linked module inside the root reactor belongs to the reactor",
|
||||
vec![
|
||||
(
|
||||
"pom.xml".into(),
|
||||
"<project><modules><module>site/service/03_src/demo-monitor</module></modules></project>",
|
||||
),
|
||||
(format!("{deep}/pom.xml"), BOOT_POM),
|
||||
],
|
||||
vec!["site/service/03_src/demo-monitor/pom.xml"],
|
||||
None,
|
||||
vec!["maven:package".into(), "maven:test".into()],
|
||||
),
|
||||
(
|
||||
"a separate Maven build linked inside the root build's folder has its own configurations",
|
||||
vec![("pom.xml".into(), "<project></project>"), (format!("{deep}/pom.xml"), BOOT_POM)],
|
||||
vec!["site/service/03_src/demo-monitor/pom.xml"],
|
||||
None,
|
||||
vec![
|
||||
"maven:package".into(),
|
||||
"maven:test".into(),
|
||||
format!("maven:package:{deep}"),
|
||||
format!("maven:test:{deep}"),
|
||||
format!("maven:spring-boot:run:{deep}"),
|
||||
],
|
||||
),
|
||||
(
|
||||
"a Gradle subproject linked as a build belongs to the root build",
|
||||
vec![
|
||||
("settings.gradle.kts".into(), "rootProject.name = \"root\"\ninclude(\"a:b:c:tool\")\n"),
|
||||
("build.gradle.kts".into(), "plugins {\n java\n}"),
|
||||
(format!("{tool}/build.gradle.kts"), "plugins {\n application\n}"),
|
||||
],
|
||||
vec![],
|
||||
Some(vec![".", tool]),
|
||||
vec!["gradle:build".into(), "gradle:test".into()],
|
||||
),
|
||||
(
|
||||
"a separate Gradle build linked inside the root build's folder has its own configurations",
|
||||
vec![
|
||||
("settings.gradle.kts".into(), "rootProject.name = \"root\"\n"),
|
||||
("build.gradle.kts".into(), "plugins {\n java\n}"),
|
||||
(format!("{tool}/settings.gradle.kts"), "rootProject.name = \"tool\"\n"),
|
||||
(format!("{tool}/build.gradle.kts"), "plugins {\n application\n}"),
|
||||
],
|
||||
vec![],
|
||||
Some(vec![".", tool]),
|
||||
vec![
|
||||
"gradle:build".into(),
|
||||
"gradle:test".into(),
|
||||
format!("gradle:build:{tool}"),
|
||||
format!("gradle:test:{tool}"),
|
||||
format!("gradle:run:{tool}"),
|
||||
],
|
||||
),
|
||||
(
|
||||
"linked module within the search depth is not detected twice",
|
||||
vec![("svc/pom.xml".into(), "<project></project>")],
|
||||
vec!["svc/pom.xml"],
|
||||
None,
|
||||
vec!["maven:package:svc".into(), "maven:test:svc".into()],
|
||||
),
|
||||
];
|
||||
for (name, files, maven, gradle, expected) in cases {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
for (path, text) in &files {
|
||||
std::fs::create_dir_all(root.join(path).parent().unwrap()).unwrap();
|
||||
std::fs::write(root.join(path), text).unwrap();
|
||||
}
|
||||
let mut settings = ide_core::settings::Settings::default();
|
||||
settings.languages.java.maven.linked_projects = maven.into_iter().map(String::from).collect();
|
||||
settings.languages.java.gradle.linked_projects = gradle.map(|d| d.into_iter().map(String::from).collect());
|
||||
let configs = detected_and_saved(root, &settings, &[], &[]);
|
||||
let mut ids: Vec<_> = configs.iter().map(|c| c.id.clone()).collect();
|
||||
let mut expected = expected;
|
||||
ids.sort();
|
||||
expected.sort();
|
||||
assert_eq!(ids, expected, "{name}");
|
||||
for config in configs.iter().filter(|c| matches!(c.kind.as_str(), "maven" | "gradle")) {
|
||||
let cwd = config.cwd.as_deref().map(|p| p.to_string_lossy().replace('\\', "/"));
|
||||
assert!(config.id.ends_with(cwd.as_deref().unwrap_or("")), "{name}: {config:?}");
|
||||
}
|
||||
}
|
||||
|
||||
// A POM linked from outside the project folder (an extra content root).
|
||||
let (temp, outside) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
|
||||
let external = dunce::canonicalize(outside.path()).unwrap().join("svc");
|
||||
std::fs::create_dir_all(&external).unwrap();
|
||||
std::fs::write(external.join("pom.xml"), BOOT_POM).unwrap();
|
||||
let mut settings = ide_core::settings::Settings::default();
|
||||
settings.languages.java.maven.linked_projects = vec![external.join("pom.xml").to_string_lossy().into_owned()];
|
||||
let configs = detected_and_saved(temp.path(), &settings, &[], &[]);
|
||||
let package =
|
||||
configs.iter().find(|c| c.id == format!("maven:package:{}", external.to_string_lossy().replace('\\', "/")));
|
||||
assert_eq!(package.and_then(|c| c.cwd.as_deref()), Some(external.as_path()), "{configs:?}");
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
|
||||
@@ -34,9 +34,9 @@ pub struct ProjectInterpreter {
|
||||
}
|
||||
|
||||
/// Installed interpreters / toolchains of `kind`; project-local ones first.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window).ok();
|
||||
if kind == SdkKind::Jdk {
|
||||
host.apply_added_jdks();
|
||||
@@ -63,10 +63,10 @@ pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<V
|
||||
}
|
||||
|
||||
/// The Python interpreters of the recently opened projects, each with its project.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[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_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let current = host.project(window).ok().map(|p| p.root.clone());
|
||||
let config = host.config_dir.clone();
|
||||
// Probing runs the project's interpreter (and its settings may name any program): only
|
||||
@@ -111,9 +111,9 @@ 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 = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<Sdk>> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let root = host.project(window).ok().map(|p| p.root.clone());
|
||||
tokio::task::spawn_blocking(move || Ok(ide_sdk::python_interpreter_sdk(&path, root.as_deref())))
|
||||
.await
|
||||
@@ -320,7 +320,7 @@ pub async fn sdk_locate_tools(
|
||||
}
|
||||
|
||||
/// Creates a Python environment with `tool` (`venv` / `uv` / `poetry`); output streams through `on_output`.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_create_venv(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -330,7 +330,7 @@ pub async fn sdk_python_create_venv(
|
||||
request: RequestId,
|
||||
on_output: Channel<String>,
|
||||
) -> IdeResult<Sdk> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
ide_sdk::python::create_venv(tool, &base, &location, &cancel, &|line| {
|
||||
@@ -343,14 +343,14 @@ pub async fn sdk_python_create_venv(
|
||||
result?
|
||||
}
|
||||
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_packages(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
python: PathBuf,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<PythonPackage>> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result =
|
||||
tokio::task::spawn_blocking(move || ide_sdk::python::list_packages(&python, &cancel)).await.map_err(join_err);
|
||||
@@ -360,7 +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 = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_pip(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -371,7 +371,7 @@ pub async fn sdk_python_pip(
|
||||
request: RequestId,
|
||||
on_output: Channel<String>,
|
||||
) -> IdeResult<()> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let project_root = host.project(window).ok().map(|p| p.root.clone());
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
|
||||
@@ -15,9 +15,6 @@ impl ReplaceHost for DocumentsHost<'_> {
|
||||
Some(doc) => (doc, false),
|
||||
None => (docs.open(path)?.id, true),
|
||||
};
|
||||
// A buffer without unsaved changes (open only for the search preview, or a clean
|
||||
// tab) is saved like a closed file; one the user is editing is left unsaved.
|
||||
let save = transient || !docs.is_dirty(doc)?;
|
||||
let result = (|| {
|
||||
// Recompute if the user typed between reading the text and applying.
|
||||
for _ in 0..3 {
|
||||
@@ -30,7 +27,7 @@ impl ReplaceHost for DocumentsHost<'_> {
|
||||
continue;
|
||||
}
|
||||
docs.apply_edits(doc, &edits)?;
|
||||
if save {
|
||||
if transient {
|
||||
docs.save(doc)?;
|
||||
}
|
||||
return Ok(edits.len() as u32);
|
||||
@@ -49,12 +46,8 @@ impl ReplaceHost for DocumentsHost<'_> {
|
||||
///
|
||||
/// Edits go through the document layer as one patch per file, so open editors
|
||||
/// update live and undo the whole file's replacements in one step. Unsaved
|
||||
/// editor buffers are replaced in place and left unsaved; other open documents
|
||||
/// are saved, and files that were not open are opened transiently, saved and closed.
|
||||
///
|
||||
/// With `all_in_scope` (Replace All after the search hit its match limit) the
|
||||
/// scope is searched again without the limit and every match in it is replaced,
|
||||
/// as IDEA does: `targets` then only carry the `skip` positions of their files.
|
||||
/// 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(
|
||||
@@ -65,15 +58,12 @@ pub async fn replace_in_files(
|
||||
replacement: String,
|
||||
preserve_case: bool,
|
||||
targets: Vec<ReplaceTarget>,
|
||||
all_in_scope: bool,
|
||||
on_event: Channel<ReplaceEvent>,
|
||||
) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let events = on_event.clone();
|
||||
let syntax = host.syntax();
|
||||
let summary = tokio::task::spawn_blocking(move || {
|
||||
let targets = if all_in_scope { scope_targets(&project, &syntax, &query, targets, &cancel)? } else { targets };
|
||||
let host = DocumentsHost(&project.documents);
|
||||
ide_search::replace_files(&host, &query, &replacement, preserve_case, &targets, &cancel, &|e| {
|
||||
let _ = events.send(e);
|
||||
@@ -87,26 +77,6 @@ pub async fn replace_in_files(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Every file of `query`'s scope with a match (no match limit), sorted, each
|
||||
/// keeping the `skip` positions `listed` gives it.
|
||||
fn scope_targets(
|
||||
project: &crate::project::Project,
|
||||
syntax: &ide_language::Syntax,
|
||||
query: &SearchQuery,
|
||||
listed: Vec<ReplaceTarget>,
|
||||
cancel: &ide_core::CancellationToken,
|
||||
) -> IdeResult<Vec<ReplaceTarget>> {
|
||||
let mut query = query.clone();
|
||||
query.max_matches = u32::MAX;
|
||||
query.exclude.extend(project.search_excludes());
|
||||
let found = std::sync::Mutex::new(Vec::new());
|
||||
super::search_project(project, syntax, &query, cancel, &|file| found.lock().unwrap().push(file.path))?;
|
||||
let mut skip: std::collections::HashMap<_, _> = listed.into_iter().map(|t| (t.path, t.skip)).collect();
|
||||
let mut paths = found.into_inner().unwrap();
|
||||
paths.sort();
|
||||
Ok(paths.into_iter().map(|path| ReplaceTarget { skip: skip.remove(&path).flatten(), path, only: None }).collect())
|
||||
}
|
||||
|
||||
/// Before / after text of `path` for Replace › Preview (unsaved buffer included).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn replace_preview(
|
||||
|
||||
@@ -11,7 +11,7 @@ use std::path::PathBuf;
|
||||
|
||||
/// The installer, reporting the executables chosen in the window's settings.
|
||||
fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let data = host.local_data_dir.clone();
|
||||
let (settings, root) = match host.project(window) {
|
||||
Ok(project) => (project.settings.effective(), project.root.clone()),
|
||||
@@ -56,7 +56,7 @@ fn reconfigure_servers(host: &Host) {
|
||||
}
|
||||
|
||||
/// Status of every known language server / debug adapter and the languages using it.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
|
||||
let tools = tools(host, window)?;
|
||||
let langs = languages(host, window);
|
||||
@@ -65,7 +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 = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn tools_install(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -93,7 +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 = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> IdeResult<Vec<ToolUpdate>> {
|
||||
let tools = tools(host, window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
@@ -103,7 +103,7 @@ pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> Ide
|
||||
}
|
||||
|
||||
/// Removes a tool the IDE installed.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[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);
|
||||
|
||||
@@ -47,19 +47,12 @@ pub async fn serves_page(url: &str) -> bool {
|
||||
response.status().is_success() && html
|
||||
}
|
||||
|
||||
/// The built-in server's URL for `path` (started on first use). A file whose language is
|
||||
/// HTML (Settings › File Types can make it so) is served as a page, whatever its extension.
|
||||
/// 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 project = host.project(window).ok();
|
||||
let root = project.as_ref().map(|p| p.root.as_path());
|
||||
let languages = project.as_ref().map_or(&host.languages, |p| &p.languages);
|
||||
if matches!(languages.detect(&path, None).as_str(), "html" | "django-html") {
|
||||
host.web.page_url_for(root, &path).await
|
||||
} else {
|
||||
host.web.url_for(root, &path).await
|
||||
}
|
||||
let root = host.project(window).ok().map(|p| p.root.clone());
|
||||
host.web.url_for(root.as_deref(), &path).await
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -285,36 +285,6 @@ pub(super) enum Waiter {
|
||||
Prompt(std::sync::mpsc::SyncSender<Option<Vec<String>>>),
|
||||
Commit(std::sync::mpsc::SyncSender<CommitAnswer>),
|
||||
Command(std::sync::mpsc::SyncSender<super::CommandAnswer>),
|
||||
Clipboard(std::sync::mpsc::SyncSender<super::ClipboardAnswer>),
|
||||
}
|
||||
|
||||
/// What a window read from its clipboard, as `ui.read-clipboard` returns it. Oversized text
|
||||
/// or images fail here, before the base64 is decoded.
|
||||
fn clipboard_content(answer: super::ClipboardAnswer) -> Result<ide_plugin::ClipboardContent, HostError> {
|
||||
use base64::Engine;
|
||||
let (text, png) = match answer {
|
||||
super::ClipboardAnswer::Content { text, png } => (text, png),
|
||||
super::ClipboardAnswer::Refused => return Err(HostError::Denied("clipboard.read (the user refused)".into())),
|
||||
super::ClipboardAnswer::Failed { message } => return Err(HostError::Failed(message)),
|
||||
};
|
||||
let max = ide_plugin::MAX_CLIPBOARD_BYTES;
|
||||
let too_large = || HostError::Failed(format!("the clipboard holds more than {} MiB", max >> 20));
|
||||
// The longest base64 of `max` bytes.
|
||||
if text.as_ref().is_some_and(|t| t.len() > max) || png.as_ref().is_some_and(|p| p.len() > max.div_ceil(3) * 4) {
|
||||
return Err(too_large());
|
||||
}
|
||||
let image = match png.filter(|p| !p.is_empty()) {
|
||||
Some(png) => Some(
|
||||
base64::engine::general_purpose::STANDARD
|
||||
.decode(png)
|
||||
.map_err(|e| HostError::Failed(format!("the clipboard image is not valid base64: {e}")))?,
|
||||
),
|
||||
None => None,
|
||||
};
|
||||
if image.as_ref().is_some_and(|i| i.len() > max) {
|
||||
return Err(too_large());
|
||||
}
|
||||
Ok(ide_plugin::ClipboardContent { text: text.filter(|t| !t.is_empty()), image })
|
||||
}
|
||||
|
||||
/// A process a plugin started and has not released (API 1.3 `process.start`).
|
||||
@@ -983,17 +953,6 @@ impl Shared {
|
||||
tx.try_send(answer).is_ok()
|
||||
}
|
||||
|
||||
/// The window a [`PluginEvent::ClipboardRequested`] went to answered it.
|
||||
pub fn answer_clipboard(&self, client: &str, id: u64, answer: super::ClipboardAnswer) -> bool {
|
||||
let mut prompts = self.prompts.lock();
|
||||
if !matches!(prompts.get(&id), Some(PromptEntry { client: window, answer: Waiter::Clipboard(_), .. }) if window == client)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let Some(PromptEntry { answer: Waiter::Clipboard(tx), .. }) = prompts.remove(&id) else { return false };
|
||||
tx.try_send(answer).is_ok()
|
||||
}
|
||||
|
||||
pub fn answer_commit(&self, id: u64, answer: CommitAnswer) -> bool {
|
||||
let mut prompts = self.prompts.lock();
|
||||
if !matches!(prompts.get(&id), Some(PromptEntry { answer: Waiter::Commit(_), .. })) {
|
||||
@@ -1929,49 +1888,6 @@ impl HostApi for PluginApi {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_clipboard(
|
||||
&self,
|
||||
client: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> Result<ide_plugin::ClipboardContent, HostError> {
|
||||
let id = self.shared.next_prompt.fetch_add(1, Ordering::Relaxed);
|
||||
let (answer, answers) = std::sync::mpsc::sync_channel(1);
|
||||
{
|
||||
let closed = self.shared.closed_clients.lock();
|
||||
let blocked = self.shared.prompts_blocked.lock();
|
||||
if closed.contains(client) || blocked.contains(self.id()) {
|
||||
return Err(HostError::Cancelled);
|
||||
}
|
||||
self.shared.prompts.lock().insert(
|
||||
id,
|
||||
PromptEntry {
|
||||
plugin: self.id().to_owned(),
|
||||
client: client.to_owned(),
|
||||
answer: Waiter::Clipboard(answer),
|
||||
},
|
||||
);
|
||||
}
|
||||
let request_id = id.to_string();
|
||||
self.shared.sink.emit(
|
||||
Some(client),
|
||||
PluginEvent::ClipboardRequested { plugin_id: self.id().to_owned(), request_id: request_id.clone() },
|
||||
);
|
||||
// A remote window asks the user first, so there is no deadline: the call's own
|
||||
// cancellation, the plugin stopping or the window closing ends the wait.
|
||||
let answer = loop {
|
||||
match answers.recv_timeout(Duration::from_millis(100)) {
|
||||
Ok(answer) => break answer,
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Timeout) if !cancel.is_cancelled() => {}
|
||||
Err(_) => {
|
||||
self.shared.prompts.lock().remove(&id);
|
||||
self.shared.sink.emit(Some(client), PluginEvent::PromptClosed { prompt_id: request_id });
|
||||
return Err(HostError::Cancelled);
|
||||
}
|
||||
}
|
||||
};
|
||||
clipboard_content(answer)
|
||||
}
|
||||
|
||||
fn open_url(&self, client: Option<&str>, url: String) -> Result<(), HostError> {
|
||||
let client = from_window(client, "open a URL")?;
|
||||
self.shared.sink.emit(Some(client), PluginEvent::OpenUrl { plugin_id: self.id().to_owned(), url });
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
//! Plugin window commands shared by local IPC and remote RPC.
|
||||
|
||||
use super::{
|
||||
ClipboardAnswer, CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost,
|
||||
PluginInfo, PluginStatusItem, WorkbenchEvent,
|
||||
CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost, PluginInfo,
|
||||
PluginStatusItem, WorkbenchEvent,
|
||||
};
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
@@ -127,18 +127,6 @@ pub fn plugin_answer_command(
|
||||
Ok(plugins.answer_command(window, &request_id, answer))
|
||||
}
|
||||
|
||||
/// This window's clipboard for a plugin's `clipboardRequested`; false when the call no
|
||||
/// longer waits or asked another window.
|
||||
#[command(trust = trusted)]
|
||||
pub fn plugin_answer_clipboard(
|
||||
plugins: &Arc<PluginHost>,
|
||||
window: &str,
|
||||
request_id: String,
|
||||
answer: ClipboardAnswer,
|
||||
) -> IdeResult<bool> {
|
||||
Ok(plugins.answer_clipboard(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 {
|
||||
@@ -290,7 +278,6 @@ pub async fn plugin_debug_attach_target(
|
||||
|
||||
ide_command::domain!(
|
||||
plugins_commands:
|
||||
plugin_answer_clipboard,
|
||||
plugin_answer_command,
|
||||
plugin_answer_commit,
|
||||
plugin_answer_prompt,
|
||||
|
||||
@@ -162,8 +162,7 @@ impl PluginHost {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// What a plugin receives for `document-changed`: the path relative to the file's own
|
||||
/// project, and that project's root, since two open projects can hold the same relative path.
|
||||
/// What a plugin receives for `document-changed`: the path relative to the file's own project.
|
||||
pub(super) fn relativize_documents(
|
||||
shared: &super::api::Shared,
|
||||
client: Option<&str>,
|
||||
@@ -182,7 +181,6 @@ impl PluginHost {
|
||||
.to_string_lossy()
|
||||
.replace('\\', "/");
|
||||
change.path = relative;
|
||||
change.project = Some(ide_core::ipc_path::to_ipc(&root));
|
||||
Some(WorkbenchEvent::DocumentChanged(change))
|
||||
})
|
||||
.collect()
|
||||
|
||||
@@ -1806,12 +1806,6 @@ impl PluginHost {
|
||||
request.parse().is_ok_and(|id| self.shared.answer_command(client, id, answer))
|
||||
}
|
||||
|
||||
/// A window answered a plugin's `ClipboardRequested`; false when the call no longer
|
||||
/// waits or asked another window.
|
||||
pub fn answer_clipboard(&self, client: &str, request_id: &str, answer: ClipboardAnswer) -> bool {
|
||||
request_id.parse().is_ok_and(|id| self.shared.answer_clipboard(client, id, answer))
|
||||
}
|
||||
|
||||
pub fn answer_commit(&self, request_id: &str, answer: CommitAnswer) -> bool {
|
||||
request_id.parse().is_ok_and(|id| self.shared.answer_commit(id, answer))
|
||||
}
|
||||
|
||||
@@ -169,7 +169,6 @@ pub fn forwarded(event: &PluginEvent) -> bool {
|
||||
| PluginEvent::PromptWaiting { .. }
|
||||
| PluginEvent::RevealView { .. }
|
||||
| PluginEvent::CommitRequested { .. }
|
||||
| PluginEvent::ClipboardRequested { .. }
|
||||
| PluginEvent::EndpointsChanged { .. }
|
||||
)
|
||||
}
|
||||
|
||||
@@ -352,10 +352,6 @@ pub enum PluginEvent {
|
||||
/// `plugin_answer_commit(request_id, …)`. Closed like a prompt (`PromptClosed`).
|
||||
#[serde(rename_all = "camelCase")]
|
||||
CommitRequested { plugin_id: String, request_id: String, request: CommitRequest },
|
||||
/// A command the user ran reads the clipboard (`ui.read-clipboard`): answer with
|
||||
/// `plugin_answer_clipboard(request_id, …)`. Closed like a prompt (`PromptClosed`).
|
||||
#[serde(rename_all = "camelCase")]
|
||||
ClipboardRequested { plugin_id: String, request_id: String },
|
||||
}
|
||||
|
||||
/// What a plugin asks of a window's Commit view.
|
||||
@@ -493,18 +489,6 @@ pub struct PluginCommitCheckResult {
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
/// A window's answer to `ClipboardRequested`: its machine's clipboard.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum ClipboardAnswer {
|
||||
/// `None` for a kind the clipboard doesn't hold; `png` is base64.
|
||||
Content { text: Option<String>, png: Option<String> },
|
||||
/// The user refused (a remote window asks first).
|
||||
Refused,
|
||||
/// The window could not read the clipboard.
|
||||
Failed { message: String },
|
||||
}
|
||||
|
||||
/// The invoking window's response to a command request.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", content = "value", rename_all = "camelCase")]
|
||||
|
||||
@@ -108,9 +108,6 @@ impl Host {
|
||||
let trusted = Arc::new(AtomicBool::new(self.trust.window_trusted(&root)?));
|
||||
let post_start =
|
||||
trusted.load(Ordering::Acquire).then(|| self.environment.project_opened(&root, &sink)).flatten();
|
||||
if trusted.load(Ordering::Acquire) {
|
||||
self.environment.direnv_opened(&root, &sink);
|
||||
}
|
||||
let settings = SettingsStore::load(&self.config_dir, Some(&root));
|
||||
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
|
||||
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
|
||||
@@ -183,14 +180,7 @@ impl Host {
|
||||
ide_sdk::apply::server_launch_overrides(cfg, &effective);
|
||||
ide_sdk::apply::configure_server(cfg, root, server_root, &effective);
|
||||
ide_sdk::apply::configure_vue_module_resolution(cfg, &data_dir);
|
||||
let container_python = effective.languages.python.run_target().is_some();
|
||||
crate::ops::sdk::container_python::configure_server(cfg, &data_dir, root, &effective);
|
||||
// Attached dependency projects are source, so basedpyright/Pyright should
|
||||
// resolve imports into them. A container target already supplies its own
|
||||
// `extraPaths` (the site-packages snapshot); don't mix local sources into it.
|
||||
if !container_python {
|
||||
ide_sdk::apply::configure_python_extra_paths(cfg, &python_dependency_roots(&effective, root));
|
||||
}
|
||||
if cfg.name == "jdtls" {
|
||||
// A workspace member keeps its build model under its own key (Build Project).
|
||||
let cache = match &member {
|
||||
@@ -272,7 +262,6 @@ impl Host {
|
||||
lombok.jar(),
|
||||
);
|
||||
ide_sdk::apply::configure_gradle_runtime(cfg, root, server_root, &effective);
|
||||
ide_sdk::apply::configure_maven_sources(cfg, &effective);
|
||||
ide_sdk::jdtls::launch_directly(cfg);
|
||||
}
|
||||
ide_sdk::apply::server_protocol_overrides(cfg, &effective);
|
||||
@@ -286,8 +275,6 @@ impl Host {
|
||||
effective.languages.java.gradle.linked_projects.as_deref(),
|
||||
build_files.as_deref(),
|
||||
);
|
||||
// After the import settings: they extend the workspace folder's name.
|
||||
ide_sdk::jdtls_workspaces::use_own_temp(cfg, &data_dir);
|
||||
}
|
||||
}));
|
||||
}
|
||||
@@ -324,7 +311,7 @@ impl Host {
|
||||
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
|
||||
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
|
||||
documents.add_observer(Arc::new(LspObserver(lsp.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver::new(history.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver(history.clone())));
|
||||
documents.add_observer(Arc::new(DeployObserver {
|
||||
remote: self.remote.clone(),
|
||||
settings: settings.clone(),
|
||||
@@ -400,14 +387,6 @@ impl Host {
|
||||
if composer_changed(&root, changed.iter().chain(&batch.removed)) {
|
||||
lsp.reconfigure_soon();
|
||||
}
|
||||
// Not while loading: a first `use flake` may write `flake.lock` itself.
|
||||
if trusted.load(Ordering::Acquire)
|
||||
&& !ide_core::project_env::is_loading(&root)
|
||||
&& let Some(file) = crate::direnv::reload_offer(&root, changed.iter().chain(&batch.removed))
|
||||
{
|
||||
let status = ide_core::event::DirenvStatus::Changed { file };
|
||||
sink.emit(IdeEvent::Direnv { root: root.clone().into(), status });
|
||||
}
|
||||
// Atomic saves by external tools surface as `created`.
|
||||
documents.on_disk_changed(&[&changed[..], &ignored].concat());
|
||||
if let Some(plugins) = crate::plugins::editor_plugin_host() {
|
||||
@@ -785,7 +764,7 @@ impl Host {
|
||||
lsp.set_servers_hook(Box::new(|_, _| Vec::new()));
|
||||
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
|
||||
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver::new(history.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver(history.clone())));
|
||||
let watcher = match watch_dir {
|
||||
Some(dir) => light_watcher(dir, &sink, &documents, &history)?,
|
||||
// A quiet private folder stands in until the first save brings a
|
||||
@@ -1504,30 +1483,6 @@ fn member_dependencies_for<'a>(map: &'a BTreeMap<String, Vec<String>>, own_key:
|
||||
map.iter().find(|(key, _)| ide_core::ipc_path::to_ipc(&PathBuf::from(key)) == own_key).map(|(_, deps)| deps)
|
||||
}
|
||||
|
||||
/// Dependency roots of `root`, for a Python language server's `analysis.extraPaths`.
|
||||
/// In a workspace a member depends only on the roots picked for it in Project
|
||||
/// Structure › Dependencies; outside one, the project-level `dependencies` list applies.
|
||||
fn python_dependency_roots(settings: &ide_core::settings::Settings, root: &Path) -> Vec<PathBuf> {
|
||||
let own_key = ide_core::ipc_path::to_ipc(root);
|
||||
let configured = if ide_workspace::workspace::Workspace::load(root).ok().flatten().is_some() {
|
||||
member_dependencies_for(&settings.project_structure.member_dependencies, &own_key).cloned().unwrap_or_default()
|
||||
} else {
|
||||
settings.project_structure.dependencies.clone()
|
||||
};
|
||||
configured
|
||||
.into_iter()
|
||||
.map(|p| PathBuf::from(p.trim()))
|
||||
.filter(|p| p.is_absolute() && p.is_dir())
|
||||
// A `src` layout keeps its packages one level down; basedpyright searches a
|
||||
// project's own `src` by itself, but not an extra path's.
|
||||
.flat_map(|p| {
|
||||
let src = p.join("src");
|
||||
let src = src.is_dir().then_some(src);
|
||||
std::iter::once(p).chain(src)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn extra_content_roots(
|
||||
settings: &ide_core::settings::Settings,
|
||||
root: &Path,
|
||||
@@ -1890,42 +1845,14 @@ impl DocumentObserver for SyntaxObserver {
|
||||
}
|
||||
}
|
||||
|
||||
struct HistoryObserver {
|
||||
history: Arc<LocalHistory>,
|
||||
/// Documents edited since they were opened: only the first edit looks for a missing original.
|
||||
edited: Mutex<HashSet<ide_core::DocId>>,
|
||||
}
|
||||
|
||||
impl HistoryObserver {
|
||||
fn new(history: Arc<LocalHistory>) -> Self {
|
||||
Self { history, edited: Mutex::default() }
|
||||
}
|
||||
}
|
||||
struct HistoryObserver(Arc<LocalHistory>);
|
||||
|
||||
impl DocumentObserver for HistoryObserver {
|
||||
fn changed(
|
||||
&self,
|
||||
doc: ide_core::DocId,
|
||||
path: &Path,
|
||||
_version: u32,
|
||||
_changes: &[AppliedChange],
|
||||
_full_text: &dyn Fn() -> String,
|
||||
) {
|
||||
// The file on disk still has its content from before the edit.
|
||||
if self.edited.lock().insert(doc)
|
||||
&& let Err(e) = self.history.record_original(path)
|
||||
{
|
||||
tracing::warn!("local history: {e}");
|
||||
}
|
||||
}
|
||||
fn saved(&self, _doc: ide_core::DocId, path: &Path, text: &str) {
|
||||
if let Err(e) = self.history.record(path, text, "Saved") {
|
||||
if let Err(e) = self.0.record(path, text, "Saved") {
|
||||
tracing::warn!("local history: {e}");
|
||||
}
|
||||
}
|
||||
fn closed(&self, doc: ide_core::DocId, _path: &Path) {
|
||||
self.edited.lock().remove(&doc);
|
||||
}
|
||||
}
|
||||
|
||||
/// Uploads saved files: remote files' local copies, and automatic upload to the default server.
|
||||
@@ -2290,47 +2217,6 @@ mod content_roots_tests {
|
||||
assert_eq!(roots, vec![shared, dep]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn python_dependency_roots_use_project_dependencies_outside_a_workspace() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("app");
|
||||
let dep = tmp.path().join("lib");
|
||||
let missing = tmp.path().join("gone");
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
std::fs::create_dir_all(&dep).unwrap();
|
||||
let src_layout = tmp.path().join("pkg");
|
||||
std::fs::create_dir_all(src_layout.join("src/pkg")).unwrap();
|
||||
let mut settings = ide_core::settings::Settings::default();
|
||||
settings.project_structure.dependencies = vec![
|
||||
dep.to_string_lossy().into_owned(),
|
||||
missing.to_string_lossy().into_owned(),
|
||||
"relative".into(),
|
||||
src_layout.to_string_lossy().into_owned(),
|
||||
];
|
||||
assert_eq!(
|
||||
super::python_dependency_roots(&settings, &root),
|
||||
vec![dep, src_layout.clone(), src_layout.join("src")]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn python_dependency_roots_use_the_members_own_picks_inside_a_workspace() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ws = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let (app, lib, other) = (ws.join("app"), ws.join("lib"), ws.join("other"));
|
||||
for dir in [&app, &lib, &other] {
|
||||
std::fs::create_dir_all(dir).unwrap();
|
||||
}
|
||||
ide_workspace::workspace::Workspace::attach(&app, "ws", vec![app.clone(), lib.clone(), other.clone()]).unwrap();
|
||||
let mut settings = ide_core::settings::Settings::default();
|
||||
let key = |p: &std::path::Path| ide_core::ipc_path::to_ipc(p);
|
||||
settings.project_structure.member_dependencies.insert(key(&app), vec![key(&lib)]);
|
||||
settings.project_structure.member_dependencies.insert(key(&other), vec![key(&app)]);
|
||||
// Project-level dependencies are ignored: inside a workspace, members pick their own.
|
||||
settings.project_structure.dependencies = vec![key(&other)];
|
||||
assert_eq!(super::python_dependency_roots(&settings, &app), vec![lib]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -184,7 +184,6 @@ pub fn client_accepts(event: &IdeEvent) -> bool {
|
||||
| IdeEvent::UpdateAvailable { .. } => false,
|
||||
IdeEvent::DbSourcesChanged
|
||||
| IdeEvent::ProjectTrustChanged { .. }
|
||||
| IdeEvent::Direnv { .. }
|
||||
| IdeEvent::FsChanged { .. }
|
||||
| IdeEvent::ExcludedDirsChanged { .. }
|
||||
| IdeEvent::DocPatched { .. }
|
||||
|
||||
@@ -275,12 +275,10 @@ impl crate::Host {
|
||||
if let Some(cmd) = self.environment.project_opened(&project.root, &project.sink) {
|
||||
self.environment.spawn_post_start(cmd, project.root.clone(), project.sink.clone());
|
||||
}
|
||||
self.environment.direnv_opened(&project.root, &project.sink);
|
||||
project.lsp.set_execution_allowed(true);
|
||||
project.lsp.prewarm_java_configuration();
|
||||
} else {
|
||||
self.environment.project_closed();
|
||||
self.environment.direnv_closed(&project.root);
|
||||
project.agents.shutdown();
|
||||
self.processes.kill_project(&project.root);
|
||||
project.notebooks.restrict().await;
|
||||
|
||||
@@ -1,130 +0,0 @@
|
||||
//! A project's direnv environment through the host, with a stand-in `direnv` on `PATH`: it
|
||||
//! runs in trusted projects only, reaches the children started in the project, loads again
|
||||
//! on Reload Environment and goes with trust or the project.
|
||||
//! One test in its own binary: it changes this process's `PATH`.
|
||||
#![cfg(unix)]
|
||||
|
||||
use ide_core::event::DirenvStatus;
|
||||
use ide_core::{EventSink, IdeEvent, SharedSink};
|
||||
use ide_host::{Host, HostConfig};
|
||||
use parking_lot::Mutex;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
#[derive(Default)]
|
||||
struct Events(Mutex<Vec<IdeEvent>>);
|
||||
|
||||
impl EventSink for Events {
|
||||
fn emit(&self, e: IdeEvent) {
|
||||
self.0.lock().push(e);
|
||||
}
|
||||
}
|
||||
|
||||
/// What a child started in `dir` now sees for `name`.
|
||||
fn child_var(dir: &Path, name: &str) -> String {
|
||||
let out = ide_core::process::prepare(Command::new("/bin/sh").current_dir(dir))
|
||||
.args(["-c", &format!("printf %s \"${name}\"")])
|
||||
.output()
|
||||
.unwrap();
|
||||
String::from_utf8(out.stdout).unwrap()
|
||||
}
|
||||
|
||||
fn wait_for(what: &str, mut done: impl FnMut() -> bool) {
|
||||
let deadline = Instant::now() + Duration::from_secs(20);
|
||||
while !done() {
|
||||
assert!(Instant::now() < deadline, "timed out waiting for {what}");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direnv_runs_in_trusted_projects_and_reaches_their_children() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let tmp = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let bin = tmp.join("bin");
|
||||
std::fs::create_dir_all(&bin).unwrap();
|
||||
// Logs each run to `runs` and prints `out.json`, or blocks like direnv on `.envrc` not allowed.
|
||||
let direnv = bin.join("direnv");
|
||||
std::fs::write(
|
||||
&direnv,
|
||||
"#!/bin/sh\necho run >> runs\n[ -f blocked ] && { echo \"direnv: error $PWD/.envrc is blocked. Run \\`direnv allow\\` to approve its content\" >&2; exit 1; }\ncat out.json\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&direnv, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let path =
|
||||
std::env::join_paths(std::iter::once(bin).chain(std::env::split_paths(&std::env::var_os("PATH").unwrap())))
|
||||
.unwrap();
|
||||
// SAFETY: no other thread runs yet.
|
||||
unsafe {
|
||||
std::env::set_var("PATH", path);
|
||||
// Reload Environment must not read this machine's login shell.
|
||||
std::env::set_var("OPENIDEA_SKIP_SHELL_ENV", "1");
|
||||
}
|
||||
|
||||
let project = tmp.join("flake-project");
|
||||
std::fs::create_dir_all(project.join("src")).unwrap();
|
||||
std::fs::write(project.join(".envrc"), "use flake\n").unwrap();
|
||||
std::fs::write(project.join("out.json"), r#"{"OPENIDEA_DEVSHELL":"one"}"#).unwrap();
|
||||
let runs = || std::fs::read_to_string(project.join("runs")).unwrap_or_default().lines().count();
|
||||
|
||||
let runtime = tokio::runtime::Builder::new_multi_thread().worker_threads(2).enable_all().build().unwrap();
|
||||
let events = Arc::new(Events::default());
|
||||
let sink_events = events.clone();
|
||||
let base = tmp.join("host");
|
||||
let host = Arc::new(Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(move |_| sink_events.clone() as SharedSink),
|
||||
owner: |w| w,
|
||||
runtime: runtime.handle().clone(),
|
||||
// The desktop: several projects in one process.
|
||||
project_environment: false,
|
||||
}));
|
||||
|
||||
// Restricted Mode: `.envrc` is project code and doesn't run.
|
||||
host.trust.decide(&project, false, false).unwrap();
|
||||
runtime.block_on(ide_host::ops::project::open(&host, "main", &project)).unwrap();
|
||||
std::thread::sleep(Duration::from_millis(300));
|
||||
assert_eq!(runs(), 0);
|
||||
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
|
||||
|
||||
// Trusted: it loads, for children started in the project only.
|
||||
runtime.block_on(host.set_project_trust(&project, true, false)).unwrap();
|
||||
wait_for("the direnv environment", || child_var(&project.join("src"), "OPENIDEA_DEVSHELL") == "one");
|
||||
assert_eq!(runs(), 1);
|
||||
assert_eq!(child_var(&tmp, "OPENIDEA_DEVSHELL"), "", "outside the project");
|
||||
|
||||
// Reload Environment loads it again.
|
||||
std::fs::write(project.join("out.json"), r#"{"OPENIDEA_DEVSHELL":"two"}"#).unwrap();
|
||||
let reloaded = runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
|
||||
assert!(reloaded.changed.iter().any(|c| c == "OPENIDEA_DEVSHELL"), "{:?}", reloaded.changed);
|
||||
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "two");
|
||||
|
||||
// Blocked after an edit: said so, never allowed by the IDE, and the environment goes.
|
||||
std::fs::write(project.join("blocked"), "").unwrap();
|
||||
runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
|
||||
assert!(
|
||||
events.0.lock().iter().any(|e| matches!(e, IdeEvent::Direnv { status: DirenvStatus::Blocked, .. })),
|
||||
"a blocked notice"
|
||||
);
|
||||
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
|
||||
std::fs::remove_file(project.join("blocked")).unwrap();
|
||||
runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
|
||||
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "two");
|
||||
|
||||
// Revoking trust drops it; so does closing the project.
|
||||
runtime.block_on(host.set_project_trust(&project, false, false)).unwrap();
|
||||
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
|
||||
runtime.block_on(host.set_project_trust(&project, true, false)).unwrap();
|
||||
wait_for("the reloaded environment", || child_var(&project, "OPENIDEA_DEVSHELL") == "two");
|
||||
host.close_project("main");
|
||||
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
|
||||
|
||||
runtime.block_on(host.shutdown());
|
||||
}
|
||||
@@ -662,34 +662,6 @@ async fn rust_references_and_rename_through_mcp() {
|
||||
assert!(std::time::Instant::now() < deadline, "language server did not find format_price references");
|
||||
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
|
||||
}
|
||||
// Its callers, the callees of one of them, and the hierarchy at a call.
|
||||
let callers = h.json("get_call_hierarchy", args.clone()).await;
|
||||
assert_eq!(callers["root"]["name"], "format_price", "{callers}");
|
||||
let main = callers["items"].as_array().unwrap().iter().find(|i| i["name"] == "main").expect("main calls it");
|
||||
assert_eq!(main["filePath"], "src/main.rs");
|
||||
let call = main["callSites"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|s| s["lineText"].as_str().unwrap().contains("format_price("))
|
||||
.expect("the call in main");
|
||||
assert_eq!(call["filePath"], "src/main.rs");
|
||||
let callees = h
|
||||
.json("get_call_hierarchy", json!({"filePath":"src/main.rs", "line":main["startLine"], "column":main["startColumn"], "direction":"outgoing"}))
|
||||
.await;
|
||||
// rust-analyzer leaves out the calls inside macro arguments, such as `format_price` in `println!`.
|
||||
let parse = callees["items"].as_array().unwrap().iter().find(|i| i["name"] == "parse").expect("main calls parse");
|
||||
assert_eq!(
|
||||
(&parse["filePath"], &parse["callSites"][0]["filePath"]),
|
||||
(&json!("src/parser.rs"), &json!("src/main.rs"))
|
||||
);
|
||||
let at_call = h
|
||||
.json("get_call_hierarchy", json!({"filePath":"src/main.rs", "line":call["startLine"], "column":call["startColumn"], "direction":"outgoing"}))
|
||||
.await;
|
||||
assert_eq!(
|
||||
(&at_call["root"]["name"], &at_call["root"]["filePath"]),
|
||||
(&json!("format_price"), &json!("src/lib.rs"))
|
||||
);
|
||||
let result = h.json("rename_refactoring", json!({"pathInProject":"src/lib.rs", "symbolName":"format_price", "newName":"format_amount", "line":line + 1, "column":column})).await;
|
||||
assert_eq!(result["applied"], true, "{result}");
|
||||
assert!(project.documents.text_snapshot(doc.id).unwrap().text.contains("format_amount"));
|
||||
@@ -1007,218 +979,3 @@ async fn http_list_and_run_require_confirmation() {
|
||||
assert!(result.get("headers").is_none(), "{result}");
|
||||
assert!(result.get("request").is_none(), "{result}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn call_hierarchy_is_listed_for_untrusted_projects() {
|
||||
let h = Harness::new();
|
||||
let tools = Registry::new(h.host.clone()).tools(&h.root).unwrap();
|
||||
assert!(tools.iter().any(|t| t.name == "get_call_hierarchy"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn call_hierarchy_without_a_language_server_says_it_is_unsupported() {
|
||||
let h = Harness::new();
|
||||
let error = h.error("get_call_hierarchy", json!({"filePath":"src/a.txt","line":1,"column":1})).await;
|
||||
assert!(error.contains("call hierarchy"), "{error}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn call_hierarchy_rejects_an_unknown_direction() {
|
||||
let h = Harness::new();
|
||||
let args = json!({"filePath":"src/a.txt","line":1,"column":1,"direction":"up"});
|
||||
assert_eq!(h.error("get_call_hierarchy", args).await, "direction must be incoming or outgoing");
|
||||
}
|
||||
|
||||
/// `src/lib.rs`: `price` calls `double`; `src/main.rs`: `main` calls `price` and `show`;
|
||||
/// `other/c.rs`: `helper` calls `price`; a library class calls it too.
|
||||
const LIB_RS: &str = "pub fn price(cents: u64) -> u64 {\n double(cents)\n}\nfn double(v: u64) -> u64 { v * 2 }\n";
|
||||
const MAIN_RS: &str = "fn main() {\n let a = price(1);\n show(a);\n}\nfn show(v: u64) {}\n";
|
||||
const C_RS: &str = "fn helper() {\n price(2);\n}\n";
|
||||
const LIBRARY_URI: &str = "jar:file:///lib.jar!/Caller.class";
|
||||
|
||||
/// A language server for `rust` that knows the call hierarchy of the files above.
|
||||
struct CallServer {
|
||||
root: PathBuf,
|
||||
}
|
||||
|
||||
impl CallServer {
|
||||
fn uri(&self, path: &str) -> String {
|
||||
ide_lsp::path_to_uri_string(&self.root.join(path))
|
||||
}
|
||||
fn item(&self, name: &str) -> Value {
|
||||
let r = |l, c, l2, c2| json!({"start":{"line":l,"character":c},"end":{"line":l2,"character":c2}});
|
||||
let (uri, range, selection) = match name {
|
||||
"price" => (self.uri("src/lib.rs"), r(0, 0, 2, 1), r(0, 7, 0, 12)),
|
||||
"double" => (self.uri("src/lib.rs"), r(3, 0, 3, 34), r(3, 3, 3, 9)),
|
||||
"main" => (self.uri("src/main.rs"), r(0, 0, 3, 1), r(0, 3, 0, 7)),
|
||||
"show" => (self.uri("src/main.rs"), r(4, 0, 4, 18), r(4, 3, 4, 7)),
|
||||
"helper" => (self.uri("other/c.rs"), r(0, 0, 2, 1), r(0, 3, 0, 9)),
|
||||
_ => (LIBRARY_URI.to_owned(), r(0, 0, 9, 1), r(2, 4, 2, 10)),
|
||||
};
|
||||
json!({"name":name,"kind":12,"uri":uri,"range":range,"selectionRange":selection})
|
||||
}
|
||||
fn call(&self, name: &str, key: &str, sites: &[(u32, u32, u32)]) -> Value {
|
||||
let sites: Vec<Value> = sites
|
||||
.iter()
|
||||
.map(|(l, c, c2)| json!({"start":{"line":l,"character":c},"end":{"line":l,"character":c2}}))
|
||||
.collect();
|
||||
json!({key: self.item(name), "fromRanges": sites})
|
||||
}
|
||||
/// The item named at `p`: on a declaration's name or on a call.
|
||||
fn prepare(&self, p: &Value) -> Value {
|
||||
let uri = p["textDocument"]["uri"].as_str().unwrap();
|
||||
let (line, col) = (p["position"]["line"].as_u64().unwrap(), p["position"]["character"].as_u64().unwrap());
|
||||
let on =
|
||||
|path: &str, l: u64, from: u64, to: u64| uri == self.uri(path) && line == l && (from..=to).contains(&col);
|
||||
let name = if on("src/lib.rs", 0, 7, 12) || on("src/main.rs", 1, 12, 17) {
|
||||
"price"
|
||||
} else if on("src/main.rs", 0, 3, 7) {
|
||||
"main"
|
||||
} else {
|
||||
return Value::Null;
|
||||
};
|
||||
json!([self.item(name)])
|
||||
}
|
||||
}
|
||||
|
||||
impl ide_jsonrpc::Handler for CallServer {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
|
||||
let item = p["item"]["name"].as_str().unwrap_or_default();
|
||||
Ok(match method {
|
||||
"initialize" => json!({"capabilities": {
|
||||
"textDocumentSync": {"openClose": true, "change": 1},
|
||||
"callHierarchyProvider": true,
|
||||
"documentSymbolProvider": true,
|
||||
}}),
|
||||
"textDocument/prepareCallHierarchy" => self.prepare(&p),
|
||||
"callHierarchy/incomingCalls" if item == "price" => json!([
|
||||
self.call("main", "from", &[(1, 12, 17)]),
|
||||
self.call("helper", "from", &[(1, 4, 9)]),
|
||||
self.call("Caller", "from", &[(2, 8, 13)]),
|
||||
]),
|
||||
"callHierarchy/outgoingCalls" if item == "price" => json!([self.call("double", "to", &[(1, 4, 10)])]),
|
||||
"callHierarchy/outgoingCalls" if item == "main" => {
|
||||
json!([self.call("show", "to", &[(2, 4, 8)]), self.call("price", "to", &[(1, 12, 17)])])
|
||||
}
|
||||
"textDocument/documentSymbol" if p["textDocument"]["uri"] == self.uri("src/main.rs") => {
|
||||
let symbol = |name| {
|
||||
let item = self.item(name);
|
||||
json!({"name":name,"kind":12,"range":item["range"],"selectionRange":item["selectionRange"]})
|
||||
};
|
||||
json!([symbol("main"), symbol("show")])
|
||||
}
|
||||
"callHierarchy/incomingCalls" | "callHierarchy/outgoingCalls" | "textDocument/documentSymbol" => json!([]),
|
||||
_ => Value::Null,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// The harness with the files above and [`CallServer`] serving them.
|
||||
async fn call_hierarchy_harness() -> (Harness, tokio::task::JoinHandle<()>) {
|
||||
let h = Harness::new();
|
||||
h.trust().await;
|
||||
for (path, text) in [("src/lib.rs", LIB_RS), ("src/main.rs", MAIN_RS), ("other/c.rs", C_RS)] {
|
||||
std::fs::create_dir_all(h.root.join(path).parent().unwrap()).unwrap();
|
||||
std::fs::write(h.root.join(path), text).unwrap();
|
||||
}
|
||||
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let server = Arc::new(CallServer { root: h.root.clone() });
|
||||
let accept = tokio::spawn(async move {
|
||||
let mut peers = Vec::new();
|
||||
while let Ok((stream, _)) = listener.accept().await {
|
||||
let (r, w) = stream.into_split();
|
||||
peers.push(ide_jsonrpc::Peer::connect(r, w, server.clone()));
|
||||
}
|
||||
});
|
||||
let cfg: ide_language::LanguageServerConfig =
|
||||
toml::from_str(&format!("name='calls'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
|
||||
h.host.project("main").unwrap().lsp.set_servers_hook(Box::new(move |language, _| {
|
||||
if language.as_str() == "rust" { vec![cfg.clone()] } else { Vec::new() }
|
||||
}));
|
||||
(h, accept)
|
||||
}
|
||||
|
||||
fn names(result: &Value) -> Vec<&str> {
|
||||
result["items"].as_array().unwrap().iter().map(|i| i["name"].as_str().unwrap()).collect()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn call_hierarchy_lists_callers_with_their_call_sites() {
|
||||
let (h, _server) = call_hierarchy_harness().await;
|
||||
let callers = h.json("get_call_hierarchy", json!({"filePath":"src/lib.rs","line":1,"column":9})).await;
|
||||
assert_eq!(callers["root"]["name"], "price");
|
||||
assert_eq!(callers["root"]["filePath"], "src/lib.rs");
|
||||
assert_eq!(callers["root"]["lineText"], "pub fn price(cents: u64) -> u64 {");
|
||||
assert_eq!(callers["total"], 3);
|
||||
let main = callers["items"].as_array().unwrap().iter().find(|i| i["name"] == "main").unwrap();
|
||||
assert_eq!(
|
||||
main,
|
||||
&json!({"name":"main","kind":"function","filePath":"src/main.rs",
|
||||
"startLine":1,"startColumn":4,"endLine":1,"endColumn":8,"lineText":"fn main() {",
|
||||
"callSites":[{"filePath":"src/main.rs","startLine":2,"startColumn":13,"endLine":2,"endColumn":18,
|
||||
"lineText":" let a = price(1);"}]})
|
||||
);
|
||||
// An item's position is a valid input for the next level.
|
||||
let main_calls = h
|
||||
.json(
|
||||
"get_call_hierarchy",
|
||||
json!({"filePath":"src/main.rs","line":main["startLine"],"column":main["startColumn"],"direction":"outgoing"}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(names(&main_calls), ["price", "show"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn outgoing_call_sites_are_in_the_file_of_the_root() {
|
||||
let (h, _server) = call_hierarchy_harness().await;
|
||||
// On the call `price(1)` in main.rs: the hierarchy of `price`, declared in lib.rs.
|
||||
let callees = h
|
||||
.json("get_call_hierarchy", json!({"filePath":"src/main.rs","line":2,"column":14,"direction":"outgoing"}))
|
||||
.await;
|
||||
assert_eq!(callees["root"]["filePath"], "src/lib.rs");
|
||||
assert_eq!(names(&callees), ["double"]);
|
||||
assert_eq!(
|
||||
callees["items"][0]["callSites"],
|
||||
json!([{"filePath":"src/lib.rs","startLine":2,"startColumn":5,"endLine":2,"endColumn":11,"lineText":" double(cents)"}])
|
||||
);
|
||||
let from_main = h
|
||||
.json("get_call_hierarchy", json!({"filePath":"src/main.rs","line":1,"column":4,"direction":"outgoing"}))
|
||||
.await;
|
||||
let price = &from_main["items"][0];
|
||||
assert_eq!((&price["filePath"], &price["callSites"][0]["filePath"]), (&json!("src/lib.rs"), &json!("src/main.rs")));
|
||||
assert_eq!(price["callSites"][0]["lineText"], " let a = price(1);");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_position_in_a_function_body_means_that_function() {
|
||||
let (h, _server) = call_hierarchy_harness().await;
|
||||
let body = json!({"filePath":"src/main.rs","line":2,"column":5,"direction":"outgoing"});
|
||||
let callees = h.json("get_call_hierarchy", body).await;
|
||||
assert_eq!(callees["root"]["name"], "main");
|
||||
assert_eq!(names(&callees), ["price", "show"]);
|
||||
let outside = h.error("get_call_hierarchy", json!({"filePath":"src/main.rs","line":6,"column":1})).await;
|
||||
assert_eq!(outside, "no function or method at 6:1");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn call_hierarchy_pages_are_sorted_and_scoped() {
|
||||
let (h, _server) = call_hierarchy_harness().await;
|
||||
let at = |extra: Value| {
|
||||
let mut args = json!({"filePath":"src/lib.rs","line":1,"column":9});
|
||||
args.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
|
||||
args
|
||||
};
|
||||
let first = h.json("get_call_hierarchy", at(json!({"limit":2}))).await;
|
||||
assert_eq!(names(&first), ["Caller", "helper"]);
|
||||
assert_eq!(first["items"][0]["filePath"], LIBRARY_URI);
|
||||
assert!(first["items"][0].get("lineText").is_none(), "{first}");
|
||||
assert_eq!((&first["more"], &first["nextOffset"]), (&json!(true), &json!(2)));
|
||||
let next = h.json("get_call_hierarchy", at(json!({"limit":2,"offset":2}))).await;
|
||||
assert_eq!(names(&next), ["main"]);
|
||||
let scoped = h.json("get_call_hierarchy", at(json!({"scope":"src"}))).await;
|
||||
assert_eq!(names(&scoped), ["main"]);
|
||||
assert_eq!(scoped["total"], 1);
|
||||
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the scope");
|
||||
}
|
||||
@@ -1,234 +0,0 @@
|
||||
//! `ui.read-clipboard` (API 1.11) through the `test.clipboard` fixture and a
|
||||
//! scripted window answering `ClipboardRequested`: commands and view actions the
|
||||
//! user ran read the window's clipboard, anything unattended is denied.
|
||||
|
||||
use base64::Engine;
|
||||
use ide_host::plugins::*;
|
||||
use ide_plugin::{HostError, Invocation, Limits, ViewEvent};
|
||||
use parking_lot::Mutex;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const ID: &str = "test.clipboard";
|
||||
|
||||
fn fixture_dir() -> PathBuf {
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/clipboard")
|
||||
}
|
||||
|
||||
struct Workspace {
|
||||
root: PathBuf,
|
||||
}
|
||||
|
||||
impl PluginWorkspace for Workspace {
|
||||
fn projects(&self) -> Vec<PathBuf> {
|
||||
vec![self.root.clone()]
|
||||
}
|
||||
fn buffer_text(&self, _: &Path) -> Option<String> {
|
||||
None
|
||||
}
|
||||
fn document(&self, _: &Path) -> Option<(u64, String)> {
|
||||
None
|
||||
}
|
||||
fn apply_edits(&self, _: &Path, _: u64, _: &[ide_core::TextEdit], _: bool) -> Result<u64, HostError> {
|
||||
Err(HostError::NotFound("not open".into()))
|
||||
}
|
||||
fn trusted(&self, _: &Path) -> bool {
|
||||
true
|
||||
}
|
||||
fn project_of(&self, _: &str) -> Option<PathBuf> {
|
||||
Some(self.root.clone())
|
||||
}
|
||||
fn publish_diagnostics(&self, _: &str, _: &Path, _: Vec<ide_core::Diagnostic>) -> Result<(), HostError> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// The window: what it answers, and the requests it got (`(window, request id)`).
|
||||
#[derive(Default)]
|
||||
struct Window {
|
||||
answer: Option<ClipboardAnswer>,
|
||||
/// Answer from this window instead of the one asked.
|
||||
answer_as: Option<String>,
|
||||
requests: Vec<(Option<String>, String)>,
|
||||
}
|
||||
|
||||
struct Fixture {
|
||||
host: Arc<PluginHost>,
|
||||
window: Arc<Mutex<Window>>,
|
||||
project: PathBuf,
|
||||
_tmp: tempfile::TempDir,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let project = tmp.path().join("project");
|
||||
std::fs::create_dir_all(&project).unwrap();
|
||||
let window = Arc::new(Mutex::new(Window::default()));
|
||||
let host_slot: Arc<Mutex<Option<std::sync::Weak<PluginHost>>>> = Arc::default();
|
||||
let (w, slot) = (window.clone(), host_slot.clone());
|
||||
// Answers on another thread, as the UI does through `plugin_answer_clipboard`.
|
||||
let sink = Arc::new(move |client: Option<&str>, e: PluginEvent| {
|
||||
let PluginEvent::ClipboardRequested { request_id, .. } = e else { return };
|
||||
let (client, w, slot) = (client.map(str::to_owned), w.clone(), slot.clone());
|
||||
std::thread::spawn(move || {
|
||||
let (answer, from) = {
|
||||
let mut w = w.lock();
|
||||
w.requests.push((client.clone(), request_id.clone()));
|
||||
(w.answer.clone(), w.answer_as.clone().or(client).unwrap_or_default())
|
||||
};
|
||||
let host = slot.lock().as_ref().and_then(std::sync::Weak::upgrade).unwrap();
|
||||
if let Some(answer) = answer {
|
||||
host.answer_clipboard(&from, &request_id, answer);
|
||||
}
|
||||
});
|
||||
});
|
||||
let host = Arc::new(PluginHost::new(tmp.path().join("plugins"), sink, Limits::default()).unwrap());
|
||||
*host_slot.lock() = Some(Arc::downgrade(&host));
|
||||
host.set_workspace(Some(Arc::new(Workspace { root: project.clone() })));
|
||||
host.load_all();
|
||||
host.startup_finished();
|
||||
host.install_from_dir(&fixture_dir(), &Consent::all()).unwrap();
|
||||
Self { host, window, project, _tmp: tmp }
|
||||
}
|
||||
|
||||
fn inv(&self) -> Invocation {
|
||||
Invocation { client: Some("main".into()), workspace_root: Some(self.project.clone()), ..Invocation::default() }
|
||||
}
|
||||
|
||||
fn answer(&self, answer: ClipboardAnswer) {
|
||||
self.window.lock().answer = Some(answer);
|
||||
}
|
||||
|
||||
fn read(&self) -> Result<String, String> {
|
||||
self.host.run_command(ID, "read", None, self.inv()).map(Option::unwrap_or_default).map_err(|e| e.message)
|
||||
}
|
||||
|
||||
/// What the last view action or event handler read.
|
||||
fn last(&self) -> String {
|
||||
self.host.run_command(ID, "last", None, self.inv()).unwrap().unwrap_or_default()
|
||||
}
|
||||
|
||||
fn requests(&self) -> usize {
|
||||
self.window.lock().requests.len()
|
||||
}
|
||||
}
|
||||
|
||||
fn content(text: Option<&str>, png: Option<&[u8]>) -> ClipboardAnswer {
|
||||
ClipboardAnswer::Content {
|
||||
text: text.map(str::to_owned),
|
||||
png: png.map(|png| base64::engine::general_purpose::STANDARD.encode(png)),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_command_reads_the_text_and_image_of_its_window() {
|
||||
let f = Fixture::new();
|
||||
f.answer(content(Some("curl https://example.com"), None));
|
||||
assert_eq!(f.read().unwrap(), "text=curl https://example.com image=-");
|
||||
assert_eq!(f.window.lock().requests[0].0.as_deref(), Some("main"), "the invoking window is asked");
|
||||
|
||||
f.answer(content(None, Some(&[0x89, b'P', b'N', b'G', 1, 2])));
|
||||
assert_eq!(f.read().unwrap(), "text=- image=6");
|
||||
f.answer(content(Some("caption"), Some(&[1, 2, 3])));
|
||||
assert_eq!(f.read().unwrap(), "text=caption image=3");
|
||||
// Empty: neither kind, also when the window sends empty strings.
|
||||
f.answer(content(None, None));
|
||||
assert_eq!(f.read().unwrap(), "text=- image=-");
|
||||
f.answer(ClipboardAnswer::Content { text: Some(String::new()), png: Some(String::new()) });
|
||||
assert_eq!(f.read().unwrap(), "text=- image=-");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refusals_failures_and_oversized_content_are_errors() {
|
||||
let f = Fixture::new();
|
||||
f.answer(ClipboardAnswer::Refused);
|
||||
let err = f.read().unwrap_err();
|
||||
assert!(err.contains("clipboard.read (the user refused)"), "{err}");
|
||||
|
||||
f.answer(ClipboardAnswer::Failed { message: "the WebView refused".into() });
|
||||
assert!(f.read().unwrap_err().contains("the WebView refused"));
|
||||
|
||||
let large = vec![0u8; ide_plugin::MAX_CLIPBOARD_BYTES + 1];
|
||||
f.answer(content(None, Some(&large)));
|
||||
assert!(f.read().unwrap_err().contains("16 MiB"));
|
||||
f.answer(content(Some(&"x".repeat(ide_plugin::MAX_CLIPBOARD_BYTES + 1)), None));
|
||||
assert!(f.read().unwrap_err().contains("16 MiB"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reading_needs_its_own_grant() {
|
||||
let f = Fixture::new();
|
||||
f.answer(content(Some("secret"), None));
|
||||
f.host.set_capability(ID, "clipboard.read", false).unwrap();
|
||||
let err = f.read().unwrap_err();
|
||||
assert!(err.contains("clipboard.read"), "{err}");
|
||||
assert_eq!(f.requests(), 0, "the window is not asked");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_calls_the_user_ran_read_it() {
|
||||
let f = Fixture::new();
|
||||
f.answer(content(Some("secret"), None));
|
||||
let denied = |out: &str| out.starts_with("error: ") && out.contains("clipboard.read");
|
||||
|
||||
// A view's button is the user's; a web view message is the page's own.
|
||||
f.host.view_event(ID, "clipboard", ViewEvent::Button { id: "read".into() }, f.inv()).unwrap();
|
||||
assert_eq!(f.last(), "text=secret image=-");
|
||||
assert_eq!(f.requests(), 1);
|
||||
f.host.view_event(ID, "clipboard", ViewEvent::Message { text: "read".into() }, f.inv()).unwrap();
|
||||
let last = f.last();
|
||||
assert!(denied(&last), "{last}");
|
||||
|
||||
// An event handler.
|
||||
let now = Instant::now();
|
||||
let focused = f.project.join("a.txt").to_string_lossy().into_owned();
|
||||
f.host.post_events(Some("main"), vec![WorkbenchEvent::EditorFocused(Some(focused))]);
|
||||
f.host.flush_events_at(now + Duration::from_secs(3));
|
||||
assert!(f.host.wait_events(Duration::from_secs(10)));
|
||||
let last = f.last();
|
||||
assert!(denied(&last), "{last}");
|
||||
|
||||
// A command another plugin ran through `command-runner`, and one with no window.
|
||||
let nested = Invocation { command_chain: vec!["other.plugin".into()], ..f.inv() };
|
||||
assert!(f.host.run_command(ID, "read", None, nested).unwrap_err().message.contains("clipboard.read"));
|
||||
let headless = Invocation { client: None, ..f.inv() };
|
||||
assert!(f.host.run_command(ID, "read", None, headless).unwrap_err().message.contains("clipboard.read"));
|
||||
assert_eq!(f.requests(), 1, "only the view's button asked the window");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_the_asked_window_answers() {
|
||||
let f = Fixture::new();
|
||||
f.window.lock().answer_as = Some("other".into());
|
||||
f.answer(content(Some("other window"), None));
|
||||
let host = f.host.clone();
|
||||
let inv = f.inv();
|
||||
let read = std::thread::spawn(move || host.run_command(ID, "read", None, inv));
|
||||
let started = Instant::now();
|
||||
while f.requests() == 0 {
|
||||
assert!(started.elapsed() < Duration::from_secs(10), "the window was not asked");
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
// The other window's answer was ignored, so the call still waits for `main`.
|
||||
std::thread::sleep(Duration::from_millis(200));
|
||||
assert!(!read.is_finished());
|
||||
let request = f.window.lock().requests[0].1.clone();
|
||||
assert!(f.host.answer_clipboard("main", &request, content(Some("main window"), None)));
|
||||
assert_eq!(read.join().unwrap().unwrap().as_deref(), Some("text=main window image=-"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_capability_needs_api_1_11() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let pkg = tmp.path().join("clipboard");
|
||||
std::fs::create_dir_all(pkg.join("dist")).unwrap();
|
||||
let manifest = std::fs::read_to_string(fixture_dir().join("plugin.toml")).unwrap();
|
||||
std::fs::write(pkg.join("plugin.toml"), manifest.replace("^1.11", "^1.10")).unwrap();
|
||||
std::fs::copy(fixture_dir().join("dist/plugin.wasm"), pkg.join("dist/plugin.wasm")).unwrap();
|
||||
let host =
|
||||
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap();
|
||||
let err = host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
|
||||
assert!(err.message.contains("new in plugin API 1.11"), "{err:?}");
|
||||
}
|
||||
@@ -879,15 +879,16 @@ fn background_tasks_scale_and_renew_cpu_fuel_budget() {
|
||||
// Room for activation (about 3_100 on macOS, more on Windows). A background task gets ten
|
||||
// times it (5 s / 500 ms): enough for each step of `patient` with its CPU work (32_000 to
|
||||
// 80_000), not for the whole run without the refill on each report.
|
||||
let limits = Limits {
|
||||
let f = fixture(Limits {
|
||||
fuel: 40_000,
|
||||
timeout: Duration::from_millis(500),
|
||||
background: Duration::from_millis(5_000),
|
||||
..Limits::default()
|
||||
};
|
||||
let f = fixture(limits);
|
||||
});
|
||||
f.install(&misbehave_pkg());
|
||||
f.host.set_capability("misbehave", "process:git", true).expect("grant Git capability");
|
||||
if f.host.set_capability("misbehave", "process:git", true).is_err() {
|
||||
return;
|
||||
}
|
||||
// Warm up activation in its own call so `patient` starts with a fresh budget.
|
||||
assert_eq!(f.run("misbehave", "echo", Some("warm")).unwrap().as_deref(), Some("warm"));
|
||||
|
||||
@@ -896,13 +897,6 @@ fn background_tasks_scale_and_renew_cpu_fuel_budget() {
|
||||
|
||||
let err = f.run("misbehave", "spin", None).unwrap_err();
|
||||
assert!(err.contains("exceeded its CPU budget (40000 fuel per call)"), "{err}");
|
||||
|
||||
// Beginning a task alone must not renew its scaled budget.
|
||||
let quiet = fixture(limits);
|
||||
quiet.install(&misbehave_pkg());
|
||||
quiet.host.set_capability("misbehave", "process:git", true).expect("grant Git capability");
|
||||
let err = quiet.run("misbehave", "patient", Some("quiet:4000")).unwrap_err();
|
||||
assert!(err.contains("exceeded its CPU budget (400000 fuel per call)"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -5298,7 +5292,6 @@ fn document_changes_reach_plugins_relative_to_the_project() {
|
||||
let deliver = |path: &str| {
|
||||
let change = ide_plugin::DocumentChanged {
|
||||
path: to_ipc(&f.project.join(path)),
|
||||
project: None,
|
||||
base_version: 1,
|
||||
version: 2,
|
||||
changes: Vec::new(),
|
||||
@@ -5312,8 +5305,6 @@ fn document_changes_reach_plugins_relative_to_the_project() {
|
||||
// Queued with the absolute path, filtered again at delivery, handed over project-relative.
|
||||
deliver("config/app.yaml");
|
||||
assert_eq!(f.run("test.path-events", "document", None).unwrap().as_deref(), Some("config/app.yaml"));
|
||||
// With the project it is relative to: another open project may hold the same path.
|
||||
assert_eq!(f.run("test.path-events", "document-project", None).unwrap(), Some(to_ipc(&f.project)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -176,9 +176,7 @@ async fn properties_search_git_and_document_coordinates_agree() {
|
||||
vec![ide_search::ReplaceTarget {
|
||||
path: closed_path.clone().into(),
|
||||
only: Some(vec![ide_core::Pos { line: 0, col: 10 }]),
|
||||
skip: None,
|
||||
}],
|
||||
false,
|
||||
ide_host::ops::Channel::new(|_| {}),
|
||||
)
|
||||
.await
|
||||
|
||||
@@ -1080,35 +1080,3 @@ async fn cancelling_one_request_does_not_interrupt_another_running_command() {
|
||||
assert_eq!(plugins.host().info_of("jobs").unwrap().stats.crashes, 0);
|
||||
plugins.host().shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
||||
async fn a_remote_command_reads_the_clipboard_of_the_desktop_window() {
|
||||
let (_tmp, plugins, peer, client) = command_rpc_fixture().await;
|
||||
plugins.host().install_from_dir(&fixture("clipboard"), &Consent::all()).unwrap();
|
||||
let read = tokio::spawn({
|
||||
let peer = peer.clone();
|
||||
async move {
|
||||
invoke(&peer, "plugin_run_command", json!({ "pluginId": "test.clipboard", "commandId": "read" })).await
|
||||
}
|
||||
});
|
||||
until("the server asks the window for its clipboard", 5, || {
|
||||
client.plugin_events.lock().iter().any(|m| matches!(m.event, PluginEvent::ClipboardRequested { .. }))
|
||||
})
|
||||
.await;
|
||||
let (window, request) = client
|
||||
.plugin_events
|
||||
.lock()
|
||||
.iter()
|
||||
.find_map(|m| match &m.event {
|
||||
PluginEvent::ClipboardRequested { request_id, .. } => Some((m.window.clone(), request_id.clone())),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(window.as_deref(), Some("main"), "the invoking window reads its own clipboard");
|
||||
let answer = json!({ "kind": "content", "text": "from the desktop", "png": null });
|
||||
let answered = invoke(&peer, "plugin_answer_clipboard", json!({ "requestId": request, "answer": answer }));
|
||||
assert_eq!(answered.await.unwrap(), true);
|
||||
let reply = tokio::time::timeout(Duration::from_secs(5), read).await.unwrap().unwrap().unwrap();
|
||||
assert_eq!(reply, "text=from the desktop image=-");
|
||||
plugins.host().shutdown();
|
||||
}
|
||||
@@ -1,197 +0,0 @@
|
||||
//! Replace All when the search hit its match limit (#4083): every match in the
|
||||
//! scope is replaced, not just the listed ones.
|
||||
|
||||
use ide_core::{NullSink, Pos, RequestId};
|
||||
use ide_host::{Host, HostConfig, ops};
|
||||
use ide_search::{ReplaceEvent, ReplaceSummary, ReplaceTarget, SearchQuery};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
fn query(pattern: &str, is_regex: bool) -> SearchQuery {
|
||||
serde_json::from_value(serde_json::json!({"pattern": pattern, "isRegex": is_regex, "caseSensitive": true, "wholeWord": false, "include": [], "exclude": [], "scope": {"kind": "project"}, "maxMatches": 2000})).unwrap()
|
||||
}
|
||||
|
||||
struct Case {
|
||||
name: &'static str,
|
||||
files: Vec<(&'static str, String)>,
|
||||
pattern: &'static str,
|
||||
is_regex: bool,
|
||||
replacement: &'static str,
|
||||
/// `(file, positions)` sent as targets: `skip` with `all_in_scope`, else `only`.
|
||||
targets: Vec<(&'static str, Vec<Pos>)>,
|
||||
all_in_scope: bool,
|
||||
expected: Vec<(&'static str, String)>,
|
||||
replaced: u32,
|
||||
}
|
||||
|
||||
fn lines(n: usize, text: &str) -> String {
|
||||
format!("{text}\n").repeat(n)
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn replace_all_covers_matches_past_the_limit() {
|
||||
let cases = vec![
|
||||
Case {
|
||||
name: "one file, 2001 matches (the report)",
|
||||
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
|
||||
pattern: "CAP_PROBE",
|
||||
is_regex: false,
|
||||
replacement: "CAP_CHANGED",
|
||||
targets: vec![],
|
||||
all_in_scope: true,
|
||||
expected: vec![("repeated.txt", lines(2001, "CAP_CHANGED"))],
|
||||
replaced: 2001,
|
||||
},
|
||||
Case {
|
||||
name: "several files, unlisted ones too",
|
||||
files: vec![("a.txt", lines(1500, "CAP")), ("b.txt", lines(1500, "CAP")), ("sub/c.txt", "x CAP\n".into())],
|
||||
pattern: "CAP",
|
||||
is_regex: false,
|
||||
replacement: "Z",
|
||||
targets: vec![],
|
||||
all_in_scope: true,
|
||||
expected: vec![("a.txt", lines(1500, "Z")), ("b.txt", lines(1500, "Z")), ("sub/c.txt", "x Z\n".into())],
|
||||
replaced: 3001,
|
||||
},
|
||||
Case {
|
||||
name: "excluded usages are kept",
|
||||
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
|
||||
pattern: "CAP_PROBE",
|
||||
is_regex: false,
|
||||
replacement: "CAP_CHANGED",
|
||||
targets: vec![("repeated.txt", vec![Pos::new(0, 0), Pos::new(2000, 0)])],
|
||||
all_in_scope: true,
|
||||
expected: vec![("repeated.txt", format!("CAP_PROBE\n{}CAP_PROBE\n", lines(1999, "CAP_CHANGED")))],
|
||||
replaced: 1999,
|
||||
},
|
||||
Case {
|
||||
name: "regex with groups",
|
||||
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
|
||||
pattern: r"CAP_(\w+)",
|
||||
is_regex: true,
|
||||
replacement: "${1}_CAP",
|
||||
targets: vec![],
|
||||
all_in_scope: true,
|
||||
expected: vec![("repeated.txt", lines(2001, "PROBE_CAP"))],
|
||||
replaced: 2001,
|
||||
},
|
||||
Case {
|
||||
name: "Replace Selected keeps to the selected usages",
|
||||
files: vec![("repeated.txt", lines(3, "CAP_PROBE"))],
|
||||
pattern: "CAP_PROBE",
|
||||
is_regex: false,
|
||||
replacement: "CAP_CHANGED",
|
||||
targets: vec![("repeated.txt", vec![Pos::new(1, 0)])],
|
||||
all_in_scope: false,
|
||||
expected: vec![("repeated.txt", "CAP_PROBE\nCAP_CHANGED\nCAP_PROBE\n".into())],
|
||||
replaced: 1,
|
||||
},
|
||||
];
|
||||
for case in cases {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
for (path, text) in &case.files {
|
||||
let path = root.join(path);
|
||||
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
std::fs::write(path, text).unwrap();
|
||||
}
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&root, true, false).unwrap();
|
||||
host.open_project("main", &root).unwrap();
|
||||
let targets = case
|
||||
.targets
|
||||
.iter()
|
||||
.map(|(path, at)| {
|
||||
let path = root.join(path).into();
|
||||
if case.all_in_scope {
|
||||
ReplaceTarget { path, only: None, skip: Some(at.clone()) }
|
||||
} else {
|
||||
ReplaceTarget { path, only: Some(at.clone()), skip: None }
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
let summary = Arc::new(Mutex::new(ReplaceSummary::default()));
|
||||
let out = summary.clone();
|
||||
ops::search::replace_in_files(
|
||||
&host,
|
||||
"main",
|
||||
RequestId::next(),
|
||||
query(case.pattern, case.is_regex),
|
||||
case.replacement.into(),
|
||||
false,
|
||||
targets,
|
||||
case.all_in_scope,
|
||||
ops::Channel::new(move |e| {
|
||||
if let ReplaceEvent::Done { summary } = e {
|
||||
*out.lock().unwrap() = summary;
|
||||
}
|
||||
}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
for (path, text) in &case.expected {
|
||||
assert_eq!(&std::fs::read_to_string(root.join(path)).unwrap(), text, "{}: {path}", case.name);
|
||||
}
|
||||
assert_eq!(summary.lock().unwrap().replacements, case.replaced, "{}", case.name);
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
/// #4202: a file the search preview holds open (no unsaved changes) is saved like a closed
|
||||
/// one; a buffer with unsaved edits is replaced in place and left for the editor to save.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn replace_all_saves_open_buffers_without_unsaved_changes() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
for name in ["previewed.txt", "edited.txt", "closed.txt"] {
|
||||
std::fs::write(root.join(name), "TOKEN\n").unwrap();
|
||||
}
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&root, true, false).unwrap();
|
||||
host.open_project("main", &root).unwrap();
|
||||
let project = host.project("main").unwrap();
|
||||
project.documents.open(&root.join("previewed.txt")).unwrap();
|
||||
let edited = project.documents.open(&root.join("edited.txt")).unwrap().id;
|
||||
project.documents.replace_all(edited, "TOKEN\nmore\n").unwrap();
|
||||
ops::search::replace_in_files(
|
||||
&host,
|
||||
"main",
|
||||
RequestId::next(),
|
||||
query("TOKEN", false),
|
||||
"DONE".into(),
|
||||
false,
|
||||
vec![],
|
||||
true,
|
||||
ops::Channel::new(|_| {}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let disk = |name: &str| std::fs::read_to_string(root.join(name)).unwrap();
|
||||
assert_eq!(disk("previewed.txt"), "DONE\n");
|
||||
assert_eq!(disk("closed.txt"), "DONE\n");
|
||||
assert_eq!(disk("edited.txt"), "TOKEN\n", "unsaved edits stay unsaved");
|
||||
assert_eq!(project.documents.text_snapshot(edited).unwrap().text, "DONE\nmore\n");
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -45,9 +45,6 @@ async fn a_commands_trust_class_decides_where_it_runs() {
|
||||
assert_eq!(allowed("main", class), in_restricted, "{class:?} in Restricted Mode");
|
||||
assert_eq!(allowed("welcome", class), without_project, "{class:?} without a project");
|
||||
}
|
||||
// Toolchain detection runs from Settings opened on the Welcome screen, but not in Restricted Mode.
|
||||
assert!(ide_host::ops::sdk::sdk_detect(&host, "welcome", ide_sdk::SdkKind::Zig).await.is_ok());
|
||||
assert!(ide_host::ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Zig).await.is_err());
|
||||
// These requests validate the vendor before any network access, independently of project trust.
|
||||
let error = ide_host::ops::tools::jdk_download_releases(&host, "unknown-vendor".into(), ide_core::RequestId(901))
|
||||
.await
|
||||
|
||||
@@ -406,14 +406,13 @@ impl Peer {
|
||||
// would (`PATH` × `PATHEXT`, e.g. `codex` → `codex.cmd`) first.
|
||||
let resolved = resolve_spawn_program(command, env);
|
||||
let mut cmd = tokio::process::Command::new(&resolved);
|
||||
// The working directory first: it picks the project's environment.
|
||||
cmd.current_dir(cwd);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
// Wrappers (`npx`, `codex.cmd`, launcher scripts) start the real server as a child:
|
||||
// stopping the connection stops the whole tree.
|
||||
ide_core::process::own_group(cmd.as_std_mut());
|
||||
cmd.args(args)
|
||||
.envs(ide_core::process::shell_env_in(cwd))
|
||||
.current_dir(cwd)
|
||||
.envs(ide_core::process::shell_env())
|
||||
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
|
||||
@@ -6,7 +6,6 @@ edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
dunce.workspace = true
|
||||
ide-core.workspace = true
|
||||
ide-extension.workspace = true
|
||||
ide-text.workspace = true
|
||||
|
||||
@@ -18,7 +18,7 @@ mod markers;
|
||||
pub mod plugin_point;
|
||||
mod registry;
|
||||
mod syntax;
|
||||
pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root, project_spelling};
|
||||
pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root};
|
||||
pub use plugin_point::PluginLanguages;
|
||||
pub use registry::{FileTypes, LanguageRegistry};
|
||||
pub use syntax::{
|
||||
@@ -28,7 +28,7 @@ pub use syntax::{
|
||||
VueComponentImport, VueRefAccess, VueRefElement, WebReference, WebReferenceKind, merge_visibility,
|
||||
set_external_syntax, shift_pos, shift_range,
|
||||
};
|
||||
pub use syntax::{MethodBody, PhpAlignment, PythonClassFacts, PythonFacts, PythonMethodFacts};
|
||||
pub use syntax::{MethodBody, PythonClassFacts, PythonFacts, PythonMethodFacts};
|
||||
|
||||
/// Parsed form of `languages/<id>.toml`. Backend-only; the UI gets [`LanguageInfo`].
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
|
||||
@@ -2,23 +2,8 @@
|
||||
//! framework's project there (`Cargo.toml`, `angular.json`). Language server
|
||||
//! roots (`root-markers`) and framework modes (`framework-ui-modes`) share them.
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// `path` as the project's roots spell it, `inside` telling whether a path is
|
||||
/// under one. Roots are canonical, while a file can arrive under another
|
||||
/// spelling (other letter case on macOS, a symlinked folder) and would look
|
||||
/// outside the project, missing its frameworks' markers.
|
||||
pub fn project_spelling<'a>(path: &'a Path, inside: impl Fn(&Path) -> bool) -> Cow<'a, Path> {
|
||||
if inside(path) {
|
||||
return path.into();
|
||||
}
|
||||
match dunce::canonicalize(path) {
|
||||
Ok(canonical) if inside(&canonical) => canonical.into(),
|
||||
_ => path.into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// The outermost ancestor of `file` containing a root marker, within
|
||||
/// `project_root` (any ancestor without one: loose files). A directory counts
|
||||
/// as its own ancestor: a module folder is served like the files in it.
|
||||
|
||||
@@ -371,7 +371,6 @@ impl LanguageRegistry {
|
||||
pub fn framework_ui_mode(&self, language: &LanguageId, path: &Path, project_root: Option<&Path>) -> Option<String> {
|
||||
let state = self.state();
|
||||
let cfg = state.languages.iter().find(|l| &l.id == language)?;
|
||||
let path = &*crate::project_spelling(path, |p| project_root.is_none_or(|root| p.starts_with(root)));
|
||||
cfg.framework_ui_modes
|
||||
.iter()
|
||||
.find(|f| crate::marked_root(project_root, path, &f.root_markers).is_some())
|
||||
@@ -929,38 +928,6 @@ mod tests {
|
||||
assert_eq!(detect("pages/promo.html"), "html");
|
||||
}
|
||||
|
||||
/// #4061: the project root is canonical; a template reached under another
|
||||
/// spelling of it is still the project's.
|
||||
#[test]
|
||||
fn templates_spelt_differently_from_the_project_use_framework_modes() {
|
||||
let reg = reg();
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap().join("Develop/shop");
|
||||
std::fs::create_dir_all(root.join("node_modules/@angular/core")).unwrap();
|
||||
let template = root.join("apps/myapp/src/app/example.component.html");
|
||||
std::fs::create_dir_all(template.parent().unwrap()).unwrap();
|
||||
std::fs::write(&template, "<button (click)=\"onConfirm()\">Confirm</button>\n").unwrap();
|
||||
let mode = |path: &Path| reg.framework_ui_mode(&LanguageId::new("html"), path, Some(&root));
|
||||
let links = tempfile::tempdir().unwrap();
|
||||
let mut spellings = Vec::new();
|
||||
#[cfg(unix)]
|
||||
{
|
||||
std::os::unix::fs::symlink(&root, links.path().join("shop")).unwrap();
|
||||
spellings.push(links.path().join("shop").join(template.strip_prefix(&root).unwrap()));
|
||||
}
|
||||
// Only on a case-insensitive disk (macOS, Windows): `develop` for `Develop`.
|
||||
let lower = PathBuf::from(template.to_string_lossy().replace("Develop", "develop"));
|
||||
if lower.exists() {
|
||||
spellings.push(lower);
|
||||
}
|
||||
for path in &spellings {
|
||||
assert_eq!(mode(path).as_deref(), Some("Angular Template"), "{}", path.display());
|
||||
}
|
||||
// Still nothing for files that are elsewhere under every spelling.
|
||||
std::fs::create_dir_all(links.path().join("other")).unwrap();
|
||||
assert_eq!(mode(&links.path().join("other/index.html")), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn markers_outside_the_project_do_not_make_angular_templates() {
|
||||
let reg = reg();
|
||||
|
||||
@@ -6,8 +6,8 @@
|
||||
//! parse instead of a full one.
|
||||
|
||||
use super::{
|
||||
Grammar, MAX_PARSE_BYTES, ParsedTree, Syntax, SyntaxHighlights, TreeError, highlight, outline, parse_cancellable,
|
||||
selection,
|
||||
Grammar, MAX_PARSE_BYTES, ParsedTree, Syntax, SyntaxHighlights, TreeError, folding, highlight, outline,
|
||||
parse_cancellable, selection,
|
||||
};
|
||||
use crate::FoldRange;
|
||||
use ide_core::{DocId, LanguageId, OutlineItem, Range};
|
||||
@@ -219,10 +219,9 @@ impl SyntaxCache {
|
||||
|m| &mut m.folding,
|
||||
|| {
|
||||
self.with_tree(doc, lang, version, text, |g, tree, text| {
|
||||
Some(self.syntax.folding_with_scripts(g, tree, text, lang))
|
||||
Some(folding::folding(g.spec, g.kinds(), tree, text, self.syntax.comment_tokens(lang)))
|
||||
})
|
||||
.or_else(|| super::external::folding(lang, text))
|
||||
.or_else(|| self.syntax.web_folding(lang, text))
|
||||
.or_else(|| Some(self.syntax.custom_folding(lang, text)))
|
||||
},
|
||||
)
|
||||
|
||||
@@ -118,16 +118,6 @@ pub(super) fn folding(
|
||||
});
|
||||
return true;
|
||||
}
|
||||
// Some languages write documentation as a string-like node rather than a
|
||||
// lexical comment (Python docstrings, Elixir `@doc` / `@moduledoc`). The
|
||||
// generic comment pass above never sees those, so fold them as documentation.
|
||||
if node.is_named()
|
||||
&& start != end
|
||||
&& let Some(fold) = docstring_fold(spec, &node, kinds, text)
|
||||
{
|
||||
out.push(fold);
|
||||
return false;
|
||||
}
|
||||
if start != end && !spec.imports.is_empty() && node.named_child_count() > 1 {
|
||||
import_runs(kinds, node, text, &mut out);
|
||||
}
|
||||
@@ -216,64 +206,6 @@ pub(crate) fn is_comment(kind: &str) -> bool {
|
||||
kind.contains("comment") || kind == "Comment"
|
||||
}
|
||||
|
||||
/// Folds a documentation string written as a non-comment node. Returns `None`
|
||||
/// for every other node; the caller skips its subtree only on a match.
|
||||
fn docstring_fold(spec: &Spec, node: &Node, kinds: &KindTable, text: &str) -> Option<FoldRange> {
|
||||
let multi_line = |n: &Node| n.start_position().row != n.end_position().row && kinds.has(n, FOLD_NODE);
|
||||
let range = |n: &Node| FoldRange {
|
||||
start_line: n.start_position().row as u32,
|
||||
end_line: last_content_row(n, text) as u32,
|
||||
kind: FoldKind::Comment,
|
||||
};
|
||||
match spec.name {
|
||||
// A bare string as the first statement of a module/class/function body.
|
||||
"python" if node.kind() == "expression_statement" => {
|
||||
let string = node.named_child(0)?;
|
||||
if string.kind() != "string" || !multi_line(&string) {
|
||||
return None;
|
||||
}
|
||||
let parent = node.parent()?;
|
||||
let mut cursor = parent.walk();
|
||||
if parent.named_children(&mut cursor).find(|c| !kinds.has(c, COMMENT)) != Some(*node) {
|
||||
return None;
|
||||
}
|
||||
Some(range(node))
|
||||
}
|
||||
// `@doc """…"""` / `@moduledoc """…"""`: an @-prefixed call whose
|
||||
// argument is a multi-line string (or a sigil like `~S"""`).
|
||||
"elixir" if node.kind() == "unary_operator" => {
|
||||
let operand = node.child_by_field_name("operand")?;
|
||||
if operand.kind() != "call" || !is_elixir_doc_attr(operand, text) {
|
||||
return None;
|
||||
}
|
||||
// The string is the argument of the attribute call: `@doc """…"""`
|
||||
// parses as unary_operator -> call(target: doc) -> arguments -> string.
|
||||
let mut cursor = operand.walk();
|
||||
let doc_string =
|
||||
operand.named_children(&mut cursor).find(|c| c.kind() == "arguments").and_then(|args| {
|
||||
let mut args_cursor = args.walk();
|
||||
args.named_children(&mut args_cursor).find(|c| multi_line(c))
|
||||
})?;
|
||||
if !matches!(doc_string.kind(), "string" | "sigil") {
|
||||
return None;
|
||||
}
|
||||
Some(range(&doc_string))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether an Elixir `call` is `@doc` / `@moduledoc` / `@typedoc` (the documented
|
||||
/// attributes that take a string argument).
|
||||
fn is_elixir_doc_attr(call: Node, text: &str) -> bool {
|
||||
let Some(target) = call.child_by_field_name("target") else { return false };
|
||||
let name = text.get(target.byte_range()).unwrap_or_default();
|
||||
if target.kind() != "identifier" {
|
||||
return false;
|
||||
}
|
||||
matches!(name, "doc" | "moduledoc" | "typedoc")
|
||||
}
|
||||
|
||||
/// Row of the closing token when `node` is delimited by a matching bracket pair.
|
||||
pub(crate) fn bracket_pair<'t>(node: &Node<'t>) -> Option<(Node<'t>, Node<'t>)> {
|
||||
let count = node.child_count();
|
||||
|
||||
@@ -10,7 +10,6 @@ mod inheritance;
|
||||
pub(crate) mod lines;
|
||||
mod literals;
|
||||
mod outline;
|
||||
mod php_align;
|
||||
mod python_facts;
|
||||
mod rst;
|
||||
mod selection;
|
||||
@@ -29,7 +28,6 @@ pub use inheritance::ClassBases;
|
||||
pub use lines::{shift_pos, shift_range};
|
||||
pub use literals::{Literal, LiteralKind, SpellingKind, SpellingRegion};
|
||||
pub use outline::merge_visibility;
|
||||
pub use php_align::PhpAlignment;
|
||||
pub use python_facts::{MethodBody, PythonClassFacts, PythonFacts, PythonMethodFacts};
|
||||
use std::cell::RefCell;
|
||||
use std::collections::HashMap;
|
||||
@@ -192,38 +190,11 @@ impl Syntax {
|
||||
}
|
||||
|
||||
pub fn folding(&self, lang: &LanguageId, text: &str) -> Vec<FoldRange> {
|
||||
self.web_folding(lang, text)
|
||||
.or_else(|| self.analyze(lang, text, |g, tree, text| Some(self.folding_with_scripts(g, tree, text, lang))))
|
||||
let tokens = self.comment_tokens(lang);
|
||||
self.analyze(lang, text, |g, tree, text| Some(folding::folding(g.spec, g.kinds(), tree, text, tokens)))
|
||||
.unwrap_or_else(|| self.custom_folding(lang, text))
|
||||
}
|
||||
|
||||
pub(crate) fn web_folding(&self, lang: &LanguageId, text: &str) -> Option<Vec<FoldRange>> {
|
||||
let g = self.web_grammar(lang)?;
|
||||
if g.spec.name != "html" || text.len() > MAX_PARSE_BYTES {
|
||||
return None;
|
||||
}
|
||||
let tree = parse(&g.language, text, None)?;
|
||||
Some(self.folding_with_scripts(g, &tree, text, lang))
|
||||
}
|
||||
|
||||
fn folding_with_scripts(&self, g: &Grammar, tree: &Tree, text: &str, lang: &LanguageId) -> Vec<FoldRange> {
|
||||
let mut folds = folding::folding(g.spec, g.kinds(), tree, text, self.comment_tokens(lang));
|
||||
if g.spec.name == "html" {
|
||||
let lines = lines::LineIndex::new(text);
|
||||
for region in sfc::script_regions(tree, text) {
|
||||
let base_line = lines.line_of(region.base) as u32;
|
||||
folds.extend(self.folding(®ion.language, ®ion.text).into_iter().map(|mut fold| {
|
||||
fold.start_line += base_line;
|
||||
fold.end_line += base_line;
|
||||
fold
|
||||
}));
|
||||
}
|
||||
folds.sort_by(|a, b| a.start_line.cmp(&b.start_line).then(b.end_line.cmp(&a.end_line)));
|
||||
folds.dedup_by_key(|f| f.start_line);
|
||||
}
|
||||
folds
|
||||
}
|
||||
|
||||
fn comment_tokens(&self, lang: &LanguageId) -> &folding::CommentTokens {
|
||||
static EMPTY: OnceLock<folding::CommentTokens> = OnceLock::new();
|
||||
self.comments.get(lang.as_str()).unwrap_or_else(|| EMPTY.get_or_init(Default::default))
|
||||
|
||||
@@ -1,368 +0,0 @@
|
||||
//! PHP Code Style › Align key-value pairs and Align consecutive assignments (PhpStorm's
|
||||
//! options of the same names), applied to text a formatter has already formatted.
|
||||
//!
|
||||
//! A block is a run of array elements, or of assignment statements, on consecutive lines of
|
||||
//! the same array or statement list, one per line and each on a single line. A blank line,
|
||||
//! a comment line, another statement or element, or one spanning several lines ends it.
|
||||
//! Within a block the operators line up one space after the longest left-hand side; nested
|
||||
//! arrays form blocks of their own. Only the whitespace before an operator token of the
|
||||
//! syntax tree changes, so `=>` and `=` inside strings and comments are never touched.
|
||||
|
||||
use crate::{LanguageId, Syntax};
|
||||
use tree_sitter::{Node, Tree};
|
||||
|
||||
/// Which alignments to apply.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub struct PhpAlignment {
|
||||
/// `=>` of the elements of multi-line arrays.
|
||||
pub key_value_pairs: bool,
|
||||
/// `=` of consecutive assignment statements.
|
||||
pub assignments: bool,
|
||||
}
|
||||
|
||||
impl PhpAlignment {
|
||||
pub fn any(self) -> bool {
|
||||
self.key_value_pairs || self.assignments
|
||||
}
|
||||
}
|
||||
|
||||
impl Syntax {
|
||||
/// `text` with its PHP alignment applied, changing only lines `lines` (0-based, inclusive;
|
||||
/// `None`: all). A block reaching outside them still aligns with its lines there.
|
||||
/// `None` when nothing changes or `lang` is not parsed with the PHP grammar.
|
||||
pub fn align_php(
|
||||
&self,
|
||||
lang: &LanguageId,
|
||||
text: &str,
|
||||
lines: Option<(usize, usize)>,
|
||||
options: PhpAlignment,
|
||||
) -> Option<String> {
|
||||
if !options.any() {
|
||||
return None;
|
||||
}
|
||||
self.analyze(lang, text, |g, tree, text| (g.spec.name == "php").then(|| align(tree, text, lines, options)))
|
||||
.flatten()
|
||||
}
|
||||
}
|
||||
|
||||
/// One line's operator: the whitespace `gap` before it and the width of the line up to it.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
struct Entry {
|
||||
line: usize,
|
||||
gap: (usize, usize),
|
||||
/// Characters from the start of the line to the end of the left-hand side.
|
||||
width: usize,
|
||||
}
|
||||
|
||||
fn align(tree: &Tree, text: &str, lines: Option<(usize, usize)>, options: PhpAlignment) -> Option<String> {
|
||||
let mut gaps: Vec<(usize, usize, usize)> = Vec::new();
|
||||
let mut cursor = tree.walk();
|
||||
visit(&mut cursor, &mut |node| {
|
||||
// Error recovery can read string content as code, where whitespace matters.
|
||||
if node.is_error() {
|
||||
return;
|
||||
}
|
||||
let entries = match node.kind() {
|
||||
"array_creation_expression" if options.key_value_pairs => run(node, text, key_value),
|
||||
_ if options.assignments => run(node, text, assignment),
|
||||
_ => return,
|
||||
};
|
||||
for block in blocks(&entries) {
|
||||
let column = block.iter().map(|e| e.width).max().unwrap_or(0) + 1;
|
||||
for e in block {
|
||||
if lines.is_none_or(|(first, last)| (first..=last).contains(&e.line)) {
|
||||
gaps.push((e.gap.0, e.gap.1, column - e.width));
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
gaps.sort_unstable();
|
||||
let mut out = String::with_capacity(text.len());
|
||||
let mut at = 0;
|
||||
let mut changed = false;
|
||||
for (from, to, spaces) in gaps {
|
||||
if text[from..to].len() == spaces && text[from..to].bytes().all(|b| b == b' ') {
|
||||
continue;
|
||||
}
|
||||
out.push_str(&text[at..from]);
|
||||
out.extend(std::iter::repeat_n(' ', spaces));
|
||||
at = to;
|
||||
changed = true;
|
||||
}
|
||||
if !changed {
|
||||
return None;
|
||||
}
|
||||
out.push_str(&text[at..]);
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// The named children of `parent` as alignment candidates in order: `None` breaks a block.
|
||||
/// A comment ending the line of the child before it (`'a' => 1, // why`) is skipped; two
|
||||
/// children sharing a line are both left alone.
|
||||
fn run(parent: Node, text: &str, entry: fn(Node, &str) -> Option<Entry>) -> Vec<Option<Entry>> {
|
||||
let mut out: Vec<Option<Entry>> = Vec::new();
|
||||
let mut previous_end: Option<usize> = None;
|
||||
let mut cursor = parent.walk();
|
||||
for child in parent.named_children(&mut cursor) {
|
||||
let start = child.start_position().row;
|
||||
let shares_line = previous_end == Some(start);
|
||||
if child.kind() == "comment" && shares_line {
|
||||
continue;
|
||||
}
|
||||
if shares_line && let Some(last) = out.last_mut() {
|
||||
*last = None;
|
||||
}
|
||||
out.push(if shares_line { None } else { entry(child, text) });
|
||||
previous_end = Some(child.end_position().row);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Runs of entries on consecutive lines.
|
||||
fn blocks(entries: &[Option<Entry>]) -> Vec<Vec<Entry>> {
|
||||
let mut out: Vec<Vec<Entry>> = Vec::new();
|
||||
let mut current: Vec<Entry> = Vec::new();
|
||||
for entry in entries {
|
||||
match entry {
|
||||
Some(e) if current.last().is_none_or(|last| last.line + 1 == e.line) => current.push(*e),
|
||||
Some(e) => out.push(std::mem::replace(&mut current, vec![*e])),
|
||||
None if current.is_empty() => {}
|
||||
None => out.push(std::mem::take(&mut current)),
|
||||
}
|
||||
}
|
||||
if !current.is_empty() {
|
||||
out.push(current);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// `'key' => value` alone on one line.
|
||||
fn key_value(element: Node, text: &str) -> Option<Entry> {
|
||||
if element.kind() != "array_element_initializer" {
|
||||
return None;
|
||||
}
|
||||
let mut cursor = element.walk();
|
||||
let arrow = element.children(&mut cursor).find(|c| c.kind() == "=>")?;
|
||||
let key = arrow.prev_sibling()?;
|
||||
entry(element, key, arrow, text)
|
||||
}
|
||||
|
||||
/// `$left = value;` (or `= &value`) alone on one line.
|
||||
fn assignment(statement: Node, text: &str) -> Option<Entry> {
|
||||
if statement.kind() != "expression_statement" {
|
||||
return None;
|
||||
}
|
||||
let expression = statement.named_child(0)?;
|
||||
if !matches!(expression.kind(), "assignment_expression" | "reference_assignment_expression") {
|
||||
return None;
|
||||
}
|
||||
let left = expression.child_by_field_name("left")?;
|
||||
let mut cursor = expression.walk();
|
||||
let operator = expression.children(&mut cursor).find(|c| c.kind() == "=")?;
|
||||
entry(statement, left, operator, text)
|
||||
}
|
||||
|
||||
fn entry(whole: Node, left: Node, operator: Node, text: &str) -> Option<Entry> {
|
||||
let line = whole.start_position().row;
|
||||
if whole.has_error() || whole.end_position().row != line {
|
||||
return None;
|
||||
}
|
||||
let line_start = whole.start_byte() - whole.start_position().column;
|
||||
let starts_line = text[line_start..whole.start_byte()].bytes().all(|b| b == b' ' || b == b'\t');
|
||||
let gap = (left.end_byte(), operator.start_byte());
|
||||
let blank_gap = text[gap.0..gap.1].bytes().all(|b| b == b' ' || b == b'\t');
|
||||
(starts_line && blank_gap).then(|| Entry { line, gap, width: text[line_start..gap.0].chars().count() })
|
||||
}
|
||||
|
||||
fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) {
|
||||
loop {
|
||||
f(cursor.node());
|
||||
if cursor.goto_first_child() {
|
||||
continue;
|
||||
}
|
||||
loop {
|
||||
if cursor.goto_next_sibling() {
|
||||
break;
|
||||
}
|
||||
if !cursor.goto_parent() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
const BOTH: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
|
||||
const PAIRS: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: false };
|
||||
const ASSIGNMENTS: PhpAlignment = PhpAlignment { key_value_pairs: false, assignments: true };
|
||||
|
||||
fn syntax() -> &'static Syntax {
|
||||
static S: OnceLock<Syntax> = OnceLock::new();
|
||||
S.get_or_init(Syntax::new)
|
||||
}
|
||||
|
||||
fn aligned(text: &str, lines: Option<(usize, usize)>, options: PhpAlignment) -> String {
|
||||
let out = syntax().align_php(&LanguageId::new("php"), text, lines, options);
|
||||
let result = out.clone().unwrap_or_else(|| text.to_owned());
|
||||
let strip = |s: &str| s.chars().filter(|c| !c.is_whitespace()).collect::<String>();
|
||||
assert_eq!(strip(&result), strip(text), "only whitespace changes");
|
||||
assert_eq!(
|
||||
syntax().align_php(&LanguageId::new("php"), &result, lines, options),
|
||||
None,
|
||||
"aligning again changes nothing:\n{result}"
|
||||
);
|
||||
result
|
||||
}
|
||||
|
||||
fn check(options: PhpAlignment, before: &str, after: &str) {
|
||||
assert_eq!(aligned(before, None, options), after);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aligns_the_arrows_of_a_multi_line_array() {
|
||||
check(
|
||||
PAIRS,
|
||||
"<?php\nreturn [\n 'name' => 'demo',\n 'description' => 'x',\n 'id' => 1,\n];\n",
|
||||
"<?php\nreturn [\n 'name' => 'demo',\n 'description' => 'x',\n 'id' => 1,\n];\n",
|
||||
);
|
||||
check(
|
||||
PAIRS,
|
||||
"<?php\n$a = array(\n 1 => 'a',\n 1234 => 'b',\n);\n",
|
||||
"<?php\n$a = array(\n 1 => 'a',\n 1234 => 'b',\n);\n",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nested_arrays_align_per_level_and_a_multi_line_value_ends_a_block() {
|
||||
check(
|
||||
PAIRS,
|
||||
"<?php\n$config = [\n 'a' => 1,\n 'bbb' => 2,\n 'nested' => [\n 'x' => 1,\n 'yyyy' => 2,\n ],\n 'c' => 3,\n 'dd' => 4,\n];\n",
|
||||
"<?php\n$config = [\n 'a' => 1,\n 'bbb' => 2,\n 'nested' => [\n 'x' => 1,\n 'yyyy' => 2,\n ],\n 'c' => 3,\n 'dd' => 4,\n];\n",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blank_lines_comment_lines_and_elements_without_a_key_end_a_block() {
|
||||
check(
|
||||
PAIRS,
|
||||
"<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n\n 'ccc' => 3,\n // section\n 'dddd' => 4,\n 'e' => 5,\n 6,\n 'ff' => 7,\n];\n",
|
||||
"<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n\n 'ccc' => 3,\n // section\n 'dddd' => 4,\n 'e' => 5,\n 6,\n 'ff' => 7,\n];\n",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_comment_at_the_end_of_a_line_keeps_the_block() {
|
||||
check(
|
||||
PAIRS,
|
||||
"<?php\n$a = [\n 'a' => 1, // first\n 'bb' => 2, /* second */\n 'ccc' => 3,\n];\n",
|
||||
"<?php\n$a = [\n 'a' => 1, // first\n 'bb' => 2, /* second */\n 'ccc' => 3,\n];\n",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_line_arrays_and_elements_sharing_a_line_stay_as_they_are() {
|
||||
for text in [
|
||||
"<?php\n$a = ['a' => 1, 'bbb' => 2];\n",
|
||||
"<?php\n$a = [\n 'a' => 1, 'bbb' => 2,\n 'cc' => 3,\n];\n",
|
||||
"<?php\n$a = ['a' => 1,\n 'bbb' => 2];\n",
|
||||
] {
|
||||
assert_eq!(aligned(text, None, BOTH), text);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrows_and_equals_signs_outside_arrays_and_assignments_are_not_touched() {
|
||||
let text = "<?php\n\
|
||||
$s = 'a => b';\n\
|
||||
$t = \"x = y\";\n\
|
||||
// 'k' => 1, $v = 2\n\
|
||||
/* 'kk' => 1 */\n\
|
||||
foreach ($items as $key => $value) {}\n\
|
||||
$f = fn($x) => $x;\n\
|
||||
$m = match ($x) {\n 1 => 'a',\n 100 => 'b',\n};\n\
|
||||
for ($i = 0; $i < 3; $i++) {}\n\
|
||||
function g($a = 1, $bbb = 2) {}\n\
|
||||
g(a: 1, bbb: 2);\n\
|
||||
$h = <<<EOT\n 'a' => 1,\n 'bbb' => 2,\nEOT;\n";
|
||||
let out = aligned(text, None, PAIRS);
|
||||
assert_eq!(out, text);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aligns_consecutive_assignments() {
|
||||
check(
|
||||
ASSIGNMENTS,
|
||||
"<?php\n$y = foo($x);\n$i = foo($i);\n$result = $result . $y . $i;\n$this->name = 'n';\n$ref = &$y;\n",
|
||||
"<?php\n$y = foo($x);\n$i = foo($i);\n$result = $result . $y . $i;\n$this->name = 'n';\n$ref = &$y;\n",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn other_statements_blank_lines_and_multi_line_assignments_end_a_block() {
|
||||
check(
|
||||
ASSIGNMENTS,
|
||||
"<?php\nfunction f() {\n $a = 1;\n $bb = 2;\n echo $a;\n $ccc = 3;\n $d = 4;\n\n $eeeee = 5;\n $f = 6;\n $g .= 'x';\n $hh = 7;\n $i = [\n 1,\n ];\n $jjj = 8;\n $k = 9;\n}\n",
|
||||
"<?php\nfunction f() {\n $a = 1;\n $bb = 2;\n echo $a;\n $ccc = 3;\n $d = 4;\n\n $eeeee = 5;\n $f = 6;\n $g .= 'x';\n $hh = 7;\n $i = [\n 1,\n ];\n $jjj = 8;\n $k = 9;\n}\n",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn assignments_sharing_a_line_and_declarations_stay_as_they_are() {
|
||||
let text = "<?php\n$a = 1; $bbb = 2;\n$cc = 3;\nclass C {\n public $x = 1;\n public $yyy = 2;\n const A = 1;\n const BBB = 2;\n}\n";
|
||||
assert_eq!(aligned(text, None, ASSIGNMENTS), text);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn each_option_aligns_only_its_operator() {
|
||||
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n$x = 1;\n$yyy = 2;\n";
|
||||
assert_eq!(
|
||||
aligned(text, None, PAIRS),
|
||||
"<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n$x = 1;\n$yyy = 2;\n"
|
||||
);
|
||||
assert_eq!(
|
||||
aligned(text, None, ASSIGNMENTS),
|
||||
"<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n$x = 1;\n$yyy = 2;\n"
|
||||
);
|
||||
assert_eq!(syntax().align_php(&LanguageId::new("php"), text, None, PhpAlignment::default()), None);
|
||||
assert_eq!(syntax().align_php(&LanguageId::new("javascript"), "a = {\n b: 1,\n};\n", None, BOTH), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_the_given_lines_change_and_they_align_with_the_whole_block() {
|
||||
let text = "<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n 'cccc' => 3,\n];\n";
|
||||
assert_eq!(
|
||||
aligned(text, Some((2, 3)), PAIRS),
|
||||
"<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n 'cccc' => 3,\n];\n"
|
||||
);
|
||||
assert_eq!(aligned(text, Some((5, 5)), PAIRS), text);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn widths_count_characters_not_bytes() {
|
||||
check(
|
||||
PAIRS,
|
||||
"<?php\n$a = [\n '名前' => 1,\n 'name' => 2,\n];\n",
|
||||
"<?php\n$a = [\n '名前' => 1,\n 'name' => 2,\n];\n",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn code_with_syntax_errors_is_aligned_only_where_it_parses() {
|
||||
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => ,\n 'cc' => 3,\n];\n";
|
||||
let out = aligned(text, None, PAIRS);
|
||||
assert!(out.contains("'bbb' => ,"), "{out}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn php_inside_html() {
|
||||
check(
|
||||
BOTH,
|
||||
"<html>\n<?php\n$a = 1;\n$bbb = 2;\n?>\n<p>x = y</p>\n",
|
||||
"<html>\n<?php\n$a = 1;\n$bbb = 2;\n?>\n<p>x = y</p>\n",
|
||||
);
|
||||
}
|
||||
}
|
||||
Loaded 100 of 795 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача