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

..
Автор SHA1 Повідомлення Дата
l0ng-ai b3dc32c5ec fix(plugins): deliver document-changed events to plugins
The event queue relativized every path event at enqueue time, which turned a
document-changed path into a project-relative one before the delivery filter
ran; the filter then looked up a relative path, found no project for it and
dropped the event, so subscribed plugins never saw edits.

The queue now keeps document paths absolute through filtering and relativizes
them to the file's own project when handing events to the plugin. The
path-events test fixture subscribes document-changed to cover the flow.

Fixes #4008
2026-11-17 23:13:29 +08:00
795 змінених файлів з 6687 додано та 31905 видалено

No files matched your search

+15 -65
Переглянути файл
@@ -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:
+1 -67
Переглянути файл
@@ -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
-1
Переглянути файл
@@ -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"
-30
Переглянути файл
@@ -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`
-80
Переглянути файл
@@ -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}");
}
}
}
-25
Переглянути файл
@@ -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())
+2 -227
Переглянути файл
@@ -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();
-17
Переглянути файл
@@ -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
+61 -444
Переглянути файл
@@ -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();
}
}
+51 -438
Переглянути файл
@@ -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()));
}
}
-10
Переглянути файл
@@ -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.
-5
Переглянути файл
@@ -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();
-50
Переглянути файл
@@ -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.
-31
Переглянути файл
@@ -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> {
+5 -308
Переглянути файл
@@ -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:?}");
-36
Переглянути файл
@@ -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();
+2 -249
Переглянути файл
@@ -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();
+3 -3
Переглянути файл
@@ -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.
+3 -21
Переглянути файл
@@ -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]
-1
Переглянути файл
@@ -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) {
-19
Переглянути файл
@@ -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")));
}
+5 -8
Переглянути файл
@@ -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"
);
}
}
-2
Переглянути файл
@@ -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;
+6 -29
Переглянути файл
@@ -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
+23 -342
Переглянути файл
@@ -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"));
}
}
-36
Переглянути файл
@@ -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()
);
}
+8 -40
Переглянути файл
@@ -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]
-6
Переглянути файл
@@ -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).
-20
Переглянути файл
@@ -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 {
-1
Переглянути файл
@@ -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;
+12 -97
Переглянути файл
@@ -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(
-138
Переглянути файл
@@ -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);
}
}
-34
Переглянути файл
@@ -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 -16
Переглянути файл
@@ -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(),
+2 -1
Переглянути файл
@@ -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}")))?;
+14 -17
Переглянути файл
@@ -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)]
{
+1 -1
Переглянути файл
@@ -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())
+1 -15
Переглянути файл
@@ -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;
}
+14 -48
Переглянути файл
@@ -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())
-38
Переглянути файл
@@ -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() {
+31 -336
Переглянути файл
@@ -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![(
+4 -35
Переглянути файл
@@ -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;
+4 -215
Переглянути файл
@@ -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]
+48 -336
Переглянути файл
@@ -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();
}
-67
Переглянути файл
@@ -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(())
}
-39
Переглянути файл
@@ -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", &current, &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,
-41
Переглянути файл
@@ -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);
}
+1 -12
Переглянути файл
@@ -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);
+1 -12
Переглянути файл
@@ -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"] {
-426
Переглянути файл
@@ -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");
}
}
+11 -92
Переглянути файл
@@ -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, &current);
};
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 })
}
+11 -198
Переглянути файл
@@ -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");
-14
Переглянути файл
@@ -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();
-1
Переглянути файл
@@ -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());
-216
Переглянути файл
@@ -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(),
+1 -1
Переглянути файл
@@ -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();
+22 -422
Переглянути файл
@@ -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);
}
}
+1 -1
Переглянути файл
@@ -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))),
+5 -36
Переглянути файл
@@ -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,
-28
Переглянути файл
@@ -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,
+2 -5
Переглянути файл
@@ -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
-13
Переглянути файл
@@ -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,
-5
Переглянути файл
@@ -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");
}
+1 -1
Переглянути файл
@@ -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,
+3 -15
Переглянути файл
@@ -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)
}
-154
Переглянути файл
@@ -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());
}
}
-1
Переглянути файл
@@ -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;
+6 -194
Переглянути файл
@@ -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!(
+12 -12
Переглянути файл
@@ -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 || {
+3 -33
Переглянути файл
@@ -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(
+5 -5
Переглянути файл
@@ -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);
+3 -10
Переглянути файл
@@ -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)]
-84
Переглянути файл
@@ -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 });
+2 -15
Переглянути файл
@@ -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,
+1 -3
Переглянути файл
@@ -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()
-6
Переглянути файл
@@ -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))
}
-1
Переглянути файл
@@ -169,7 +169,6 @@ pub fn forwarded(event: &PluginEvent) -> bool {
| PluginEvent::PromptWaiting { .. }
| PluginEvent::RevealView { .. }
| PluginEvent::CommitRequested { .. }
| PluginEvent::ClipboardRequested { .. }
| PluginEvent::EndpointsChanged { .. }
)
}
-16
Переглянути файл
@@ -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")]
+4 -118
Переглянути файл
@@ -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();
-1
Переглянути файл
@@ -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 { .. }
-2
Переглянути файл
@@ -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;
-130
Переглянути файл
@@ -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());
}
-243
Переглянути файл
@@ -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");
}
-234
Переглянути файл
@@ -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:?}");
}
+5 -14
Переглянути файл
@@ -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]
-2
Переглянути файл
@@ -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
-32
Переглянути файл
@@ -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();
}
-197
Переглянути файл
@@ -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");
}
-3
Переглянути файл
@@ -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
+2 -3
Переглянути файл
@@ -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())
-1
Переглянути файл
@@ -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
+2 -2
Переглянути файл
@@ -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)]
-15
Переглянути файл
@@ -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.
-33
Переглянути файл
@@ -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();
+3 -4
Переглянути файл
@@ -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)))
},
)
-68
Переглянути файл
@@ -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();
+2 -31
Переглянути файл
@@ -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(&region.language, &region.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))
-368
Переглянути файл
@@ -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