дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-22 17:40:45 +02:00
Порівняти коміти
129
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
891432c2d9 | ||
|
|
160ecf4693 | ||
|
|
cb087fff48 | ||
|
|
70e0215f46 | ||
|
|
460d30030e | ||
|
|
edf9affa8e | ||
|
|
070c795de5 | ||
|
|
5c9290fefd | ||
|
|
0527ff4218 | ||
|
|
e5b2f4dfc7 | ||
|
|
a3617aa3e9 | ||
|
|
bd7d4c475b | ||
|
|
15e32d5af6 | ||
|
|
3de76f1a63 | ||
|
|
262b91d89a | ||
|
|
4d6a21c695 | ||
|
|
7de8fb850e | ||
|
|
acb850758a | ||
|
|
6bf69cfb2a | ||
|
|
6829022b71 | ||
|
|
54611ff80a | ||
|
|
cacfc4142f | ||
|
|
237f7ee5a5 | ||
|
|
2321929709 | ||
|
|
6d788cb6f8 | ||
|
|
662c32eb05 | ||
|
|
82ff84e69e | ||
|
|
7ec0d3dbec | ||
|
|
466556603d | ||
|
|
3b2deb6ad8 | ||
|
|
f2429a8c14 | ||
|
|
f3e80ba020 | ||
|
|
f767bd2e7c | ||
|
|
51174842cc | ||
|
|
e4ece2bd8d | ||
|
|
a5093c0cd1 | ||
|
|
9a0256c7d4 | ||
|
|
78b478ee38 | ||
|
|
926a5424d1 | ||
|
|
f1aa47e762 | ||
|
|
305dbdc316 | ||
|
|
0a4f2fc1df | ||
|
|
93210c8c04 | ||
|
|
c52067f815 | ||
|
|
fce37c5627 | ||
|
|
90df4ba48e | ||
|
|
c3034b25e8 | ||
|
|
b5c2a84d5d | ||
|
|
723666891d | ||
|
|
268f12349f | ||
|
|
4dfdbd35fd | ||
|
|
281b093774 | ||
|
|
a55394782a | ||
|
|
ede72f0941 | ||
|
|
3ed4fa6836 | ||
|
|
4990a90bbf | ||
|
|
762b509b66 | ||
|
|
2964b2ffc5 | ||
|
|
704952a6ae | ||
|
|
65007093e7 | ||
|
|
696ab0c3ba | ||
|
|
e282546697 | ||
|
|
93fb7b6a85 | ||
|
|
e691aa9fb3 | ||
|
|
44a12abbd7 | ||
|
|
497b25bf4a | ||
|
|
4ecfb98c94 | ||
|
|
f1d6b0dc1b | ||
|
|
f2cfe38931 | ||
|
|
d18ac58b56 | ||
|
|
0021a764c3 | ||
|
|
a30103d410 | ||
|
|
89798baa3c | ||
|
|
c09c9b8aaf | ||
|
|
995a9563f7 | ||
|
|
893d9af6e6 | ||
|
|
73496669e7 | ||
|
|
add914f7fb | ||
|
|
0fd0f08865 | ||
|
|
054d2ba517 | ||
|
|
738dc12ef7 | ||
|
|
6135a5326d | ||
|
|
403bb28ca4 | ||
|
|
3249d4ee90 | ||
|
|
79e41c85ff | ||
|
|
f0a7cca1b1 | ||
|
|
21f1e2bbb4 | ||
|
|
ffdb5d74f2 | ||
|
|
d4d9e7d191 | ||
|
|
6a41509fd2 | ||
|
|
6efece99a4 | ||
|
|
0fab45689f | ||
|
|
71090202b6 | ||
|
|
8ed08510ed | ||
|
|
500df4ffc4 | ||
|
|
81aa9418aa | ||
|
|
706ce87cb7 | ||
|
|
4e5dbc8e0c | ||
|
|
79accd1311 | ||
|
|
85d02e03f9 | ||
|
|
e689c95e93 | ||
|
|
bb243909bf | ||
|
|
64544a4edd | ||
|
|
4fd1e4356e | ||
|
|
1794cd4fbb | ||
|
|
10d39e14ca | ||
|
|
101890ab4c | ||
|
|
86778d259f | ||
|
|
59c39a7e77 | ||
|
|
4d45ddc5a5 | ||
|
|
bfd6f01471 | ||
|
|
895d042dd7 | ||
|
|
eb37d9e96a | ||
|
|
dc8ae96206 | ||
|
|
e70bca39ee | ||
|
|
2fe09e73f5 | ||
|
|
b921de184b | ||
|
|
23739c90c7 | ||
|
|
923325aeae | ||
|
|
d7351dca1d | ||
|
|
8959f7aa5d | ||
|
|
5e4f187107 | ||
|
|
aebd26bd7d | ||
|
|
c43a6169be | ||
|
|
c4836f6cd8 | ||
|
|
02235cae04 | ||
|
|
fcef18048a | ||
|
|
d72363b6ba | ||
|
|
4ab4e0b44f |
No files matched your search
@@ -32,7 +32,12 @@ 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:
|
||||
@@ -40,26 +45,55 @@ 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
|
||||
echo "rust=true" >> "$GITHUB_OUTPUT"
|
||||
echo "frontend=true" >> "$GITHUB_OUTPUT"
|
||||
for job in $jobs; do echo "$job=true" >> "$GITHUB_OUTPUT"; done
|
||||
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/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
|
||||
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|evals/|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/)'
|
||||
# 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"
|
||||
# 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
|
||||
|
||||
rust:
|
||||
name: Rust (${{ matrix.os }})
|
||||
@@ -111,7 +145,7 @@ jobs:
|
||||
server:
|
||||
name: Remote server (linux musl)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
if: needs.changes.outputs.server == 'true'
|
||||
timeout-minutes: 40
|
||||
runs-on: ubuntu-22.04
|
||||
steps:
|
||||
@@ -129,7 +163,7 @@ jobs:
|
||||
plugins:
|
||||
name: Plugins (SDK, official, fixtures)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
if: needs.changes.outputs.plugins == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-22.04
|
||||
env:
|
||||
@@ -181,7 +215,7 @@ jobs:
|
||||
deny:
|
||||
name: Cargo deny
|
||||
needs: changes
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
if: needs.changes.outputs.deny == 'true'
|
||||
timeout-minutes: 15
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
@@ -210,10 +244,26 @@ 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.frontend == 'true'
|
||||
if: needs.changes.outputs.e2e == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-24.04
|
||||
strategy:
|
||||
|
||||
@@ -15,6 +15,7 @@ on:
|
||||
- "crates/**"
|
||||
- "languages/**"
|
||||
- "fixtures/**"
|
||||
- "java/**"
|
||||
- "Cargo.toml"
|
||||
- "Cargo.lock"
|
||||
- "src/features/run/**"
|
||||
@@ -41,12 +42,77 @@ 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: [typescript, python, rust, go, java, kotlin, php, c, cpp]
|
||||
language: ${{ fromJSON(needs.changes.outputs.languages) }}
|
||||
# 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
|
||||
|
||||
Створено
@@ -6734,6 +6734,7 @@ dependencies = [
|
||||
"tracing",
|
||||
"tracing-appender",
|
||||
"tracing-subscriber",
|
||||
"webkit2gtk",
|
||||
"webview2-com",
|
||||
"windows",
|
||||
"windows-sys 0.61.2",
|
||||
|
||||
@@ -194,6 +194,36 @@ 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`
|
||||
|
||||
@@ -213,6 +213,31 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
/// Availability for an explicit session switch must come from a recent discovery for this
|
||||
/// launch, not from the display fallback or a different project's session report.
|
||||
pub(super) fn fresh_model(
|
||||
&self,
|
||||
shared: &Shared,
|
||||
spec: &provider::ProviderSpec,
|
||||
model: &str,
|
||||
) -> Option<crate::AgentConfigValue> {
|
||||
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
|
||||
let select = |catalog: &CatalogData| {
|
||||
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
|
||||
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
|
||||
return None;
|
||||
}
|
||||
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
|
||||
};
|
||||
let state = self.state.lock();
|
||||
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
|
||||
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
|
||||
}
|
||||
let cache = shared.known.lock();
|
||||
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
|
||||
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
|
||||
}
|
||||
|
||||
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
let state = self.state.lock();
|
||||
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
|
||||
|
||||
@@ -11,6 +11,7 @@ const PROVIDER: &str = "catalog-test";
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Pending {
|
||||
launch: usize,
|
||||
method: String,
|
||||
params: Value,
|
||||
reply: oneshot::Sender<Result<Value, String>>,
|
||||
@@ -44,7 +45,7 @@ impl Harness {
|
||||
let launches = launches.clone();
|
||||
let live = live.clone();
|
||||
move |_, _, client, _| {
|
||||
launches.fetch_add(1, Ordering::SeqCst);
|
||||
let launch = launches.fetch_add(1, Ordering::SeqCst);
|
||||
live.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Live(live.clone());
|
||||
let pending = pending_tx.clone();
|
||||
@@ -75,10 +76,17 @@ 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/new"
|
||||
| "session/set_config_option"
|
||||
| "session/set_model"
|
||||
| "session/load"
|
||||
| "session/resume"
|
||||
| "session/prompt"
|
||||
| "session/set_mode" => {
|
||||
let (reply, mut result) = oneshot::channel();
|
||||
pending
|
||||
.send(Pending {
|
||||
launch,
|
||||
method: request["method"].as_str().unwrap().to_owned(),
|
||||
params: request["params"].clone(),
|
||||
reply,
|
||||
@@ -290,6 +298,223 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_confirmed_by_the_live_session() {
|
||||
switch_chat_model(ChatSwitch::Live).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
|
||||
switch_chat_model(ChatSwitch::Resume).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
|
||||
switch_chat_model(ChatSwitch::ResumeFails).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
|
||||
switch_chat_model(ChatSwitch::Unavailable).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
|
||||
switch_chat_model(ChatSwitch::Idle).await;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum ChatSwitch {
|
||||
Live,
|
||||
Resume,
|
||||
ResumeFails,
|
||||
Unavailable,
|
||||
Idle,
|
||||
}
|
||||
|
||||
async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::with_initialize(json!({
|
||||
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
|
||||
}));
|
||||
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let task = manager
|
||||
.create(NewAgentTask {
|
||||
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
|
||||
provider: PROVIDER.into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
|
||||
let mut initial = response(&["old"], &["low", "high"]);
|
||||
initial["sessionId"] = json!("saved-chat");
|
||||
initial["modes"] = json!({
|
||||
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
|
||||
});
|
||||
next.reply.send(Ok(initial.clone())).unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(0, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let mode = manager.set_config(&task.id, "mode", "ask".into());
|
||||
tokio::pin!(mode);
|
||||
let set = next_chat_request(&mut harness, mode.as_mut()).await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
mode.await.unwrap();
|
||||
}
|
||||
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
|
||||
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
|
||||
if matches!(scenario, ChatSwitch::Idle) {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
}
|
||||
|
||||
let mut events = events(&manager);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
|
||||
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
|
||||
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
|
||||
|
||||
let live = matches!(scenario, ChatSwitch::Live);
|
||||
let offline = matches!(scenario, ChatSwitch::Idle);
|
||||
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
|
||||
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
}
|
||||
}
|
||||
// A fallback selection settles without waiting for a new process.
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not open another session: {request:?}"),
|
||||
}
|
||||
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
|
||||
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
|
||||
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
|
||||
|
||||
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
|
||||
if !live {
|
||||
let load = harness.next().await;
|
||||
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
|
||||
assert_eq!(load.params["sessionId"], "saved-chat");
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
|
||||
}}))
|
||||
.unwrap();
|
||||
if load_fails {
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "config_option_update",
|
||||
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
|
||||
}}))
|
||||
.unwrap();
|
||||
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
|
||||
} else {
|
||||
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
|
||||
let mut resumed = response(models, &["low", "high"]);
|
||||
resumed["modes"] = initial["modes"].clone();
|
||||
load.reply.send(Ok(resumed)).unwrap();
|
||||
}
|
||||
if load_fails || unavailable {
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
|
||||
let task = snapshot(&manager);
|
||||
assert_eq!(task.model.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
|
||||
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
|
||||
if load_fails {
|
||||
manager
|
||||
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
|
||||
.await
|
||||
.unwrap();
|
||||
let retry = harness.next().await;
|
||||
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
|
||||
assert_eq!(retry.params["sessionId"], "saved-chat");
|
||||
retry.reply.send(Ok(initial.clone())).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!(set.method, "session/set_mode");
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
let prompt = harness.next().await;
|
||||
assert_eq!(prompt.method, "session/prompt");
|
||||
assert_eq!(prompt.params["sessionId"], "saved-chat");
|
||||
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
}
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
}
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("new"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
|
||||
manager.shutdown();
|
||||
}
|
||||
|
||||
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
|
||||
let task = manager.task(id).unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while task.state.lock().task.status != status || task.state.lock().busy {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
async fn next_chat_request(
|
||||
harness: &mut Harness,
|
||||
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
|
||||
) -> Pending {
|
||||
tokio::select! {
|
||||
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
|
||||
request = harness.next() => request,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -219,6 +219,23 @@ 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
|
||||
|
||||
@@ -348,6 +348,9 @@ 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>,
|
||||
@@ -359,6 +362,9 @@ 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).
|
||||
@@ -377,11 +383,14 @@ 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,
|
||||
@@ -393,6 +402,24 @@ 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 {
|
||||
@@ -519,7 +546,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().task.clone()).collect();
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
|
||||
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
|
||||
tasks
|
||||
}
|
||||
@@ -750,9 +777,11 @@ 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,
|
||||
@@ -863,9 +892,11 @@ 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,
|
||||
@@ -994,7 +1025,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, model_choice, previous_levels) = {
|
||||
let (target, change) = {
|
||||
let mut s = task.state.lock();
|
||||
let target = s
|
||||
.task
|
||||
@@ -1004,22 +1035,28 @@ impl AgentManager {
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
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)))
|
||||
}
|
||||
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 Some((model_choice, previous_levels)) = change else {
|
||||
return task.switch_discovered_model(target, value).await;
|
||||
};
|
||||
let previous = target.current.clone();
|
||||
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
|
||||
@@ -1186,9 +1223,12 @@ 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,
|
||||
@@ -1228,6 +1268,7 @@ 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;
|
||||
@@ -1528,6 +1569,7 @@ 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))
|
||||
@@ -1570,18 +1612,47 @@ impl AgentManager {
|
||||
.await
|
||||
}
|
||||
|
||||
/// 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),
|
||||
/// 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),
|
||||
}
|
||||
})
|
||||
.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, or as they are in `HEAD`.
|
||||
/// `view` compares them: as they were when it started, as they are in `HEAD`, or as they
|
||||
/// were when its last turn started.
|
||||
pub async fn rollback_changes(
|
||||
&self,
|
||||
id: &str,
|
||||
@@ -1592,15 +1663,18 @@ 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 = blocking(move || {
|
||||
let (restamped, restored) = blocking(move || {
|
||||
let (changes, rev) = match view {
|
||||
AgentChangesView::Group => (at.grouped_changes(&before)?.uncommitted, worktree::head_commit(at.cwd())?),
|
||||
AgentChangesView::SinceStart => (at.changes(&before)?, at.rev()?),
|
||||
AgentChangesView::SinceStart | AgentChangesView::LastTurn => (at.changes(&before)?, at.rev()?),
|
||||
};
|
||||
let changes = worktree::made_by_task(changes, touched.as_deref());
|
||||
let sources = match rev.as_deref() {
|
||||
@@ -1608,6 +1682,7 @@ 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.
|
||||
@@ -1617,6 +1692,58 @@ 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)
|
||||
@@ -1690,7 +1817,7 @@ impl AgentManager {
|
||||
s.task.mcp_overrides = cleaned;
|
||||
s.task.updated_ms = now_ms();
|
||||
}
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.snapshot())
|
||||
};
|
||||
if changed {
|
||||
task.persist();
|
||||
@@ -1748,10 +1875,12 @@ 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,
|
||||
@@ -1785,31 +1914,48 @@ impl Task {
|
||||
(s.before.clone(), s.touched.clone())
|
||||
}
|
||||
|
||||
/// 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()
|
||||
};
|
||||
blocking(move || worktree::snapshot(&cwd)).await.ok()
|
||||
/// 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))
|
||||
}
|
||||
|
||||
/// 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;
|
||||
}
|
||||
/// 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
|
||||
}
|
||||
};
|
||||
self.state.lock().turn = turn;
|
||||
self.persist();
|
||||
}
|
||||
|
||||
/// 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 };
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
let Some(touched) = &s.touched else { return };
|
||||
let mut touched = (**touched).clone();
|
||||
touched.extend(changed);
|
||||
s.touched = Some(Arc::new(touched));
|
||||
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() }));
|
||||
}
|
||||
self.persist();
|
||||
}
|
||||
@@ -1826,7 +1972,7 @@ impl Task {
|
||||
}
|
||||
|
||||
fn emit_task(&self) {
|
||||
let task = self.state.lock().task.clone();
|
||||
let task = self.state.lock().snapshot();
|
||||
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
|
||||
}
|
||||
|
||||
@@ -1923,9 +2069,11 @@ 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,
|
||||
@@ -1977,11 +2125,11 @@ impl Task {
|
||||
/// the user stops one. The caller set `busy`.
|
||||
async fn run(self: Arc<Self>, mut prompt: AgentPrompt) {
|
||||
loop {
|
||||
let start = self.checkout_before_turn().await;
|
||||
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(start).await;
|
||||
self.record_turn_changes().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);
|
||||
@@ -2027,7 +2175,7 @@ impl Task {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
|
||||
/// Drops an idle resumable live session so the next turn reloads it.
|
||||
fn recycle_resumable_session(&self) {
|
||||
self.mcp_reload_pending.store(false, Ordering::Release);
|
||||
let live = {
|
||||
@@ -2035,12 +2183,110 @@ 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 {}: restarting idle resumable session for MCP override update", self.id);
|
||||
tracing::debug!("agent task {}: recycling idle resumable session", 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.
|
||||
@@ -2288,10 +2534,12 @@ impl Task {
|
||||
{
|
||||
return Ok(live);
|
||||
}
|
||||
let (provider_id, cwd, saved) = {
|
||||
let (provider_id, cwd, saved, pending) = {
|
||||
let s = self.state.lock();
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
|
||||
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)
|
||||
};
|
||||
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);
|
||||
@@ -2300,8 +2548,8 @@ impl Task {
|
||||
} else {
|
||||
raw_spec.clone()
|
||||
};
|
||||
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
|
||||
Ok(live) => live,
|
||||
let opened = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone(), pending_model).await {
|
||||
Ok(live) => Ok(live),
|
||||
Err(err) if can_fallback && err.allow_acp_fallback => {
|
||||
tracing::warn!(
|
||||
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
|
||||
@@ -2310,9 +2558,32 @@ 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).await.map_err(|e| e.message)?
|
||||
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);
|
||||
}
|
||||
Err(err) => return Err(err.message),
|
||||
};
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
@@ -2324,6 +2595,7 @@ 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))
|
||||
@@ -2373,6 +2645,12 @@ 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) {
|
||||
self.replaying.store(true, Ordering::Release);
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
@@ -2388,6 +2666,16 @@ impl Task {
|
||||
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!(
|
||||
@@ -2459,6 +2747,19 @@ 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 {
|
||||
@@ -2479,6 +2780,12 @@ 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;
|
||||
@@ -2492,6 +2799,9 @@ 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),
|
||||
}
|
||||
}
|
||||
@@ -2501,6 +2811,7 @@ 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);
|
||||
|
||||
@@ -399,163 +399,429 @@ pub fn apply_save_json(
|
||||
Ok(saved_names)
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
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)]
|
||||
enum SourceFormat {
|
||||
Jsonc,
|
||||
CodexToml,
|
||||
CopilotPlugin { root: PathBuf },
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct SourceSpec {
|
||||
id: &'static str,
|
||||
label: &'static str,
|
||||
id: String,
|
||||
label: String,
|
||||
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",
|
||||
label: "Project (.mcp.json)",
|
||||
id: "workspace-mcp".into(),
|
||||
label: "Project (.mcp.json)".into(),
|
||||
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",
|
||||
label: "VS Code (.vscode/mcp.json)",
|
||||
id: "vscode-mcp".into(),
|
||||
label: "VS Code (.vscode/mcp.json)".into(),
|
||||
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",
|
||||
label: "Cursor Project (.cursor/mcp.json)",
|
||||
id: "cursor-project".into(),
|
||||
label: "Cursor Project (.cursor/mcp.json)".into(),
|
||||
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",
|
||||
label: "Codex Project (.codex/config.toml)",
|
||||
id: "codex-project".into(),
|
||||
label: "Codex Project (.codex/config.toml)".into(),
|
||||
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",
|
||||
label: "Gemini Project (.gemini/settings.json)",
|
||||
id: "gemini-project".into(),
|
||||
label: "Gemini Project (.gemini/settings.json)".into(),
|
||||
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",
|
||||
label: "GitHub Copilot CLI",
|
||||
path: home.join(".copilot").join("mcp-config.json"),
|
||||
id: "copilot-cli".into(),
|
||||
label: "GitHub Copilot CLI".into(),
|
||||
path: copilot_dir.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",
|
||||
label: "Claude Code",
|
||||
id: "claude-code".into(),
|
||||
label: "Claude Code".into(),
|
||||
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",
|
||||
label: "Codex",
|
||||
id: "codex".into(),
|
||||
label: "Codex".into(),
|
||||
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",
|
||||
label: "Cursor",
|
||||
id: "cursor".into(),
|
||||
label: "Cursor".into(),
|
||||
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",
|
||||
label: "Gemini CLI",
|
||||
id: "gemini".into(),
|
||||
label: "Gemini CLI".into(),
|
||||
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",
|
||||
label: "JetBrains Air",
|
||||
id: "jetbrains-air".into(),
|
||||
label: "JetBrains Air".into(),
|
||||
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",
|
||||
label: "GitHub Copilot (JetBrains)",
|
||||
id: "copilot-intellij".into(),
|
||||
label: "GitHub Copilot (JetBrains)".into(),
|
||||
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_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
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();
|
||||
};
|
||||
if spec.format == SourceFormat::CodexToml {
|
||||
return parse_codex_toml_servers(&text);
|
||||
}
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return BTreeMap::new();
|
||||
return CopilotSettings::default();
|
||||
};
|
||||
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);
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
map
|
||||
}
|
||||
};
|
||||
for name in spec.disabled_servers.iter() {
|
||||
if let Some(srv) = servers.get_mut(name) {
|
||||
srv.enabled = false;
|
||||
}
|
||||
}
|
||||
servers
|
||||
@@ -612,8 +878,8 @@ pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option
|
||||
})
|
||||
.collect();
|
||||
out.push(McpExternalSource {
|
||||
id: spec.id.to_owned(),
|
||||
label: spec.label.to_owned(),
|
||||
id: spec.id,
|
||||
label: spec.label,
|
||||
path: IpcPath(spec.path),
|
||||
suggested_scope: spec.suggested_scope,
|
||||
native_provider: spec.native_provider.map(str::to_owned),
|
||||
@@ -641,7 +907,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, read_source_servers(spec, workspace_root));
|
||||
by_source.insert(spec.id.as_str(), read_source_servers(spec, workspace_root));
|
||||
}
|
||||
}
|
||||
let target = match scope {
|
||||
@@ -1370,4 +1636,125 @@ 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()));
|
||||
}
|
||||
}
|
||||
@@ -672,6 +672,8 @@ 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.
|
||||
|
||||
@@ -2852,7 +2852,10 @@ 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()).await.unwrap().as_deref(), Some("original\n"));
|
||||
assert_eq!(
|
||||
mgr.base_text(&task.id, changes[0].path.0.clone(), AgentChangesView::SinceStart).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();
|
||||
@@ -3636,6 +3639,178 @@ 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 {
|
||||
@@ -3652,7 +3827,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")).await.unwrap();
|
||||
let base = mgr.base_text(&task.id, repo.dir.join("a.txt"), AgentChangesView::SinceStart).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:?}");
|
||||
@@ -3792,7 +3967,11 @@ 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")).await.unwrap(), None, "{eol:?}");
|
||||
assert_eq!(
|
||||
mgr.base_text(&task.id, repo.dir.join("new.txt"), AgentChangesView::SinceStart).await.unwrap(),
|
||||
None,
|
||||
"{eol:?}"
|
||||
);
|
||||
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
|
||||
assert!(!repo.dir.join("new.txt").exists(), "{eol:?}");
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
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};
|
||||
@@ -610,7 +611,6 @@ 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,11 +626,16 @@ 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(path, Some(rev))?
|
||||
repo.file_bytes_at(&change.path.0, 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() {
|
||||
@@ -646,6 +651,187 @@ pub(crate) fn restore(
|
||||
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) {
|
||||
@@ -815,6 +1001,67 @@ 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();
|
||||
|
||||
@@ -536,7 +536,9 @@ impl PathMap {
|
||||
let abs = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
let in_base = base.map(|b| Path::new(b).join(p)).filter(|c| c.exists());
|
||||
// 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()));
|
||||
in_base.unwrap_or_else(|| cwd.join(p))
|
||||
};
|
||||
let abs = normalize(&abs);
|
||||
@@ -713,7 +715,7 @@ pub fn run(
|
||||
}
|
||||
}
|
||||
};
|
||||
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
|
||||
let out = process::run_bounded(&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() => {}
|
||||
@@ -755,7 +757,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.text);
|
||||
let summary = crate::sync::error_summary(&out);
|
||||
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() });
|
||||
@@ -1303,6 +1305,22 @@ mod tests {
|
||||
assert_eq!(identifier_len("x é_1 c", 2), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_a_member_build_s_workspace_relative_paths() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().to_path_buf();
|
||||
write(&root, "client/src/main.rs", "fn main() {}\n");
|
||||
write(&root, "client/src/lib.rs", "\n");
|
||||
write(&root, "src/lib.rs", "\n");
|
||||
let map = PathMap { root: root.clone(), canonical: None };
|
||||
let member = root.join("client");
|
||||
let base = member.to_str();
|
||||
// Build Module runs in the member; rustc names its files from the workspace root.
|
||||
assert_eq!(map.resolve("client/src/main.rs", &member, base), root.join("client/src/main.rs"));
|
||||
// A crate built from its own directory names them from there.
|
||||
assert_eq!(map.resolve("src/lib.rs", &member, base), member.join("src/lib.rs"));
|
||||
}
|
||||
|
||||
// Uses Unix absolute paths for the canonical root.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
|
||||
@@ -30,6 +30,7 @@ def processedResources = { Project p, s ->
|
||||
def describe = { Project p ->
|
||||
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
|
||||
if (p.gradle.parent != null) m.build = identity(p.rootProject)
|
||||
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
|
||||
// Gradle 4.x has it as a convention property, not an extension.
|
||||
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
|
||||
if (sets != null) {
|
||||
|
||||
@@ -41,6 +41,10 @@ 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)]
|
||||
@@ -301,6 +305,7 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
|
||||
path,
|
||||
name,
|
||||
tasks,
|
||||
resolvable_configurations: None,
|
||||
build: None,
|
||||
}
|
||||
}
|
||||
@@ -317,6 +322,8 @@ 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>,
|
||||
@@ -412,6 +419,7 @@ 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
|
||||
})
|
||||
@@ -1630,6 +1638,11 @@ 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())
|
||||
@@ -1658,6 +1671,12 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
|
||||
);
|
||||
let build_src = &model.projects[2];
|
||||
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
|
||||
assert_eq!(
|
||||
model.projects[0].resolvable_configurations,
|
||||
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
|
||||
);
|
||||
assert_eq!(model.projects[1].resolvable_configurations, None);
|
||||
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
|
||||
assert!(!model.projects[4].tasks.is_empty());
|
||||
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
|
||||
}
|
||||
|
||||
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
|
||||
configuration: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<GradleDependency>> {
|
||||
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
|
||||
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
|
||||
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, "--configuration".into(), configuration.into()];
|
||||
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
|
||||
if options.offline {
|
||||
args.push("--offline".into());
|
||||
}
|
||||
@@ -156,7 +156,10 @@ pub fn gradle_dependencies(
|
||||
|_, _| {},
|
||||
)?;
|
||||
if !out.success {
|
||||
return Err(IdeError::unavailable(error_summary(&out.text)));
|
||||
return Err(IdeError::unavailable(error_summary(&out)));
|
||||
}
|
||||
if let Some(note) = sync::truncation_note(&out) {
|
||||
return Err(IdeError::unavailable(note));
|
||||
}
|
||||
Ok(parse_report(&out.text))
|
||||
}
|
||||
@@ -337,14 +340,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
|
||||
&gradle::load(root).unwrap(),
|
||||
&options,
|
||||
":app",
|
||||
"testRuntimeClasspath",
|
||||
"review.tools",
|
||||
&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 testRuntimeClasspath --offline"
|
||||
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,8 @@ 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;
|
||||
|
||||
@@ -1875,6 +1875,14 @@ pub fn goto_declaration(text: &str, path: &Path, pos: Pos, local_repo: Option<Pa
|
||||
goto_declaration_in(text, path, pos, local_repo, Vec::new)
|
||||
}
|
||||
|
||||
/// The declaration of the property `name` in the pom at `path`, for files it configures
|
||||
/// outside the pom itself (a YAML resource's `@name@`): the first `<properties>` entry
|
||||
/// along the parent chain declaring it, `project.*` built-ins included.
|
||||
pub fn property_declaration(pom: &Path, name: &str, local_repo: Option<PathBuf>) -> Option<PomGoto> {
|
||||
let text = xml::read_text(pom)?;
|
||||
property_target(&text, pom, name, local_repo)
|
||||
}
|
||||
|
||||
/// [`goto_declaration`], where a `<parent>` and a dependency or plugin whose version no
|
||||
/// management entry provides (or a management entry itself) go to the artifact's own
|
||||
/// POM: the project module among `modules` with its coordinates, else the local
|
||||
|
||||
@@ -17,10 +17,72 @@ 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.
|
||||
/// Every line, stdout and stderr interleaved as received, up to [`MAX_TEXT_BYTES`].
|
||||
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
|
||||
@@ -41,7 +103,8 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &
|
||||
}
|
||||
|
||||
/// Runs `program args` in `cwd`, feeding each output line to `on_line`; kills
|
||||
/// the process group and returns `cancelled` when `cancel` fires.
|
||||
/// the process group and returns `cancelled` when `cancel` fires. `Output.text`
|
||||
/// keeps every line: callers that parse a complete model from it use this.
|
||||
pub(crate) fn run(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
@@ -53,6 +116,20 @@ 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],
|
||||
@@ -60,8 +137,27 @@ 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 =
|
||||
@@ -80,17 +176,22 @@ pub(crate) fn run_with_env(
|
||||
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 || {
|
||||
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;
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -102,7 +203,17 @@ pub(crate) fn run_with_env(
|
||||
child.stderr.take().map(|s| pump(Box::new(s), Stream::Stderr, tx.clone())),
|
||||
];
|
||||
drop(tx);
|
||||
let mut text = String::new();
|
||||
// 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;
|
||||
loop {
|
||||
if cancel.is_cancelled() {
|
||||
kill_tree(&mut child);
|
||||
@@ -112,8 +223,34 @@ pub(crate) fn run_with_env(
|
||||
Ok((_, line)) if encoding.notice.as_ref() == Some(&line) => {}
|
||||
Ok((stream, line)) => {
|
||||
on_line(stream, &line);
|
||||
text.push_str(&line);
|
||||
text.push('\n');
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(mpsc::RecvTimeoutError::Timeout) => {}
|
||||
Err(mpsc::RecvTimeoutError::Disconnected) => break,
|
||||
@@ -123,13 +260,85 @@ pub(crate) fn run_with_env(
|
||||
let _ = r.join();
|
||||
}
|
||||
let status = child.wait()?;
|
||||
Ok(Output { success: status.success(), text })
|
||||
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 })
|
||||
}
|
||||
|
||||
#[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) {
|
||||
@@ -148,10 +357,11 @@ 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("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
|
||||
let err = run_bounded("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
|
||||
.err()
|
||||
.unwrap();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
@@ -171,9 +381,117 @@ mod tests {
|
||||
std::thread::sleep(Duration::from_millis(200));
|
||||
c.cancel();
|
||||
});
|
||||
let err = run("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
|
||||
let err =
|
||||
run_bounded("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"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
|
||||
//! run it on both revisions of `process.rs` and compare the printed numbers.
|
||||
//!
|
||||
//! ```text
|
||||
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
|
||||
//! ```
|
||||
|
||||
use crate::process;
|
||||
use ide_core::CancellationToken;
|
||||
use std::collections::BTreeMap;
|
||||
use std::time::Instant;
|
||||
|
||||
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
|
||||
#[test]
|
||||
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
|
||||
fn high_output_process_numbers() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
|
||||
let start = Instant::now();
|
||||
let mut lines = 0u64;
|
||||
let mut fed = 0usize;
|
||||
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
lines += 1;
|
||||
fed += line.len() + 1;
|
||||
})
|
||||
.unwrap();
|
||||
println!(
|
||||
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
|
||||
start.elapsed(),
|
||||
out.success,
|
||||
out.text.len()
|
||||
);
|
||||
}
|
||||
@@ -268,8 +268,20 @@ 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(text: &str) -> String {
|
||||
pub(crate) fn error_summary(output: &Output) -> String {
|
||||
let text = &output.text;
|
||||
// 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). \
|
||||
@@ -289,11 +301,15 @@ pub(crate) fn error_summary(text: &str) -> String {
|
||||
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
|
||||
.take(4)
|
||||
.collect();
|
||||
if lines.is_empty() {
|
||||
let mut summary = 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).
|
||||
@@ -397,7 +413,9 @@ pub fn sync_maven(
|
||||
}
|
||||
}
|
||||
if !out.success {
|
||||
errors.push(error_summary(&out.text));
|
||||
errors.push(error_summary(&out));
|
||||
} else if let Some(note) = truncation_note(&out) {
|
||||
errors.push(note);
|
||||
}
|
||||
}
|
||||
cache.at_ms = now_ms();
|
||||
@@ -437,6 +455,8 @@ 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(),
|
||||
@@ -457,7 +477,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 }
|
||||
Output { success: false, text: error.message, truncated: false }
|
||||
}
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
@@ -470,7 +490,7 @@ pub fn sync_gradle_model(
|
||||
let cache = GradleCache {
|
||||
hash: hash_gradle_files(&gradle::build_files(root, &model)),
|
||||
at_ms: now_ms(),
|
||||
error: (!out.success).then(|| error_summary(&out.text)),
|
||||
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
|
||||
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
|
||||
projects,
|
||||
resources: true,
|
||||
@@ -914,10 +934,22 @@ 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";
|
||||
assert_eq!(error_summary(text), "Failed to execute goal");
|
||||
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
|
||||
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");
|
||||
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
|
||||
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
|
||||
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"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -446,6 +446,12 @@ 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).
|
||||
|
||||
@@ -16,18 +16,55 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
||||
/// For a `tokio::process::Command`, pass `cmd.as_std_mut()`.
|
||||
///
|
||||
/// - Windows: release builds use the GUI subsystem, so without `CREATE_NO_WINDOW` every
|
||||
/// console child flashes a `cmd` window.
|
||||
/// console child flashes a `cmd` window. Batch files also need a PATH small enough for cmd.
|
||||
/// - 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.
|
||||
/// Explicit variables take precedence over the host environment. Call after setting
|
||||
/// `current_dir` and any explicit `PATH`, and before `env_clear`.
|
||||
pub fn prepare(cmd: &mut Command) -> &mut Command {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
cmd.creation_flags(CREATE_NO_WINDOW);
|
||||
}
|
||||
host_env(cmd)
|
||||
host_env(cmd);
|
||||
#[cfg(windows)]
|
||||
compact_batch_path(cmd);
|
||||
cmd
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn compact_batch_path(cmd: &mut Command) {
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use std::path::{Component, Prefix};
|
||||
|
||||
// Rust runs these files through cmd.exe, which drops inherited variables over this limit.
|
||||
const CMD_ENV_LIMIT: usize = 8191;
|
||||
let extension = Path::new(cmd.get_program()).extension();
|
||||
if !extension.is_some_and(|ext| ext.eq_ignore_ascii_case("cmd") || ext.eq_ignore_ascii_case("bat")) {
|
||||
return;
|
||||
}
|
||||
let path = match cmd.get_envs().find(|(key, _)| key.eq_ignore_ascii_case("PATH")) {
|
||||
Some((_, path)) => path.map(OsStr::to_owned),
|
||||
None => std::env::var_os("PATH"),
|
||||
};
|
||||
let Some(path) = path.filter(|p| p.encode_wide().count() > CMD_ENV_LIMIT) else { return };
|
||||
|
||||
// The IDE includes possible locations of as-yet uninstalled tools. Prune paths that are
|
||||
// missing now, keeping search precedence and leaving UNC and relative paths alone.
|
||||
let dirs = std::env::split_paths(&path).filter(|dir| {
|
||||
let local = dir.is_absolute()
|
||||
&& matches!(dir.components().next(), Some(Component::Prefix(p))
|
||||
if matches!(p.kind(), Prefix::Disk(_) | Prefix::VerbatimDisk(_)));
|
||||
!local
|
||||
|| !std::fs::symlink_metadata(dir)
|
||||
.is_err_and(|e| matches!(e.kind(), std::io::ErrorKind::NotFound | std::io::ErrorKind::NotADirectory))
|
||||
});
|
||||
if let Ok(compact) = std::env::join_paths(dirs)
|
||||
&& compact.encode_wide().count() <= CMD_ENV_LIMIT
|
||||
{
|
||||
cmd.env("PATH", compact);
|
||||
}
|
||||
}
|
||||
|
||||
/// Starts the child as the leader of its own process group on Unix, so [`kill_tree`] and
|
||||
@@ -885,6 +922,44 @@ mod tests {
|
||||
assert!(!process_alive(pid));
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn batch_launch_keeps_runtime_paths_when_cmd_would_drop_path() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let script = root.path().join("server.CMD");
|
||||
std::fs::write(&script, "@echo off\r\nif not defined PATH exit /b 42\r\n").unwrap();
|
||||
let selected = root.path().join("Selected Runtime");
|
||||
let fallback = root.path().join("Fallback Runtime");
|
||||
std::fs::create_dir(&selected).unwrap();
|
||||
std::fs::create_dir(&fallback).unwrap();
|
||||
let relative = Path::new("relative");
|
||||
let unc = Path::new(r"\\openidea-test\share\bin");
|
||||
let missing = root.path().join("uninstalled-".repeat(12));
|
||||
let path = std::env::join_paths(
|
||||
std::iter::once(selected.as_path()).chain(std::iter::repeat_n(missing.as_path(), 60)).chain([
|
||||
unc,
|
||||
relative,
|
||||
fallback.as_path(),
|
||||
]),
|
||||
)
|
||||
.unwrap();
|
||||
let compact = std::env::join_paths([selected.as_path(), unc, relative, fallback.as_path()]).unwrap();
|
||||
|
||||
let path_in = |cmd: &Command| {
|
||||
cmd.get_envs()
|
||||
.find_map(|(key, value)| key.eq_ignore_ascii_case("PATH").then(|| value.map(OsStr::to_owned)))
|
||||
.flatten()
|
||||
};
|
||||
let mut cmd = Command::new(&script);
|
||||
cmd.current_dir(root.path()).env("PATH", &path);
|
||||
prepare(&mut cmd);
|
||||
assert_eq!(path_in(&cmd), Some(compact));
|
||||
assert!(cmd.status().unwrap().success());
|
||||
|
||||
let mut native = Command::new(root.path().join("server.exe"));
|
||||
assert_eq!(path_in(prepare(native.env("PATH", &path))), Some(path));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn process_alive_rejects_ids_that_are_not_a_single_process() {
|
||||
@@ -1062,11 +1137,13 @@ mod tests {
|
||||
#[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("/nix/store/x-devshell/bin".into())),
|
||||
("PATH".into(), Some(devshell.into())),
|
||||
("OPENIDEA_PROJECT_UNSET".into(), None),
|
||||
],
|
||||
);
|
||||
@@ -1075,7 +1152,7 @@ mod tests {
|
||||
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("/nix/store/x-devshell/bin".into())));
|
||||
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");
|
||||
|
||||
@@ -1093,7 +1170,7 @@ mod tests {
|
||||
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("/nix/store/x-devshell/bin".into()));
|
||||
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"));
|
||||
}
|
||||
|
||||
@@ -752,6 +752,8 @@ pub struct AppearanceSettings {
|
||||
pub compact_mode: bool,
|
||||
/// IDEA "Use smaller indents in trees": tool window trees indent less per level.
|
||||
pub small_tree_indents: bool,
|
||||
/// Linux: WebKit animates each mouse wheel step
|
||||
pub smooth_scrolling: bool,
|
||||
pub full_path_in_title: bool,
|
||||
pub project_colors_in_toolbar: bool,
|
||||
pub dnd_with_alt_only: bool,
|
||||
@@ -770,6 +772,8 @@ pub struct AppearanceSettings {
|
||||
pub show_tool_window_names: bool,
|
||||
pub show_tool_window_badges: bool,
|
||||
pub widescreen_tool_windows: bool,
|
||||
/// Each tool window keeps its own size; off, the windows of a side share one.
|
||||
pub remember_tool_window_sizes: bool,
|
||||
/// View › Appearance › Toolbar; hidden leaves IDEA's compact window header.
|
||||
pub show_main_toolbar: bool,
|
||||
pub show_status_bar: bool,
|
||||
@@ -885,6 +889,7 @@ impl Default for AppearanceSettings {
|
||||
different_tool_window_background: false,
|
||||
compact_mode: false,
|
||||
small_tree_indents: false,
|
||||
smooth_scrolling: true,
|
||||
full_path_in_title: false,
|
||||
project_colors_in_toolbar: true,
|
||||
dnd_with_alt_only: false,
|
||||
@@ -898,6 +903,7 @@ impl Default for AppearanceSettings {
|
||||
show_tool_window_names: false,
|
||||
show_tool_window_badges: true,
|
||||
widescreen_tool_windows: false,
|
||||
remember_tool_window_sizes: false,
|
||||
show_main_toolbar: true,
|
||||
show_status_bar: true,
|
||||
navigation_bar: NavigationBarPosition::StatusBar,
|
||||
@@ -1504,6 +1510,10 @@ 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 {
|
||||
@@ -1748,6 +1758,16 @@ mod tests {
|
||||
assert_eq!(kept.appearance.theme, "solarized-dark");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn smooth_scrolling_defaults_on_and_round_trips() {
|
||||
let old: Settings = serde_json::from_str(r#"{"appearance":{"zoom":110}}"#).unwrap();
|
||||
assert!(old.appearance.smooth_scrolling);
|
||||
let off: Settings = serde_json::from_str(r#"{"appearance":{"smoothScrolling":false}}"#).unwrap();
|
||||
assert!(!off.appearance.smooth_scrolling);
|
||||
let json = serde_json::to_value(&off).unwrap();
|
||||
assert_eq!(json["appearance"]["smoothScrolling"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn window_close_settings_default_off_and_round_trip() {
|
||||
for old in [r#"{}"#, r#"{"general":{"confirmExit":false}}"#] {
|
||||
|
||||
@@ -20,6 +20,34 @@ pub struct VcsSettings {
|
||||
pub shelf: ShelfSettings,
|
||||
/// Issue Navigation: commit-message patterns turned into links.
|
||||
pub issue_navigation: Vec<IssueLink>,
|
||||
/// Directory Mappings: repository roots added to or excluded from the detected ones.
|
||||
pub mappings: VcsMappings,
|
||||
}
|
||||
|
||||
/// Directory Mappings on top of repository detection. Paths are relative to the project
|
||||
/// root (`.` for the root itself) or absolute outside it.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct VcsMappings {
|
||||
/// Detected repositories the IDE leaves alone: no Git or Commit integration, files stay.
|
||||
pub excluded: Vec<String>,
|
||||
/// Repository roots detection does not reach (outside the project, or deeper).
|
||||
pub added: Vec<String>,
|
||||
}
|
||||
|
||||
impl VcsMappings {
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.excluded.is_empty() && self.added.is_empty()
|
||||
}
|
||||
|
||||
/// `path` resolved against `project_root`.
|
||||
pub fn resolve(project_root: &std::path::Path, path: &str) -> std::path::PathBuf {
|
||||
match path {
|
||||
"" | "." => project_root.to_path_buf(),
|
||||
p if std::path::Path::new(p).is_absolute() => p.into(),
|
||||
p => project_root.join(p),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for VcsSettings {
|
||||
@@ -34,6 +62,7 @@ impl Default for VcsSettings {
|
||||
confirmation: VcsConfirmationSettings::default(),
|
||||
shelf: ShelfSettings::default(),
|
||||
issue_navigation: Vec::new(),
|
||||
mappings: VcsMappings::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -77,6 +106,9 @@ pub struct GitSettings {
|
||||
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
|
||||
/// stage and unstage instead of inclusion checkboxes, and no change lists.
|
||||
pub staging_area: bool,
|
||||
/// Scan the working tree with `git status` (for file systems whose metadata only
|
||||
/// the system git reads correctly) instead of in process.
|
||||
pub cli_status: bool,
|
||||
}
|
||||
|
||||
impl Default for GitSettings {
|
||||
@@ -101,6 +133,7 @@ impl Default for GitSettings {
|
||||
push_dialog_only_protected: false,
|
||||
combine_stash_and_shelf: false,
|
||||
staging_area: false,
|
||||
cli_status: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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: ide_core::input::InputWriter,
|
||||
writer: Arc<ide_core::input::InputWriter>,
|
||||
killer: Box<dyn portable_pty::ChildKiller + Send + Sync>,
|
||||
#[cfg_attr(not(unix), allow(dead_code))]
|
||||
pid: Option<u32>,
|
||||
@@ -1025,10 +1025,12 @@ 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,
|
||||
);
|
||||
@@ -1043,10 +1045,35 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
|
||||
Ok(json!({ "processId": pid }))
|
||||
}
|
||||
|
||||
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).
|
||||
/// 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).
|
||||
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;
|
||||
@@ -1078,11 +1105,20 @@ fn forward_terminal_output(
|
||||
break;
|
||||
}
|
||||
}
|
||||
// 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(),
|
||||
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,
|
||||
Err(e) if e.error_len().is_none() => e.valid_up_to(),
|
||||
Err(_) => pending.len(),
|
||||
Err(_) => pending.len() - keep,
|
||||
};
|
||||
if valid > 0 && pending[valid - 1] == b'\r' {
|
||||
valid -= 1;
|
||||
|
||||
@@ -1010,6 +1010,44 @@ async fn run_in_terminal_spawns_debuggee() {
|
||||
assert!(response["body"]["processId"].as_u64().unwrap() > 0);
|
||||
}
|
||||
|
||||
/// The debug console answers a terminal's cursor position query: ConPTY asks one before it runs
|
||||
/// the program at all (Windows debuggees never started), and programs that lay out a prompt ask too.
|
||||
#[tokio::test]
|
||||
async fn run_in_terminal_answers_cursor_position_queries() {
|
||||
#[cfg(unix)]
|
||||
let program = vec![
|
||||
"sh".into(),
|
||||
"-c".into(),
|
||||
r"stty -echo -icanon min 6; printf '\033[6n'; reply=$(dd bs=6 count=1 2>/dev/null); stty sane; case $reply in *'[1;1R') echo answered;; esac".into(),
|
||||
];
|
||||
#[cfg(windows)]
|
||||
let program = vec!["cmd".into(), "/c".into(), "echo answered".into()];
|
||||
let h = harness(Script { run_in_terminal: Some(program), ..Script::default() });
|
||||
h.start(config()).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("answered"))).await;
|
||||
let output: String = h
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } => Some(output.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert!(!output.contains("\x1b[6n"), "{output:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cursor_position_queries_are_taken_out_of_the_output() {
|
||||
use crate::session::{partial_cursor_query, take_cursor_queries};
|
||||
assert_eq!(take_cursor_queries(b"a\x1b[6nb\x1b[6n"), (b"ab".to_vec(), 2));
|
||||
assert_eq!(take_cursor_queries(b"\x1b[0mtext"), (b"\x1b[0mtext".to_vec(), 0));
|
||||
assert_eq!(partial_cursor_query(b"text\x1b["), 2);
|
||||
assert_eq!(partial_cursor_query(b"text\x1b[6"), 3);
|
||||
assert_eq!(partial_cursor_query(b"text\x1b[0m"), 0);
|
||||
assert_eq!(partial_cursor_query(b"text"), 0);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn run_in_terminal_program_reads_typed_input() {
|
||||
|
||||
@@ -18,14 +18,21 @@ struct State {
|
||||
database: String,
|
||||
settings: Vec<(String, String)>,
|
||||
read_only: bool,
|
||||
session_id: String,
|
||||
session: Mutex<bool>,
|
||||
session: Mutex<Session>,
|
||||
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 expired or is missing on this node (code 372). Reconnect to start a new session. Behind a load balancer, 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")
|
||||
@@ -36,11 +43,32 @@ impl ClickhousePool {
|
||||
if source.options.transaction == DbTxMode::Manual {
|
||||
return Err(transaction_error());
|
||||
}
|
||||
for (name, _) in &setup.params {
|
||||
if reserved_setting(name) {
|
||||
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) {
|
||||
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()) {
|
||||
@@ -105,16 +133,50 @@ impl ClickhousePool {
|
||||
endpoint,
|
||||
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: setup.params,
|
||||
database: database.into(),
|
||||
settings,
|
||||
read_only: source.read_only,
|
||||
session_id: uuid::Uuid::new_v4().to_string(),
|
||||
session: Mutex::new(false),
|
||||
session: Mutex::new(Session {
|
||||
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
|
||||
..Session::default()
|
||||
}),
|
||||
closed: CancellationToken::new(),
|
||||
}));
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
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?;
|
||||
}
|
||||
for sql in setup.statements {
|
||||
pool.execute(&sql, 0, &cancel).await?;
|
||||
}
|
||||
@@ -151,27 +213,30 @@ 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, initialized: bool) -> RequestBuilder {
|
||||
fn request(&self, client: &Client, query_id: &str, max_rows: usize, session: &Session) -> 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(&[
|
||||
("session_id", self.0.session_id.clone()),
|
||||
("session_timeout", "3600".into()),
|
||||
("query_id", query_id.to_owned()),
|
||||
("default_format", FORMAT.into()),
|
||||
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
|
||||
if !session.strict_read_only {
|
||||
request = request.query(&[
|
||||
("output_format_json_quote_denormals", "1".into()),
|
||||
("max_result_rows", max_rows.saturating_add(1).to_string()),
|
||||
("result_overflow_mode", "break".into()),
|
||||
]);
|
||||
if initialized {
|
||||
request = request.query(&[("session_check", "1")]);
|
||||
} else {
|
||||
}
|
||||
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 !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only {
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -200,7 +265,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)?;
|
||||
@@ -254,7 +319,7 @@ impl ClickhousePool {
|
||||
match result {
|
||||
Some(result) => {
|
||||
if result.is_ok() {
|
||||
*session = true;
|
||||
session.initialized = true;
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -307,11 +372,7 @@ 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 detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
|
||||
"ClickHouse HTTP session expired; reconnect to restore session settings"
|
||||
} else {
|
||||
detail
|
||||
};
|
||||
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
|
||||
self.redact_error(IdeError::new(
|
||||
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
|
||||
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
|
||||
@@ -323,9 +384,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 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.
|
||||
/// 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.
|
||||
struct RowReader {
|
||||
skip: usize,
|
||||
max_rows: usize,
|
||||
@@ -433,7 +494,11 @@ impl RowReader {
|
||||
let rest = std::mem::take(&mut self.pending);
|
||||
self.line(&rest)?;
|
||||
if let Some(exception) = self.exception {
|
||||
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
|
||||
let detail = exception_text(&exception);
|
||||
return Err(IdeError::invalid(format!(
|
||||
"ClickHouse: {}",
|
||||
if session_not_found(detail) { SESSION_LOST } else { detail }
|
||||
)));
|
||||
}
|
||||
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
|
||||
let types = self.types.unwrap_or_default();
|
||||
@@ -445,6 +510,13 @@ 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 {
|
||||
@@ -479,6 +551,20 @@ 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_")
|
||||
@@ -575,6 +661,19 @@ 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)
|
||||
}
|
||||
@@ -653,6 +752,7 @@ 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",
|
||||
@@ -664,7 +764,7 @@ mod tests {
|
||||
user: "reader".into(),
|
||||
read_only: true,
|
||||
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
|
||||
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
|
||||
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
|
||||
@@ -687,7 +787,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[2], "max_result_rows").as_deref(), Some("2"));
|
||||
assert_eq!(value(&urls[3], "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="));
|
||||
@@ -695,8 +795,10 @@ 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();
|
||||
@@ -706,6 +808,85 @@ mod tests {
|
||||
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_unset_database_uses_the_accounts_default_in_both_modes() {
|
||||
for mode in ["true", "false"] {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE); 2]).await;
|
||||
let source = DataSource { properties: vec![property("use_http_session", mode)], ..source(port) };
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
|
||||
for request in requests.await.unwrap() {
|
||||
assert_eq!(query_value(&request_url(&request), "database"), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[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("Reconnect"));
|
||||
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();
|
||||
@@ -726,6 +907,144 @@ 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![(
|
||||
|
||||
@@ -916,6 +916,37 @@ 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;
|
||||
|
||||
@@ -230,6 +230,44 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
|
||||
}
|
||||
|
||||
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
|
||||
#[tokio::test]
|
||||
async fn drops_a_database_the_ide_holds_connections_to() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_drop_me", 0, &c).await?;
|
||||
db.execute("p", "CREATE DATABASE oi_drop_me TEMPLATE template0", 0, &c).await?;
|
||||
|
||||
// What the tree and a manual-commit console leave open on the database.
|
||||
db.schemas("p:oi_drop_me").await?;
|
||||
db.set_manual_commit("p:oi_drop_me", true).await?;
|
||||
db.execute("p:oi_drop_me", "SELECT 1", 1, &c).await?;
|
||||
|
||||
db.drop_database("p", "oi_drop_me", "drop database oi_drop_me").await?;
|
||||
assert!(!db.is_connected("p:oi_drop_me"));
|
||||
assert!(!db.databases("p").await?.names.iter().any(|n| n == "oi_drop_me"));
|
||||
|
||||
let current = db.databases("p").await?.current;
|
||||
let refused = db.drop_database("p", ¤t, &format!("drop database \"{current}\"")).await;
|
||||
assert!(refused.is_err());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn creates_a_database_from_a_template_the_ide_holds_connections_to() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_from_template", 0, &c).await?;
|
||||
db.schemas("p:template1").await?;
|
||||
|
||||
db.create_database("p", "template1", "create database oi_from_template").await?;
|
||||
assert!(!db.is_connected("p:template1"));
|
||||
assert!(db.databases("p").await?.names.iter().any(|n| n == "oi_from_template"));
|
||||
db.execute("p", "DROP DATABASE oi_from_template", 0, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
|
||||
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
|
||||
let mut lines = Vec::new();
|
||||
|
||||
@@ -95,3 +95,44 @@ 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);
|
||||
}
|
||||
@@ -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.12.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.
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
|
||||
use crate::Host;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::settings::{ExternalFormatter, LanguagesSettings};
|
||||
use ide_core::{DocId, IdeError, IdeEvent, IdeResult, Pos, Range, TextEdit};
|
||||
use ide_language::LanguageConfig;
|
||||
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_lsp::types::FormatOptions;
|
||||
use ide_tools::{Tools, formatter};
|
||||
use std::path::Path;
|
||||
@@ -129,12 +129,101 @@ 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(Vec::new());
|
||||
return Ok(None);
|
||||
}
|
||||
if snap.read_only {
|
||||
return Err(IdeError::invalid("The file is read-only"));
|
||||
@@ -160,7 +249,8 @@ pub async fn format(
|
||||
)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.map(Some);
|
||||
}
|
||||
// A committed PHP-CS-Fixer configuration takes over Reformat Code for `.php` files.
|
||||
if options.tool.is_none()
|
||||
@@ -168,7 +258,7 @@ pub async fn format(
|
||||
&& let Some(fixer) = formatter::php_cs_fixer(&snap.path)
|
||||
{
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(Vec::new());
|
||||
return Ok(None);
|
||||
}
|
||||
host.require_trust(window)?;
|
||||
if snap.read_only {
|
||||
@@ -188,7 +278,7 @@ pub async fn format(
|
||||
body: Some("PHP-CS-Fixer does not support selection formatting; formatted the whole file".into()),
|
||||
});
|
||||
}
|
||||
return Ok(edits);
|
||||
return Ok(Some(edits));
|
||||
}
|
||||
let mut selected = external_tool(options.tool, language.as_ref(), &snap.path, &settings.languages)?;
|
||||
if let Some(tool) = selected
|
||||
@@ -200,13 +290,13 @@ pub async fn format(
|
||||
}
|
||||
let Some(selected) = selected else {
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(Vec::new());
|
||||
return Ok(None);
|
||||
}
|
||||
return project.lsp.format(doc, range, options).await;
|
||||
return project.lsp.format(doc, range, options).await.map(Some);
|
||||
};
|
||||
let tool_settings = settings.languages.formatter(selected);
|
||||
if options.on_save && !tool_settings.run_on_save {
|
||||
return Ok(Vec::new());
|
||||
return Ok(None);
|
||||
}
|
||||
host.require_trust(window)?;
|
||||
if snap.read_only {
|
||||
@@ -262,7 +352,7 @@ pub async fn format(
|
||||
)),
|
||||
});
|
||||
}
|
||||
edits.map_err(|e| e.with_tool(tool))
|
||||
edits.map(Some).map_err(|e| e.with_tool(tool))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -413,6 +503,103 @@ 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");
|
||||
|
||||
@@ -253,6 +253,16 @@ 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)
|
||||
|
||||
@@ -869,6 +869,7 @@ async fn occurrences(
|
||||
scope,
|
||||
max_matches: 0,
|
||||
context,
|
||||
include_excluded: false,
|
||||
};
|
||||
let host = call.host();
|
||||
let request = crate::mcp::tool::request_id();
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::page::{OFFSET, Page};
|
||||
use super::scope::{self, Scope};
|
||||
use super::search::{PathScope, paths_param};
|
||||
use super::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::{Diagnostic, IdeResult, Severity};
|
||||
use serde_json::{Map, Value, json};
|
||||
@@ -16,7 +16,7 @@ pub fn tools() -> Vec<Tool> {
|
||||
Use this tool to explore current open editors.",
|
||||
open_editors,
|
||||
)
|
||||
.param(scope::param()),
|
||||
.param(paths_param()),
|
||||
Tool::new(
|
||||
"get_current_file",
|
||||
"Returns the focused editor's file and selection reported by the IDE.
|
||||
@@ -45,20 +45,20 @@ Lines and UTF-16 columns are 1-based.",
|
||||
project_problems,
|
||||
)
|
||||
.param(Param::optional("errorsOnly", ParamType::Boolean, "Only errors (default) or warnings too"))
|
||||
.param(scope::param())
|
||||
.param(paths_param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Problems to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET)),
|
||||
]
|
||||
}
|
||||
|
||||
async fn open_editors(call: Call) -> IdeResult<Output> {
|
||||
let dir = Scope::of(&call)?;
|
||||
let paths = PathScope::of(&call)?;
|
||||
let windows = call.host.mcp_windows(call.root());
|
||||
let open = call.host.mcp_reports.editors(&windows);
|
||||
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
|
||||
let active = call.host.mcp_reports.focused(call.window()).filter(|e| paths.matches_path(&e.path.0));
|
||||
Output::json(json!({
|
||||
"activeFilePath": active.map(|e| call.display(&e.path.0)),
|
||||
"openFiles": open.iter().filter(|p| dir.contains(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
|
||||
"openFiles": open.iter().filter(|p| paths.matches_path(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -103,11 +103,11 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
|
||||
async fn project_problems(call: Call) -> IdeResult<Output> {
|
||||
let page = Page::of(&call, PROBLEMS_LIMIT)?;
|
||||
let errors_only = call.flag("errorsOnly", true)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let paths = PathScope::of(&call)?;
|
||||
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
|
||||
let problems: Vec<(String, Value)> = files
|
||||
.into_iter()
|
||||
.filter(|f| dir.contains(&f.path.0))
|
||||
.filter(|f| paths.matches_path(&f.path.0))
|
||||
.flat_map(|f| {
|
||||
let path = call.display(&f.path.0);
|
||||
let wanted = f.items.into_iter().filter(|d| !errors_only || d.severity == Severity::Error);
|
||||
|
||||
@@ -8,9 +8,10 @@ use crate::mcp::util::{
|
||||
self, RELATIVE_PATH_IN_PROJECT_DESCRIPTION, TIMED_OUT_DESCRIPTION, TIMEOUT_MILLISECONDS_DESCRIPTION,
|
||||
};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use ide_search::FileMask;
|
||||
use serde::Serialize;
|
||||
use serde_json::json;
|
||||
use std::path::Path;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const DEFAULT_READ_LIMIT: i64 = 2000;
|
||||
@@ -166,7 +167,9 @@ fn list_directory_tree() -> Tool {
|
||||
"Provides a tree representation of the specified directory in the pseudo graphic format like `tree` utility does.
|
||||
Use this tool to explore the contents of a directory or the whole project.
|
||||
You MUST prefer this tool over listing directories via command line utilities like `ls` or `dir`.
|
||||
A page that starts inside a directory repeats the lines of the directories above it.",
|
||||
A page that starts inside a directory repeats the lines of the directories above it.
|
||||
What `.gitignore` ignores is marked [git-ignored] and what the project excludes [ide-excluded]; entries inside a
|
||||
marked directory are not marked again.",
|
||||
|call| async move {
|
||||
let directory = call.str("directoryPath")?;
|
||||
let max_depth = call.opt_i64("maxDepth")?.unwrap_or(DEFAULT_TREE_DEPTH);
|
||||
@@ -181,6 +184,12 @@ A page that starts inside a directory repeats the lines of the directories above
|
||||
}
|
||||
let deadline = Instant::now() + Duration::from_millis(timeout.max(0) as u64);
|
||||
let cancel = call.cancel.clone();
|
||||
let marks = Marks {
|
||||
root: call.root().to_path_buf(),
|
||||
excludes: FileMask::new(&[], &call.project().search_excludes()).ok(),
|
||||
};
|
||||
// The directory itself, when it or one above it is left out.
|
||||
let root_mark = marker(ide_index::walk_skips(call.root(), &dir), marks.ide_excluded(&dir, true));
|
||||
let mut tree = TreeRender {
|
||||
out: String::new(),
|
||||
errors: Vec::new(),
|
||||
@@ -190,11 +199,12 @@ A page that starts inside a directory repeats the lines of the directories above
|
||||
page,
|
||||
seen: 0,
|
||||
above: Vec::new(),
|
||||
marks,
|
||||
};
|
||||
let tree = call
|
||||
.host()
|
||||
.blocking(move || {
|
||||
tree.render(&dir, "", true, max_depth, true);
|
||||
tree.render(&dir, "", true, max_depth, true, root_mark, !root_mark.is_empty());
|
||||
Ok(tree)
|
||||
})
|
||||
.await?;
|
||||
@@ -234,7 +244,8 @@ A page that starts inside a directory repeats the lines of the directories above
|
||||
|
||||
/// The `tree`-like listing: the directory's absolute path, then every entry (hidden and
|
||||
/// ignored ones too) by lower-cased name, directories marked with `/`; entries outside the
|
||||
/// page are counted, not listed.
|
||||
/// page are counted, not listed. An entry left out of the project is marked, the entries
|
||||
/// inside it are not.
|
||||
struct TreeRender {
|
||||
out: String,
|
||||
errors: Vec<String>,
|
||||
@@ -246,10 +257,48 @@ struct TreeRender {
|
||||
seen: usize,
|
||||
/// The lines of the directories above the entry, and whether this page shows them yet.
|
||||
above: Vec<(String, bool)>,
|
||||
marks: Marks,
|
||||
}
|
||||
|
||||
/// What the project leaves out, to mark in the listing.
|
||||
struct Marks {
|
||||
root: PathBuf,
|
||||
/// The project's exclusions (excluded folders, "Exclude files" names), as Find in Files applies them.
|
||||
excludes: Option<FileMask>,
|
||||
}
|
||||
|
||||
impl Marks {
|
||||
fn ide_excluded(&self, path: &Path, is_dir: bool) -> bool {
|
||||
let (Some(mask), Ok(rel)) = (&self.excludes, path.strip_prefix(&self.root)) else { return false };
|
||||
let rel = rel.to_string_lossy().replace('\\', "/");
|
||||
// A directory is excluded with the files in it.
|
||||
!rel.is_empty() && !mask.matches(&if is_dir { format!("{rel}/x") } else { rel })
|
||||
}
|
||||
}
|
||||
|
||||
/// Spelled out, so that the listing says what it means.
|
||||
fn marker(git_ignored: bool, ide_excluded: bool) -> &'static str {
|
||||
match (git_ignored, ide_excluded) {
|
||||
(true, true) => " [git-ignored] [ide-excluded]",
|
||||
(true, false) => " [git-ignored]",
|
||||
(false, true) => " [ide-excluded]",
|
||||
(false, false) => "",
|
||||
}
|
||||
}
|
||||
|
||||
impl TreeRender {
|
||||
fn render(&mut self, path: &Path, indent: &str, is_last: bool, max_depth: i64, is_root: bool) {
|
||||
/// `mark`: the entry's marker; `marked`: it or a directory above it is marked.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn render(
|
||||
&mut self,
|
||||
path: &Path,
|
||||
indent: &str,
|
||||
is_last: bool,
|
||||
max_depth: i64,
|
||||
is_root: bool,
|
||||
mark: &str,
|
||||
marked: bool,
|
||||
) {
|
||||
if max_depth <= 0 || self.timed_out || self.cancel.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
@@ -268,7 +317,7 @@ impl TreeRender {
|
||||
path.file_name().unwrap_or_default().to_string_lossy().into_owned()
|
||||
};
|
||||
let is_dir = path.is_dir() && !path.is_symlink();
|
||||
let line = format!("{indent}{prefix}{name}{}\n", if is_dir { "/" } else { "" });
|
||||
let line = format!("{indent}{prefix}{name}{}{mark}\n", if is_dir { "/" } else { "" });
|
||||
let shown = if is_root {
|
||||
self.out.push_str(&line);
|
||||
true
|
||||
@@ -278,22 +327,38 @@ impl TreeRender {
|
||||
if !is_dir {
|
||||
return;
|
||||
}
|
||||
let mut children: Vec<_> = match std::fs::read_dir(path) {
|
||||
Ok(entries) => entries.filter_map(|e| e.ok().map(|e| e.path())).collect(),
|
||||
// Without exclusions, `ignored` is what `.gitignore` says.
|
||||
let mut children: Vec<(PathBuf, bool)> = match ide_vfs::read_dir(path, &[]) {
|
||||
Ok(entries) => entries.into_iter().map(|e| (e.path.0, e.ignored)).collect(),
|
||||
Err(e) => {
|
||||
self.errors.push(format!("Failed to read {}: {e}", path.display()));
|
||||
self.errors.push(format!("Failed to read {}: {}", path.display(), e.message));
|
||||
return;
|
||||
}
|
||||
};
|
||||
let key = |p: &std::path::PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
|
||||
children.sort_by_cached_key(|p| (key(p).to_lowercase(), key(p)));
|
||||
let key = |p: &PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
|
||||
children.sort_by_cached_key(|(p, _)| (key(p).to_lowercase(), key(p)));
|
||||
let child_indent = format!("{indent}{}", if is_last { " " } else { "│ " });
|
||||
let n = children.len();
|
||||
if !is_root {
|
||||
self.above.push((line, shown));
|
||||
}
|
||||
for (i, child) in children.iter().enumerate() {
|
||||
self.render(child, &child_indent, i + 1 == n, max_depth - 1, false);
|
||||
// Inside a marked directory nothing is marked again.
|
||||
for (i, (child, git_ignored)) in children.iter().enumerate() {
|
||||
let child_mark = if marked {
|
||||
""
|
||||
} else {
|
||||
let child_dir = child.is_dir() && !child.is_symlink();
|
||||
marker(*git_ignored, self.marks.ide_excluded(child, child_dir))
|
||||
};
|
||||
self.render(
|
||||
child,
|
||||
&child_indent,
|
||||
i + 1 == n,
|
||||
max_depth - 1,
|
||||
false,
|
||||
child_mark,
|
||||
marked || !child_mark.is_empty(),
|
||||
);
|
||||
}
|
||||
if !is_root {
|
||||
self.above.pop();
|
||||
@@ -383,8 +448,9 @@ mod tests {
|
||||
page: Page { offset, limit },
|
||||
seen: 0,
|
||||
above: Vec::new(),
|
||||
marks: Marks { root: tmp.path().to_path_buf(), excludes: None },
|
||||
};
|
||||
tree.render(tmp.path(), "", true, 5, true);
|
||||
tree.render(tmp.path(), "", true, 5, true, "", false);
|
||||
let root = format!("{}/\n", tmp.path().display());
|
||||
(tree.out.strip_prefix(&root).unwrap().to_owned(), tree.seen)
|
||||
};
|
||||
@@ -396,4 +462,48 @@ mod tests {
|
||||
);
|
||||
assert_eq!(render(0, 100).0, " ├── a/\n │ ├── x.txt\n │ └── y.txt\n └── b.txt\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn what_the_project_leaves_out_is_marked_once() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap();
|
||||
for file in ["ign/deep/a.txt", "out/b.txt", "both/c.txt", "src/d.txt", "src/e.log"] {
|
||||
let path = root.join(file);
|
||||
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
std::fs::write(path, "").unwrap();
|
||||
}
|
||||
std::fs::write(root.join(".gitignore"), "ign/\nboth/\n*.log\n").unwrap();
|
||||
let excludes = ["out/**".to_owned(), "both/**".to_owned()];
|
||||
let mut tree = TreeRender {
|
||||
out: String::new(),
|
||||
errors: Vec::new(),
|
||||
timed_out: false,
|
||||
deadline: Instant::now() + Duration::from_secs(10),
|
||||
cancel: CancellationToken::new(),
|
||||
page: Page { offset: 0, limit: 100 },
|
||||
seen: 0,
|
||||
above: Vec::new(),
|
||||
marks: Marks { root: root.clone(), excludes: FileMask::new(&[], &excludes).ok() },
|
||||
};
|
||||
tree.render(&root, "", true, 5, true, "", false);
|
||||
let listing = tree.out.strip_prefix(&format!("{}/\n", root.display())).unwrap().to_owned();
|
||||
assert_eq!(
|
||||
listing,
|
||||
[
|
||||
" ├── .gitignore",
|
||||
" ├── both/ [git-ignored] [ide-excluded]",
|
||||
" │ └── c.txt",
|
||||
" ├── ign/ [git-ignored]",
|
||||
" │ └── deep/",
|
||||
" │ └── a.txt",
|
||||
" ├── out/ [ide-excluded]",
|
||||
" │ └── b.txt",
|
||||
" └── src/",
|
||||
" ├── d.txt",
|
||||
" └── e.log [git-ignored]",
|
||||
"",
|
||||
]
|
||||
.join("\n")
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,6 @@ mod files;
|
||||
mod http;
|
||||
mod page;
|
||||
pub mod reports;
|
||||
mod scope;
|
||||
mod search;
|
||||
mod symbols;
|
||||
mod tool;
|
||||
|
||||
@@ -305,7 +305,7 @@ pub fn list_runs() -> Tool {
|
||||
start of the command, exit code and times. `get_run_status` gives a tab's whole status.",
|
||||
|call| async move {
|
||||
let page = Page::of(&call, LIST_LIMIT)?;
|
||||
let dir = crate::mcp::scope::Scope::of(&call)?;
|
||||
let paths = crate::mcp::search::PathScope::of(&call)?;
|
||||
let wanted = call.opt_str("state")?.filter(|s| s != "all");
|
||||
let states = match wanted.as_deref() {
|
||||
None => None,
|
||||
@@ -327,7 +327,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
|
||||
.rev()
|
||||
.map(|r| r.status())
|
||||
// A tab belongs where its command runs.
|
||||
.filter(|s| dir.contains_shown(call.root(), s["workingDirectory"].as_str().unwrap_or_default()))
|
||||
.filter(|s| paths.matches_dir(&call.root().join(s["workingDirectory"].as_str().unwrap_or_default())))
|
||||
.filter(|s| {
|
||||
states.as_ref().is_none_or(|states| s["state"].as_str().is_some_and(|v| states.contains(&v)))
|
||||
})
|
||||
@@ -344,7 +344,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
|
||||
ParamType::String,
|
||||
"all (default), running, idle (not running), error (failed, crashed, startFailed), or one state",
|
||||
))
|
||||
.param(crate::mcp::scope::param())
|
||||
.param(crate::mcp::search::paths_param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
|
||||
@@ -139,12 +139,14 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
|
||||
}
|
||||
let page = Page::of(&call, CONFIGURATIONS_LIMIT)?;
|
||||
let query = call.opt_str("query")?.map(|q| q.to_lowercase());
|
||||
let dir = crate::mcp::scope::Scope::of(&call)?;
|
||||
let paths = crate::mcp::search::PathScope::of(&call)?;
|
||||
let list: Vec<Value> = configs
|
||||
.iter()
|
||||
// A configuration belongs where it runs.
|
||||
.filter(|c| {
|
||||
dir.contains(&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)))
|
||||
paths.matches_dir(
|
||||
&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)),
|
||||
)
|
||||
})
|
||||
.filter(|c| {
|
||||
query.as_ref().is_none_or(|q| {
|
||||
@@ -169,7 +171,7 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
|
||||
in the file instead of project-wide run configurations.",
|
||||
))
|
||||
.param(Param::optional("query", ParamType::String, "Only configurations whose name, type or command contains it"))
|
||||
.param(crate::mcp::scope::param())
|
||||
.param(crate::mcp::search::paths_param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
@@ -356,6 +358,13 @@ 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) {
|
||||
@@ -367,6 +376,177 @@ 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(
|
||||
@@ -608,6 +788,10 @@ 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();
|
||||
@@ -684,6 +868,40 @@ 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,56 +0,0 @@
|
||||
//! The `scope` argument of the query tools: the directory their results are limited to, a
|
||||
//! folder of the project or a project attached to it.
|
||||
|
||||
use crate::mcp::tool::{Call, Param, ParamType};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub fn param() -> Param {
|
||||
Param::optional(
|
||||
"scope",
|
||||
ParamType::String,
|
||||
"Directory to limit results to: relative to the project root, or absolute",
|
||||
)
|
||||
}
|
||||
|
||||
/// No `scope`: everything.
|
||||
pub struct Scope(Option<PathBuf>);
|
||||
|
||||
impl Scope {
|
||||
pub fn of(call: &Call) -> IdeResult<Self> {
|
||||
let Some(raw) = call.opt_str("scope")?.filter(|s| !s.trim().is_empty()) else { return Ok(Self(None)) };
|
||||
let given = Path::new(raw.trim());
|
||||
let path = crate::mcp::tool::normalize(&if given.is_absolute() {
|
||||
given.to_path_buf()
|
||||
} else {
|
||||
call.root().join(given)
|
||||
});
|
||||
let roots: Vec<PathBuf> =
|
||||
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
|
||||
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
|
||||
if !ide_vfs::content_path_allowed(&path, &roots) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
let path = dunce::canonicalize(&path).unwrap_or(path);
|
||||
if !path.is_dir() {
|
||||
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
|
||||
}
|
||||
if !roots.iter().any(|root| path.starts_with(root)) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
Ok(Self(Some(path)))
|
||||
}
|
||||
|
||||
pub fn dir(&self) -> Option<&Path> {
|
||||
self.0.as_deref()
|
||||
}
|
||||
|
||||
pub fn contains(&self, path: &Path) -> bool {
|
||||
self.0.as_ref().is_none_or(|dir| path.starts_with(dir))
|
||||
}
|
||||
|
||||
/// For a path the tools return: project-relative with `/`, or absolute.
|
||||
pub fn contains_shown(&self, root: &Path, path: &str) -> bool {
|
||||
self.0.is_none() || self.contains(&root.join(path))
|
||||
}
|
||||
}
|
||||
@@ -6,7 +6,6 @@
|
||||
//! the editor (one per character except emoji and other astral characters).
|
||||
|
||||
use crate::mcp::page::{OFFSET, Page};
|
||||
use crate::mcp::scope::{self, Scope};
|
||||
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use crate::mcp::util::{INDEXING_PARTIAL_RESULT_REASON, MEDIUM_TIMEOUT};
|
||||
use crate::ops::search::SearchEvent;
|
||||
@@ -37,8 +36,10 @@ const MIN_UNMASKED_MATCHES: usize = 10_000;
|
||||
/// outside the window of a longer line are left out.
|
||||
const LINE_WINDOW: usize = 500;
|
||||
|
||||
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results. Supports '!' \
|
||||
excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as '**/pattern'. Empty strings are ignored.";
|
||||
const INCLUDE_EXCLUDED_DESCRIPTION: &str = "Whether to include excluded/ignored files in results";
|
||||
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results (absolute ones for a \
|
||||
project attached outside it). Supports '!' excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as \
|
||||
'**/pattern'. Empty strings are ignored.";
|
||||
const LIMIT_DESCRIPTION: &str = "Results to return at most (default 100)";
|
||||
const SYMBOL_LIMIT_DESCRIPTION: &str = "Results to return at most (default 50)";
|
||||
const CONTEXT_DESCRIPTION: &str = "Lines around each match to return besides the matched line (`lineText`): \"+N\" the \
|
||||
@@ -68,8 +69,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|
||||
|call| async move { text_search(call, false).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Text to search for"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(paths_param())
|
||||
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
|
||||
@@ -91,8 +92,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|
||||
|call| async move { text_search(call, true).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Regex pattern to search for"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(paths_param())
|
||||
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
|
||||
@@ -113,8 +114,7 @@ If you don't find a suitable result, try again with include_external=true to sea
|
||||
|call| async move { symbol_search(call).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Symbol query text"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(paths_param())
|
||||
.param(Param::optional(
|
||||
"include_external",
|
||||
ParamType::Boolean,
|
||||
@@ -140,13 +140,8 @@ Paths are optional additional glob filters relative to the project root.",
|
||||
|call| async move { file_search(call).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Glob pattern to search for"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional(
|
||||
"includeExcluded",
|
||||
ParamType::Boolean,
|
||||
"Whether to include excluded/ignored files in results",
|
||||
))
|
||||
.param(paths_param())
|
||||
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
.output(result_schema())
|
||||
@@ -336,22 +331,39 @@ async fn fill_lines(
|
||||
|
||||
// --- path globs ----------------------------------------------------------------
|
||||
|
||||
/// The `paths` argument: project-relative globs, `!` excludes.
|
||||
struct PathScope {
|
||||
/// The `paths` argument every query tool takes.
|
||||
pub(crate) fn paths_param() -> Param {
|
||||
Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION)
|
||||
}
|
||||
|
||||
/// The `paths` argument: project-relative globs (absolute ones in a project attached outside
|
||||
/// the project), `!` excludes. It only narrows: what the project leaves out stays out.
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct PathScope {
|
||||
root: PathBuf,
|
||||
/// `None` when only excludes were given (everything is included).
|
||||
include: Option<GlobSet>,
|
||||
exclude: GlobSet,
|
||||
/// The globs as `FileMask` masks for Find in Files (`{a,b}` expanded, as masks
|
||||
/// split on commas), `None` when they cannot be expressed.
|
||||
masks: Option<(Vec<String>, Vec<String>)>,
|
||||
/// The folders the included globs lie in, `None` when one may match anywhere (`**/a.rs`).
|
||||
roots: Option<Vec<PathBuf>>,
|
||||
}
|
||||
|
||||
impl PathScope {
|
||||
fn new(root: &Path, patterns: &[String]) -> IdeResult<Self> {
|
||||
pub(crate) fn of(call: &Call) -> IdeResult<Self> {
|
||||
Self::new(call.root(), &call.project().content_roots(), &call.str_list("paths")?)
|
||||
}
|
||||
|
||||
/// `attached`: the content roots, whose files outside `root` the globs name by absolute path.
|
||||
fn new(root: &Path, attached: &[PathBuf], patterns: &[String]) -> IdeResult<Self> {
|
||||
let (mut include, mut exclude) = (GlobSetBuilder::new(), GlobSetBuilder::new());
|
||||
let (mut include_masks, mut exclude_masks) = (Vec::new(), Vec::new());
|
||||
let mut roots = Vec::new();
|
||||
let mut has_include = false;
|
||||
let mut maskable = true;
|
||||
let mut anywhere = false;
|
||||
for raw in patterns {
|
||||
let raw = raw.trim();
|
||||
if raw.is_empty() {
|
||||
@@ -362,12 +374,18 @@ impl PathScope {
|
||||
Some(rest) => (true, rest.trim()),
|
||||
None => (false, raw),
|
||||
};
|
||||
let mut glob = normalize_glob(pattern, root)?;
|
||||
let mut glob = normalize_glob(pattern, root, attached)?;
|
||||
// A path naming an existing directory covers the files below it.
|
||||
if index_of_glob_char(&glob).is_none() && root.join(&glob).is_dir() {
|
||||
glob.push_str("/**");
|
||||
}
|
||||
let alternatives = expand_braces(&glob);
|
||||
if !negated {
|
||||
match glob_folder(&glob, root) {
|
||||
Some(folder) => roots.push(folder),
|
||||
None => anywhere = true,
|
||||
}
|
||||
}
|
||||
let alternatives = expand_braces(&engine_mask(&glob, attached));
|
||||
maskable &= alternatives.is_some();
|
||||
let (set, masks) =
|
||||
if negated { (&mut exclude, &mut exclude_masks) } else { (&mut include, &mut include_masks) };
|
||||
@@ -376,27 +394,83 @@ impl PathScope {
|
||||
has_include |= !negated;
|
||||
}
|
||||
let build = |b: GlobSetBuilder| b.build().map_err(|e| IdeError::invalid(format!("Invalid glob pattern: {e}")));
|
||||
// A folder inside another one is walked with it.
|
||||
roots.sort();
|
||||
roots.dedup_by(|inner, outer| inner.starts_with(outer));
|
||||
Ok(Self {
|
||||
root: root.to_path_buf(),
|
||||
include: if has_include { Some(build(include)?) } else { None },
|
||||
exclude: build(exclude)?,
|
||||
masks: maskable.then_some((include_masks, exclude_masks)),
|
||||
roots: (has_include && !anywhere).then_some(roots),
|
||||
})
|
||||
}
|
||||
|
||||
fn is_all(&self) -> bool {
|
||||
pub(crate) fn is_all(&self) -> bool {
|
||||
self.include.is_none() && self.exclude.is_empty()
|
||||
}
|
||||
|
||||
/// `path` is project-relative with `/` (absolute outside the project).
|
||||
fn matches(&self, path: &str) -> bool {
|
||||
pub(crate) fn matches(&self, path: &str) -> bool {
|
||||
self.include.as_ref().is_none_or(|s| s.is_match(path)) && !self.exclude.is_match(path)
|
||||
}
|
||||
|
||||
pub(crate) fn matches_path(&self, path: &Path) -> bool {
|
||||
self.is_all() || self.matches(&shown(&self.root, path))
|
||||
}
|
||||
|
||||
/// Whether `dir` or a file in it is in: a directory something runs in.
|
||||
pub(crate) fn matches_dir(&self, dir: &Path) -> bool {
|
||||
if self.is_all() {
|
||||
return true;
|
||||
}
|
||||
let dir = shown(&self.root, dir);
|
||||
self.matches(&dir) || self.matches(&if dir.is_empty() { "x".into() } else { format!("{dir}/x") })
|
||||
}
|
||||
|
||||
/// The folders to walk instead of the whole project, `None` when a glob may match anywhere.
|
||||
pub(crate) fn roots(&self) -> Option<&[PathBuf]> {
|
||||
self.roots.as_deref()
|
||||
}
|
||||
}
|
||||
|
||||
/// `path` as the tools give it: relative to `root` with `/`, absolute (with `/`) outside it.
|
||||
fn shown(root: &Path, path: &Path) -> String {
|
||||
path.strip_prefix(root).unwrap_or(path).to_string_lossy().replace('\\', "/")
|
||||
}
|
||||
|
||||
/// The folder a normalized glob lies in (the whole segments before its first glob character),
|
||||
/// `None` for one that may match anywhere.
|
||||
fn glob_folder(glob: &str, root: &Path) -> Option<PathBuf> {
|
||||
let end = index_of_glob_char(glob).map_or(glob.len(), |i| glob[..i].rfind('/').unwrap_or(0));
|
||||
let prefix = glob[..end].trim_end_matches('/');
|
||||
if prefix.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let path = root.join(prefix);
|
||||
// A file named by its path lies in its folder.
|
||||
Some(if index_of_glob_char(glob).is_none() && !path.is_dir() { path.parent()?.to_path_buf() } else { path })
|
||||
}
|
||||
|
||||
/// `glob` as Find in Files matches it: a project attached outside the project goes by its
|
||||
/// folder name there (as `search_project` shows its files), not by its absolute path.
|
||||
fn engine_mask(glob: &str, attached: &[PathBuf]) -> String {
|
||||
if is_absolute_pattern(glob) {
|
||||
for root in attached {
|
||||
let shown = root.to_string_lossy().replace('\\', "/");
|
||||
if let Some(rest) = glob.strip_prefix(&shown).filter(|r| r.is_empty() || r.starts_with('/')) {
|
||||
return format!("{}{rest}", root.file_name().unwrap_or_default().to_string_lossy());
|
||||
}
|
||||
}
|
||||
}
|
||||
glob.to_owned()
|
||||
}
|
||||
|
||||
/// A glob as a project-relative pattern: `\` → `/`, leading `./` dropped, `dir/` → `dir/**`,
|
||||
/// `name` → `**/name`, and its leading directories (`..`, absolute paths) resolved against
|
||||
/// `root`. Errors when that points outside the project.
|
||||
fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
|
||||
/// `root`; absolute in a project of `attached` outside it. Errors when that points outside the
|
||||
/// project.
|
||||
fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
|
||||
let mut value = raw.trim().replace('\\', "/");
|
||||
if value.is_empty() {
|
||||
return Err(IdeError::invalid("Glob pattern is empty"));
|
||||
@@ -411,7 +485,7 @@ fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
|
||||
if !value.contains('/') {
|
||||
value = format!("**/{value}");
|
||||
}
|
||||
let value = normalize_path_pattern(&value, root)?;
|
||||
let value = normalize_path_pattern(&value, root, attached)?;
|
||||
if value.is_empty() {
|
||||
return Err(IdeError::invalid(format!("Invalid glob pattern: {raw}")));
|
||||
}
|
||||
@@ -421,7 +495,7 @@ fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
|
||||
/// Resolves the whole directory segments before the first glob character against `root`.
|
||||
/// (JetBrains resolves up to the glob character itself, turning `src/Foo*.java` into
|
||||
/// `src/Foo/*.java`; only whole segments are resolved here.)
|
||||
fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
|
||||
fn normalize_path_pattern(pattern: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
|
||||
let outside = || {
|
||||
IdeError::invalid(format!("Specified path '{pattern}' points to the location outside of the project directory"))
|
||||
};
|
||||
@@ -442,8 +516,16 @@ fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
|
||||
} else {
|
||||
root.join(prefix_path)
|
||||
});
|
||||
let relative = relative_to_root(root, &absolute).ok_or_else(outside)?;
|
||||
let suffix = pattern[prefix_len..].trim_start_matches('/');
|
||||
let Some(relative) = relative_to_root(root, &absolute) else {
|
||||
// A project attached outside the project goes by its absolute path, as its files do.
|
||||
let absolute = dunce::canonicalize(&absolute).unwrap_or(absolute);
|
||||
if !attached.iter().any(|r| absolute.starts_with(r)) {
|
||||
return Err(outside());
|
||||
}
|
||||
let absolute = absolute.to_string_lossy().replace('\\', "/");
|
||||
return Ok(if suffix.is_empty() { absolute } else { format!("{absolute}/{suffix}") });
|
||||
};
|
||||
Ok(match (relative.is_empty(), suffix.is_empty()) {
|
||||
(true, _) => suffix.to_owned(),
|
||||
(false, true) => relative,
|
||||
@@ -544,8 +626,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
let pattern = query(&call, if is_regex { "Regex pattern is empty" } else { "Search text is empty" })?;
|
||||
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
|
||||
let around = context(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
let scope = PathScope::of(&call)?;
|
||||
// Globs Find in Files cannot take are applied afterwards, so the engine must not
|
||||
// stop at `limit` matches the filter may drop.
|
||||
let (masks, max_matches) = match scope.masks.clone() {
|
||||
@@ -565,22 +646,18 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
whole_word: false,
|
||||
include,
|
||||
exclude,
|
||||
// Only `scope` is walked.
|
||||
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
|
||||
scope: SearchScope::Project,
|
||||
max_matches,
|
||||
context: Default::default(),
|
||||
include_excluded: call.flag("includeExcluded", false)?,
|
||||
};
|
||||
if is_regex && let Err(e) = ide_search::match_ranges("", &query) {
|
||||
return Err(IdeError::invalid(format!("Invalid regex pattern: {pattern} ({})", e.message)));
|
||||
}
|
||||
let (files, summary, timed_out) = run_search(&call, query.clone()).await?;
|
||||
// Content roots outside the project are reported by absolute path.
|
||||
let mut files: Vec<(String, FileMatches)> = files
|
||||
.into_iter()
|
||||
.filter(|f| dir.contains(&f.path.0))
|
||||
.map(|f| (call.display(&f.path.0), f))
|
||||
.filter(|(path, _)| scope.matches(path))
|
||||
.collect();
|
||||
let mut files: Vec<(String, FileMatches)> =
|
||||
files.into_iter().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
|
||||
files.sort_by(|a, b| a.0.cmp(&b.0));
|
||||
// Only these can match a line break.
|
||||
let may_span = is_regex || pattern.contains('\n');
|
||||
@@ -750,27 +827,35 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
|
||||
async fn file_search(call: Call) -> IdeResult<Output> {
|
||||
let q = query(&call, "Glob pattern is empty")?;
|
||||
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
let scope = PathScope::of(&call)?;
|
||||
let include_excluded = call.flag("includeExcluded", false)?;
|
||||
let glob = GlobSetBuilder::new()
|
||||
.add(build_glob(&normalize_glob(&q, call.root())?)?)
|
||||
.add(build_glob(&normalize_glob(&q, call.root(), &[])?)?)
|
||||
.build()
|
||||
.map_err(|_| IdeError::invalid(format!("Invalid glob pattern: {q}")))?;
|
||||
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
|
||||
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
|
||||
let root = call.root().to_path_buf();
|
||||
// `scope`, or the project folder and the content roots its walk does not cover: those
|
||||
// outside it and those inside it that it skips as ignored.
|
||||
let roots: Vec<PathBuf> = match dir.dir() {
|
||||
Some(dir) => vec![dir.to_path_buf()],
|
||||
let content = call.project().content_roots();
|
||||
// Where a folder's exclusions are matched from: the content root holding it, or the project.
|
||||
let base_of =
|
||||
|dir: &Path| content.iter().filter(|r| dir.starts_with(r)).max_by_key(|r| r.components().count()).cloned();
|
||||
// The folders of `paths`, or the project folder and the content roots its walk does not
|
||||
// cover: those outside it and those inside it that it skips as ignored.
|
||||
let roots: Vec<(PathBuf, PathBuf)> = match scope.roots() {
|
||||
Some(dirs) => dirs
|
||||
.iter()
|
||||
.filter(|d| d.is_dir())
|
||||
.map(|d| (d.clone(), base_of(d).unwrap_or_else(|| root.clone())))
|
||||
.collect(),
|
||||
None => std::iter::once(root.clone())
|
||||
.chain(
|
||||
call.project()
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
|
||||
content
|
||||
.iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r))
|
||||
.cloned(),
|
||||
)
|
||||
.map(|r| (r.clone(), r))
|
||||
.collect(),
|
||||
};
|
||||
let host = call.host();
|
||||
@@ -790,7 +875,7 @@ async fn file_search(call: Call) -> IdeResult<Output> {
|
||||
let (paths, more, timed_out) = host
|
||||
.blocking(move || {
|
||||
let mut found = Vec::new();
|
||||
let more = roots.iter().any(|base| walk.dir(base, base, &mut found));
|
||||
let more = roots.iter().any(|(dir, base)| walk.dir(dir, base, &mut found));
|
||||
if walk.cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
@@ -877,23 +962,23 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let q = query(&call, "Search query is empty")?;
|
||||
let (page, limit) = page(&call, SYMBOL_SEARCH_DEFAULT_LIMIT)?;
|
||||
let around = context(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
let scope = PathScope::of(&call)?;
|
||||
let external = call.flag("include_external", false)?;
|
||||
let host = call.host();
|
||||
let project = call.project().clone();
|
||||
let indexing_before = project.index.status().indexing;
|
||||
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
|
||||
let found = {
|
||||
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
|
||||
let (project, q, within) = (project.clone(), q.clone(), scope.clone());
|
||||
host.blocking(move || {
|
||||
Ok(match dir {
|
||||
Ok(if within.is_all() {
|
||||
project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool)
|
||||
} else {
|
||||
// Filtered in the index: a pool cut before the filter could miss every match.
|
||||
Some(dir) => project
|
||||
project
|
||||
.index
|
||||
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
|
||||
.unwrap_or_default(),
|
||||
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
|
||||
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| within.matches_path(p), &|| false)
|
||||
.unwrap_or_default()
|
||||
})
|
||||
})
|
||||
.await?
|
||||
@@ -902,7 +987,6 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
.into_iter()
|
||||
// By the path the other tools give: the index shows a root outside the project by its
|
||||
// folder name, which is no path to read.
|
||||
.filter(|s| dir.contains(&s.path.0))
|
||||
.map(|s| (call.display(&s.path.0), s))
|
||||
.filter(|(path, _)| scope.matches(path))
|
||||
.map(|(path, s)| SearchItem {
|
||||
@@ -920,11 +1004,11 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
roots.extend(crate::mcp::tool::attached_projects(call.root()));
|
||||
for (name, container, location) in symbols {
|
||||
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
|
||||
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
|
||||
// are what was asked for.
|
||||
// Project files (attached projects' too) obey `paths`; library symbols are what was
|
||||
// asked for.
|
||||
let inside = location.uri.is_none()
|
||||
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
|
||||
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
|
||||
if inside && !scope.matches(&path) {
|
||||
continue;
|
||||
}
|
||||
let item = SearchItem {
|
||||
@@ -999,13 +1083,13 @@ mod tests {
|
||||
}
|
||||
|
||||
fn scope(root: &Path, p: &[&str]) -> PathScope {
|
||||
PathScope::new(root, &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
|
||||
PathScope::new(root, &[], &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalizes_globs() {
|
||||
let (_dir, root) = root();
|
||||
let n = |p: &str| normalize_glob(p, &root);
|
||||
let n = |p: &str| normalize_glob(p, &root, &[]);
|
||||
assert_eq!(n("*.rs").unwrap(), "**/*.rs");
|
||||
assert_eq!(n("./foo/bar.txt").unwrap(), "foo/bar.txt");
|
||||
assert_eq!(n("foo/").unwrap(), "foo/**");
|
||||
@@ -1082,9 +1166,33 @@ mod tests {
|
||||
assert!(s.matches("a.rs") && !s.matches("docs/a.md"));
|
||||
assert!(scope(root, &["*.{rs,ts}"]).masks.is_some());
|
||||
assert!(scope(root, &["*.{rs,{ts,js}}"]).masks.is_none());
|
||||
let err = |p: &str| PathScope::new(root, &[p.to_owned()]).err().unwrap().message;
|
||||
let err = |p: &str| PathScope::new(root, &[], &[p.to_owned()]).err().unwrap().message;
|
||||
assert!(err("a[").contains("Invalid glob pattern"));
|
||||
assert!(err("!").contains("Exclude pattern is empty"));
|
||||
assert!(err("../x/**").contains("outside of the project directory"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paths_name_the_folders_to_walk_and_projects_attached_outside() {
|
||||
let (dir, root) = root();
|
||||
let roots = |p: &[&str]| scope(&root, p).roots().map(<[PathBuf]>::to_vec);
|
||||
// Only the folders the globs lie in, a folder inside another one walked with it.
|
||||
assert_eq!(roots(&["subdir1/**", "subdir1/nested/*.rs", "!**/gen/**"]), Some(vec![root.join("subdir1")]));
|
||||
assert_eq!(roots(&["subdir1/nested/x.rs"]), Some(vec![root.join("subdir1/nested")]));
|
||||
// A glob matching anywhere, or none included, means the whole project.
|
||||
assert_eq!(roots(&["subdir1/**", "**/*.rs"]), None);
|
||||
assert_eq!(roots(&["!**/*.md"]), None);
|
||||
|
||||
let attached = dunce::canonicalize(dir.path()).unwrap().join("attached");
|
||||
std::fs::create_dir_all(attached.join("src")).unwrap();
|
||||
let shown = attached.to_string_lossy().replace('\\', "/");
|
||||
let s = PathScope::new(&root, std::slice::from_ref(&attached), &[format!("{shown}/src/**")]).unwrap();
|
||||
assert!(s.matches(&format!("{shown}/src/a.rs")) && !s.matches("src/a.rs"));
|
||||
assert!(s.matches_path(&attached.join("src/a.rs")));
|
||||
assert_eq!(s.roots(), Some(&[attached.join("src")][..]));
|
||||
// Find in Files shows such a project's files under its folder name.
|
||||
assert_eq!(s.masks.unwrap().0, ["attached/src/**"]);
|
||||
let unattached = PathScope::new(&root, &[], &[format!("{shown}/src/**")]);
|
||||
assert!(unattached.err().unwrap().message.contains("outside of the project directory"));
|
||||
}
|
||||
}
|
||||
@@ -214,7 +214,7 @@ pub fn find_references() -> Tool {
|
||||
Tool::new("find_references", "Find references using the language service and the IDE's project index. Positions are 1-based UTF-16. Reports incomplete results when analysis is still running.", |call| async move {
|
||||
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 paths = super::search::PathScope::of(&call)?;
|
||||
let opened = open_at(&call, path).await?;
|
||||
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(|_| {}));
|
||||
@@ -237,8 +237,8 @@ pub fn find_references() -> Tool {
|
||||
if let serde_json::Value::Object(map) = &mut value {
|
||||
let mut list = |key: &str| match map.remove(key) { Some(serde_json::Value::Array(items)) => items, _ => Vec::new() };
|
||||
let (mut locations, mut classified) = (list("locations"), list("classified"));
|
||||
if dir.dir().is_some() {
|
||||
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| dir.contains(std::path::Path::new(p)));
|
||||
if !paths.is_all() {
|
||||
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| paths.matches_path(std::path::Path::new(p)));
|
||||
locations.retain(inside);
|
||||
classified.retain(|c| inside(&c["location"]));
|
||||
}
|
||||
@@ -253,7 +253,7 @@ pub fn find_references() -> Tool {
|
||||
.param(Param::required("line", ParamType::Integer, "1-based line"))
|
||||
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
|
||||
.param(Param::optional("includeDeclaration", ParamType::Boolean, "Include declarations (default true)"))
|
||||
.param(super::scope::param())
|
||||
.param(super::search::paths_param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "References to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
|
||||
}
|
||||
@@ -336,7 +336,7 @@ pub fn get_call_hierarchy() -> Tool {
|
||||
.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(super::search::paths_param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
|
||||
}
|
||||
@@ -354,7 +354,7 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
|
||||
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 paths = super::search::PathScope::of(&call)?;
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let opened = open_at(&call, path).await?;
|
||||
let hierarchy_at = |pos| {
|
||||
@@ -378,8 +378,8 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
|
||||
}
|
||||
result => result?,
|
||||
};
|
||||
if scope.dir().is_some() {
|
||||
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
|
||||
if !paths.is_all() {
|
||||
found.items.retain(|i| i.uri.is_none() && paths.matches_path(&i.path.0));
|
||||
}
|
||||
let incomplete = found.incomplete;
|
||||
let (mut root, items) = call_items(found, |p| call.display(p));
|
||||
|
||||
@@ -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. Optional when only one project is open." }
|
||||
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
|
||||
}, "required": [] }),
|
||||
},
|
||||
handler: Arc::new(move |call| Box::pin(handler(call))),
|
||||
|
||||
@@ -266,33 +266,39 @@ By default all Git repositories are returned.",
|
||||
.map(|r| (r.root.into_path_buf(), r.head))
|
||||
.collect();
|
||||
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
|
||||
let scope = super::scope::Scope::of(&call)?;
|
||||
let paths = super::search::PathScope::of(&call)?;
|
||||
let git = git_executable(&call);
|
||||
// A repository asked for, or the one holding `scope`.
|
||||
let target = match &wanted {
|
||||
Some(wanted) => Some(call.resolve_inside(wanted)?),
|
||||
None => scope.dir().map(Path::to_path_buf),
|
||||
// The repository asked for, or those holding the folders of `paths`.
|
||||
let targets: Vec<PathBuf> = match &wanted {
|
||||
Some(wanted) => vec![call.resolve_inside(wanted)?],
|
||||
None => paths.roots().map(<[PathBuf]>::to_vec).unwrap_or_default(),
|
||||
};
|
||||
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
|
||||
None => repos,
|
||||
Some(path) => {
|
||||
let mut roots: Vec<(PathBuf, Option<String>)> = if targets.is_empty() {
|
||||
repos
|
||||
} else {
|
||||
let mut picked: Vec<(PathBuf, Option<String>)> = Vec::new();
|
||||
for path in targets {
|
||||
// The innermost repository containing the path.
|
||||
match innermost_repo(repos, &path) {
|
||||
Some(repo) => vec![repo],
|
||||
let repo = match innermost_repo(repos.clone(), &path) {
|
||||
Some(repo) => repo,
|
||||
None => match find_git_root(call.root(), &path) {
|
||||
Some(root) => {
|
||||
// JetBrains reads the branch of any repository it reports.
|
||||
let (git, dir) = (git.clone(), root.clone());
|
||||
let branch = host.blocking(move || Ok(read_branch(&git, &dir))).await?;
|
||||
vec![(root, branch)]
|
||||
(root, branch)
|
||||
}
|
||||
None => {
|
||||
let shown = wanted.unwrap_or_else(|| call.display(&path));
|
||||
let shown = wanted.clone().unwrap_or_else(|| call.display(&path));
|
||||
return Err(IdeError::not_found(format!("No git repository found for path: {shown}")));
|
||||
}
|
||||
},
|
||||
};
|
||||
if !picked.iter().any(|p| p.0 == repo.0) {
|
||||
picked.push(repo);
|
||||
}
|
||||
}
|
||||
picked
|
||||
};
|
||||
roots.sort_by_key(|r| relative_to_project(&call, &r.0));
|
||||
let mut repositories = Vec::new();
|
||||
@@ -305,7 +311,7 @@ By default all Git repositories are returned.",
|
||||
.map_err(|e| {
|
||||
IdeError::internal(format!("Failed to get git status for repository '{rel}': {}", e.message))
|
||||
})?;
|
||||
entries.retain(|e| scope.contains(&root.join(e.path.trim_end_matches('/'))));
|
||||
entries.retain(|e| paths.matches_path(&root.join(e.path.trim_end_matches('/'))));
|
||||
let count = |f: fn(&StatusEntry) -> bool| entries.iter().filter(|e| f(e)).count();
|
||||
let listed: Vec<Value> = entries
|
||||
.iter()
|
||||
@@ -352,7 +358,7 @@ By default all Git repositories are returned.",
|
||||
))
|
||||
.param(Param::optional("includeUntracked", ParamType::Boolean, "Whether to include untracked files"))
|
||||
.param(Param::optional("includeIgnored", ParamType::Boolean, "Whether to include ignored files"))
|
||||
.param(super::scope::param())
|
||||
.param(super::search::paths_param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
|
||||
@@ -369,10 +369,21 @@ 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) -> IdeResult<Vec<AgentChange>> {
|
||||
pub async fn agent_changes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
view: Option<AgentChangesView>,
|
||||
) -> IdeResult<Vec<AgentChange>> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.changes(&task).await
|
||||
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,
|
||||
}
|
||||
}
|
||||
|
||||
/// The task's uncommitted changes and the commits made since it started.
|
||||
@@ -382,11 +393,17 @@ pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> I
|
||||
host.project(window)?.agents.grouped_changes(&task).await
|
||||
}
|
||||
|
||||
/// Content of `path` when the task started (left side of its diff).
|
||||
/// Content of `path` as `view` compares it (without: when the task started), the left side of its diff.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
|
||||
pub async fn agent_base_text(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
path: IpcPath,
|
||||
view: Option<AgentChangesView>,
|
||||
) -> IdeResult<Option<String>> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
|
||||
host.project(window)?.agents.base_text(&task, path.into_path_buf(), view.unwrap_or_default()).await
|
||||
}
|
||||
|
||||
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
|
||||
|
||||
@@ -139,6 +139,32 @@ 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>`.
|
||||
@@ -478,10 +504,12 @@ 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,
|
||||
|
||||
@@ -70,6 +70,18 @@ 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)?;
|
||||
@@ -109,6 +121,7 @@ ide_command::domain!(
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_save,
|
||||
doc_autosave,
|
||||
doc_save_all,
|
||||
doc_save_as,
|
||||
doc_snapshot,
|
||||
|
||||
@@ -3,6 +3,7 @@ use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult, RequestId};
|
||||
use ide_vfs::FileEntry;
|
||||
use ide_workspace::DeletionUndo;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[command(trust = always)]
|
||||
@@ -163,14 +164,27 @@ pub fn fs_set_writable(host: &Host, window: &str, path: PathBuf, writable: bool)
|
||||
/// Moving to the trash can take a while (large trees): kept off the main thread.
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
// Local History keeps the contents so deleted files can be restored.
|
||||
let project = host.project(window).ok();
|
||||
let history = project.as_ref().map(|p| p.history.clone());
|
||||
delete_with_history(host, window, path, false).await.map(|_| ())
|
||||
}
|
||||
|
||||
/// Moves an item to the Trash and returns the snapshot for Project View Undo.
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_delete_with_undo(host: &Host, window: &str, path: PathBuf) -> IdeResult<DeletionUndo> {
|
||||
delete_with_history(host, window, path, true).await
|
||||
}
|
||||
|
||||
async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable: bool) -> IdeResult<DeletionUndo> {
|
||||
let project = if undoable { Some(host.project(window)?) } else { host.project(window).ok() };
|
||||
host.blocking(move || {
|
||||
let paths = ide_workspace::file_ops::deletion_paths(&path)?;
|
||||
if let Some(h) = history {
|
||||
for p in &paths {
|
||||
h.record_deletion(p, DELETE_SNAPSHOT_LIMIT);
|
||||
let mut undo = DeletionUndo::default();
|
||||
if let Some(p) = &project {
|
||||
if undoable {
|
||||
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
|
||||
} else {
|
||||
for pth in &paths {
|
||||
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
|
||||
}
|
||||
}
|
||||
}
|
||||
ide_workspace::file_ops::delete(&path)?;
|
||||
@@ -178,11 +192,17 @@ pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()
|
||||
if let Some(p) = project {
|
||||
let _ = p.with_backend_of(&path, |r| r.files_deleted(&paths));
|
||||
}
|
||||
Ok(())
|
||||
Ok(undo)
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_undo_delete(host: &Host, window: &str, undo: DeletionUndo) -> IdeResult<Vec<ide_core::IpcPath>> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || Ok(project.history.restore_deletion_undo(undo))).await
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
let project = host.project(window).ok();
|
||||
@@ -280,9 +300,11 @@ ide_command::domain!(
|
||||
fs_create_file,
|
||||
fs_create_file_bytes,
|
||||
fs_delete,
|
||||
fs_delete_with_undo,
|
||||
fs_entry_kind,
|
||||
fs_read_dir,
|
||||
fs_read_text,
|
||||
fs_rename,
|
||||
fs_set_writable,
|
||||
fs_undo_delete,
|
||||
);
|
||||
@@ -311,6 +311,11 @@ async fn shutdown_does_not_wait_forever_for_a_stuck_capture() {
|
||||
shutdown_within(&f.host, std::time::Duration::from_millis(200)).await;
|
||||
assert!(started.elapsed() < std::time::Duration::from_secs(5));
|
||||
assert!(cancel.is_cancelled());
|
||||
// The cleanup is only waited for briefly and finishes in the background on a busy machine.
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
while stuck_dir.exists() && std::time::Instant::now() < deadline {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
|
||||
}
|
||||
assert!(!stuck_dir.exists(), "its directory is removed once the wait is over");
|
||||
}
|
||||
|
||||
|
||||
@@ -34,7 +34,7 @@ pub async fn java_resolve_launch(
|
||||
result
|
||||
}
|
||||
|
||||
async fn resolve_launch(
|
||||
pub(crate) async fn resolve_launch(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
module: PathBuf,
|
||||
|
||||
@@ -359,10 +359,22 @@ pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: Got
|
||||
if kind != GotoKind::Definition {
|
||||
return result;
|
||||
}
|
||||
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else { 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 found = plugin_call(move || plugins.provide_definition(&d, pos)).await.unwrap_or_default();
|
||||
let found: Vec<Location> =
|
||||
found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }).collect();
|
||||
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 in_string = !found.is_empty() && in_string_literal(host, window, doc, pos).await;
|
||||
definition_targets(result, found, in_string)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,154 @@
|
||||
//! ⌘B on a Maven resource-filtering placeholder: `@property@` in a YAML or properties
|
||||
//! resource (Spring's `application.yml` / `application.properties`) jumps to the `<properties>` entry that defines it,
|
||||
//! in the nearest `pom.xml` above the file, up through the project root. Parent
|
||||
//! poms the nearest pom declares itself are followed from there; a parent outside
|
||||
//! that walk that no pom declares is not.
|
||||
|
||||
use super::doc::blocking;
|
||||
use crate::Host;
|
||||
use ide_build::maven;
|
||||
use ide_core::{DocId, Location, Pos};
|
||||
use std::path::Path;
|
||||
|
||||
/// The definition location of the placeholder under `pos` in `doc`, when `doc` is a
|
||||
/// YAML or properties file holding a `@token@` there and a pom above it defines that property.
|
||||
pub(crate) async fn definition(host: &Host, window: &str, doc: DocId, pos: Pos) -> Option<Location> {
|
||||
let project = host.project(window).ok()?;
|
||||
blocking(move || {
|
||||
let snap = project.documents.text_snapshot(doc)?;
|
||||
if snap.large || !matches!(snap.language.as_str(), "yaml" | "properties") {
|
||||
return Ok(None);
|
||||
}
|
||||
let path = project.documents.identity(doc)?.0;
|
||||
let Some((name, _token_at)) = placeholder_at(&snap.text, pos) else { return Ok(None) };
|
||||
Ok(pom_defining(&project.root, &path, &name))
|
||||
})
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
}
|
||||
|
||||
/// The `@token@` enclosing `pos` on its line, with the token's range (UTF-16 columns).
|
||||
fn placeholder_at(text: &str, pos: Pos) -> Option<(String, ide_core::Range)> {
|
||||
let line = text.split_inclusive('\n').nth(pos.line as usize)?;
|
||||
let line = line.trim_end_matches(['\n', '\r']);
|
||||
let cursor = utf16_to_byte(line, pos.col)?;
|
||||
let mut opener: Option<usize> = None;
|
||||
for (i, b) in line.as_bytes().iter().enumerate() {
|
||||
if *b != b'@' {
|
||||
continue;
|
||||
}
|
||||
if let Some(start) = opener.replace(i) {
|
||||
let token = &line[start + 1..i];
|
||||
let valid =
|
||||
!token.is_empty() && token.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'));
|
||||
if valid && start <= cursor && cursor <= i {
|
||||
let col = |byte: usize| line[..byte].encode_utf16().count() as u32;
|
||||
return Some((
|
||||
token.to_owned(),
|
||||
ide_core::Range::new(Pos::new(pos.line, col(start)), Pos::new(pos.line, col(i + 1))),
|
||||
));
|
||||
}
|
||||
opener = None;
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The nearest `pom.xml` above `from` (up to and including `root`) defining `name`.
|
||||
fn pom_defining(root: &Path, from: &Path, name: &str) -> Option<Location> {
|
||||
let mut dir = from.parent()?.to_path_buf();
|
||||
loop {
|
||||
let pom = dir.join("pom.xml");
|
||||
if pom.is_file()
|
||||
&& let Some(found) = maven::property_declaration(&pom, name, maven::default_local_repo())
|
||||
{
|
||||
return Some(Location::file(found.path, found.range));
|
||||
}
|
||||
if dir == root || !dir.starts_with(root) {
|
||||
return None;
|
||||
}
|
||||
dir = dir.parent()?.to_path_buf();
|
||||
}
|
||||
}
|
||||
|
||||
/// UTF-16 column → byte offset within one line.
|
||||
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
|
||||
let col = col as usize;
|
||||
let mut units = 0usize;
|
||||
for (byte, c) in line.char_indices() {
|
||||
if units == col {
|
||||
return Some(byte);
|
||||
}
|
||||
units += c.len_utf16();
|
||||
if units > col {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
(units == col).then_some(line.len())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::Pos;
|
||||
|
||||
fn at(line: u32, col: u32) -> Pos {
|
||||
Pos::new(line, col)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finds_the_placeholder_under_the_cursor_and_its_range() {
|
||||
let text = "spring:\n profiles:\n active: @profileActive@\n";
|
||||
let (name, range) = placeholder_at(text, at(2, 20)).unwrap();
|
||||
assert_eq!(name, "profileActive");
|
||||
assert_eq!(range.start, at(2, 12));
|
||||
assert_eq!(range.end, at(2, 27));
|
||||
// The `@`s themselves and inside the token navigate; just past the token does not.
|
||||
for col in [12u32, 13, 26] {
|
||||
assert_eq!(placeholder_at(text, at(2, col)).unwrap().0, "profileActive");
|
||||
}
|
||||
// A second pair on the line and unrelated cursors stay unresolved.
|
||||
let multi = "a: @one@ @two@\n";
|
||||
assert_eq!(placeholder_at(multi, at(0, 4)).unwrap().0, "one");
|
||||
assert_eq!(placeholder_at(multi, at(0, 10)).unwrap().0, "two");
|
||||
assert!(placeholder_at(multi, at(0, 8)).is_none(), "between the pairs");
|
||||
assert!(placeholder_at(multi, at(0, 9)).is_some(), "the opening @ of the next pair");
|
||||
assert!(placeholder_at(multi, at(0, 14)).is_none(), "just past the last pair");
|
||||
assert!(placeholder_at("value: plain\n", at(0, 7)).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_nearest_pom_wins_and_the_walk_stops_at_the_project_root() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
let deep = root.join("core/src/main/resources");
|
||||
std::fs::create_dir_all(&deep).unwrap();
|
||||
std::fs::write(
|
||||
root.join("pom.xml"),
|
||||
"<project>\n <properties>\n <parentName>parent</parentName>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::create_dir_all(root.join("core")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("core/pom.xml"),
|
||||
"<project>\n <properties>\n <name>module</name>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
let from = deep.join("application.yml");
|
||||
// The module pom defines `name` first: its file wins, pointing at its `<name>` entry.
|
||||
let found = pom_defining(&root, &from, "name").unwrap();
|
||||
assert_eq!(found.path, root.join("core/pom.xml"));
|
||||
assert_eq!(found.range.start.line, 2);
|
||||
// A property only the parent defines resolves there; unknown ones resolve nowhere.
|
||||
let parent = pom_defining(&root, &from, "parentName").unwrap();
|
||||
assert_eq!(parent.path, root.join("pom.xml"));
|
||||
assert_eq!(parent.range.start.line, 2);
|
||||
assert!(pom_defining(&root, &from, "missing").is_none());
|
||||
// A file outside the project root has no pom walk.
|
||||
let outside = tmp.path().join("elsewhere/application.yml");
|
||||
std::fs::create_dir_all(tmp.path().join("elsewhere")).unwrap();
|
||||
assert!(pom_defining(&root, &outside, "name").is_none());
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,7 @@ 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;
|
||||
|
||||
@@ -68,6 +68,31 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
|
||||
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
|
||||
}
|
||||
|
||||
/// The files of a custom scope (`file:src//*.ts`), for the Project view's scope panes.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ScopeFiles {
|
||||
pub paths: Vec<IpcPath>,
|
||||
/// More files than `limit` matched; `paths` holds the first ones.
|
||||
pub truncated: bool,
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn scope_files(host: &Host, window: &str, pattern: String, limit: u32) -> IdeResult<ScopeFiles> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
let mask = ide_search::FileMask::new(&[], &project.search_excludes())?;
|
||||
let scope = ide_search::SearchScope::Pattern { pattern };
|
||||
let mut files =
|
||||
ide_search::scope_files(&project.root, &scope, &mask, None, &ide_core::CancellationToken::new())?;
|
||||
files.sort_by(|a, b| a.rel_path.cmp(&b.rel_path));
|
||||
let truncated = files.len() > limit as usize;
|
||||
files.truncate(limit as usize);
|
||||
Ok(ScopeFiles { paths: files.into_iter().map(|f| f.path.into()).collect(), truncated })
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Folders holding indexed files, for `@` references.
|
||||
#[command(trust = always)]
|
||||
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
@@ -375,6 +400,7 @@ ide_command::domain!(
|
||||
path_completions,
|
||||
recent_files,
|
||||
remove_recent,
|
||||
scope_files,
|
||||
web_goto,
|
||||
web_unresolved_references,
|
||||
);
|
||||
@@ -302,6 +302,15 @@ pub fn set_settings(
|
||||
}
|
||||
});
|
||||
}
|
||||
// Directory Mappings change which repositories the project has.
|
||||
if key == "vcs" || key == "vcs.mappings" || key.starts_with("vcs.mappings.") {
|
||||
let affected = affected();
|
||||
host.runtime.spawn_blocking(move || {
|
||||
for project in affected {
|
||||
project.refresh_repositories();
|
||||
}
|
||||
});
|
||||
}
|
||||
if key == "ssh" || key.starts_with("ssh.") {
|
||||
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
|
||||
}
|
||||
|
||||
@@ -34,9 +34,9 @@ pub struct ProjectInterpreter {
|
||||
}
|
||||
|
||||
/// Installed interpreters / toolchains of `kind`; project-local ones first.
|
||||
#[command(trust = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
|
||||
host.require_trust(window)?;
|
||||
host.require_trust_if_project(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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeResult<Vec<ProjectInterpreter>> {
|
||||
// Newest first. The open project is skipped: `sdk_detect` lists its own.
|
||||
host.require_trust(window)?;
|
||||
host.require_trust_if_project(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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<Sdk>> {
|
||||
host.require_trust(window)?;
|
||||
host.require_trust_if_project(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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
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(window)?;
|
||||
host.require_trust_if_project(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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
pub async fn sdk_python_packages(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
python: PathBuf,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<PythonPackage>> {
|
||||
host.require_trust(window)?;
|
||||
host.require_trust_if_project(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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
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(window)?;
|
||||
host.require_trust_if_project(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 || {
|
||||
|
||||
@@ -34,8 +34,10 @@ pub async fn search_start(
|
||||
) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
// Excluded roots (Project Structure marks and detected `target`, `node_modules`, …) and
|
||||
// ignored names are never searched.
|
||||
query.exclude.extend(project.search_excludes());
|
||||
// ignored names are not searched, unless the query asks for them.
|
||||
if !query.include_excluded {
|
||||
query.exclude.extend(project.search_excludes());
|
||||
}
|
||||
let cancel = host.begin_request(request);
|
||||
let events = on_event.clone();
|
||||
let syntax = host.syntax();
|
||||
@@ -80,10 +82,15 @@ pub(crate) fn search_project(
|
||||
query.scope,
|
||||
ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. }
|
||||
));
|
||||
let content_roots = match query.scope {
|
||||
let content_roots: Vec<std::path::PathBuf> = match query.scope {
|
||||
ide_search::SearchScope::Project
|
||||
| ide_search::SearchScope::FileSet { .. }
|
||||
| ide_search::SearchScope::Pattern { .. } => project.content_roots(),
|
||||
| ide_search::SearchScope::Pattern { .. } => project
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
// Kept out of the root's walk only by its ignore rules, which this search does not apply.
|
||||
.filter(|r| !(query.include_excluded && include_root && r.starts_with(root)))
|
||||
.collect(),
|
||||
_ => within.into_iter().collect(),
|
||||
};
|
||||
let filter = |rel: &str| match set {
|
||||
@@ -144,7 +151,7 @@ pub(crate) fn search_project(
|
||||
/// Project-relative `masks` (each a comma-separated list) for a search from the content root
|
||||
/// shown as `prefix`: paths below it lose the prefix, other paths can match nothing there and
|
||||
/// are dropped, names and `**/` patterns (`*.rs`, `**/build/**`) stay as they are.
|
||||
fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
|
||||
pub(crate) fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
|
||||
let prefix = format!("{}/", prefix.trim_end_matches('/'));
|
||||
masks
|
||||
.iter()
|
||||
|
||||
@@ -15,6 +15,9 @@ 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 {
|
||||
@@ -27,7 +30,7 @@ impl ReplaceHost for DocumentsHost<'_> {
|
||||
continue;
|
||||
}
|
||||
docs.apply_edits(doc, &edits)?;
|
||||
if transient {
|
||||
if save {
|
||||
docs.save(doc)?;
|
||||
}
|
||||
return Ok(edits.len() as u32);
|
||||
@@ -46,8 +49,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; files that were not
|
||||
/// open are opened transiently, saved and closed.
|
||||
/// 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,
|
||||
|
||||
@@ -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(window)?;
|
||||
host.require_trust_if_project(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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
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 = trusted)]
|
||||
#[command(trust = outside_restricted)]
|
||||
pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResult<ToolInfo> {
|
||||
let tools = tools(host, window)?;
|
||||
let langs = languages(host, window);
|
||||
|
||||
@@ -18,6 +18,7 @@ pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>>
|
||||
}
|
||||
for r in repos.all() {
|
||||
r.set_ignored_names(settings.ignored_names());
|
||||
r.set_cli_status(settings.vcs.git.cli_status);
|
||||
}
|
||||
repos.status()
|
||||
})
|
||||
@@ -40,6 +41,7 @@ pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::P
|
||||
}
|
||||
for r in repos.all() {
|
||||
r.set_ignored_names(settings.ignored_names());
|
||||
r.set_cli_status(settings.vcs.git.cli_status);
|
||||
}
|
||||
repos.status_paths(&paths)
|
||||
})
|
||||
|
||||
@@ -338,6 +338,13 @@ fn keep_private(root: &Path) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Directory Mappings: the repository roots detection finds, before any are excluded or added.
|
||||
#[command(trust = always)]
|
||||
pub async fn vcs_detected_roots(host: &Host, window: &str) -> IdeResult<Vec<PathBuf>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.detected_repository_roots()).await
|
||||
}
|
||||
|
||||
/// The project's repositories, the primary one first.
|
||||
#[command(trust = always)]
|
||||
pub fn vcs_roots(host: &Host, window: &str) -> IdeResult<Vec<VcsRoot>> {
|
||||
@@ -1061,6 +1068,22 @@ pub async fn vcs_config_get(
|
||||
blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.config_get(&key))).await
|
||||
}
|
||||
|
||||
/// Git User Name Is Not Defined: sets `user.name` / `user.email` for commits in the
|
||||
/// repository, or globally.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn vcs_set_user_identity(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
repo: Option<PathBuf>,
|
||||
name: String,
|
||||
email: String,
|
||||
global: bool,
|
||||
) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.with_repo_at(repo.as_deref(), |r| r.set_user_identity(&name, &email, global))).await
|
||||
}
|
||||
|
||||
/// Local history operation that may take a while (hooks, large checkouts); git's
|
||||
/// output streams through `on_output`. Cancellable.
|
||||
#[command(trust = trusted)]
|
||||
@@ -1569,6 +1592,7 @@ ide_command::domain!(
|
||||
vcs_compare_paths,
|
||||
vcs_compare_scope,
|
||||
vcs_config_get,
|
||||
vcs_set_user_identity,
|
||||
vcs_conflict_versions,
|
||||
vcs_create_branch,
|
||||
vcs_create_patch,
|
||||
@@ -1616,6 +1640,7 @@ ide_command::domain!(
|
||||
vcs_revision_files,
|
||||
vcs_reword,
|
||||
vcs_roots,
|
||||
vcs_detected_roots,
|
||||
vcs_shelf_delete,
|
||||
vcs_shelf_diff,
|
||||
vcs_shelf_import,
|
||||
|
||||
@@ -47,12 +47,19 @@ 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).
|
||||
/// 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.
|
||||
#[command(trust = always)]
|
||||
pub async fn web_url(host: &Host, window: &str, path: IpcPath) -> IdeResult<String> {
|
||||
// Under the window's project when it holds the file.
|
||||
let root = host.project(window).ok().map(|p| p.root.clone());
|
||||
host.web.url_for(root.as_deref(), &path).await
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -568,6 +568,8 @@ pub(super) struct Shared {
|
||||
/// (plugin, item id) → item, for windows opened later.
|
||||
output: Mutex<BTreeMap<(String, String), String>>,
|
||||
decorations: Mutex<BTreeMap<String, Vec<super::DecorationSet>>>,
|
||||
/// plugin → its console highlight rules, in order.
|
||||
console_rules: Mutex<BTreeMap<String, Vec<ide_plugin::ConsoleRule>>>,
|
||||
status: Mutex<BTreeMap<(String, String), StatusItem>>,
|
||||
setting_snapshots: Mutex<SettingSnapshots>,
|
||||
window_status: Mutex<BTreeMap<(String, String, String), StatusItem>>,
|
||||
@@ -648,6 +650,7 @@ impl Shared {
|
||||
status: Mutex::default(),
|
||||
output: Mutex::default(),
|
||||
decorations: Mutex::default(),
|
||||
console_rules: Mutex::default(),
|
||||
window_status: Mutex::default(),
|
||||
setting_snapshots: Mutex::default(),
|
||||
contexts: Mutex::default(),
|
||||
@@ -874,6 +877,9 @@ impl Shared {
|
||||
if self.decorations.lock().remove(plugin).is_some() {
|
||||
self.sink.emit(None, PluginEvent::DecorationsChanged { plugin_id: plugin.into(), sets: Vec::new() });
|
||||
}
|
||||
if self.console_rules.lock().remove(plugin).is_some() {
|
||||
self.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: plugin.into(), rules: Vec::new() });
|
||||
}
|
||||
self.withdraw_prompts(plugin);
|
||||
self.net_prompts.lock().remove(plugin);
|
||||
self.session_net_hosts.lock().remove(plugin);
|
||||
@@ -1706,6 +1712,18 @@ impl HostApi for PluginApi {
|
||||
fn file_icon_decorations(&self, set: &str, items: Vec<(PathBuf, String)>) -> Result<(), HostError> {
|
||||
self.set_file_icon_decorations(set, items)
|
||||
}
|
||||
fn console_rules(&self, rules: Vec<ide_plugin::ConsoleRule>) -> Result<(), HostError> {
|
||||
let rules = super::console_rules::normalize(rules).map_err(HostError::Invalid)?;
|
||||
let mut all = self.shared.console_rules.lock();
|
||||
if rules.is_empty() {
|
||||
all.remove(self.id());
|
||||
} else {
|
||||
all.insert(self.id().into(), rules.clone());
|
||||
}
|
||||
// Emitted under the lock so replacements cannot arrive out of order.
|
||||
self.shared.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: self.id().into(), rules });
|
||||
Ok(())
|
||||
}
|
||||
fn vcs_log(
|
||||
&self,
|
||||
root: &Path,
|
||||
@@ -3276,6 +3294,7 @@ impl PluginWorkspace for HostWorkspace {
|
||||
scope: ide_search::SearchScope::Project,
|
||||
max_matches: limit.min(10_000).saturating_add(1),
|
||||
context: Default::default(),
|
||||
include_excluded: false,
|
||||
};
|
||||
query.exclude.extend(project.search_excludes());
|
||||
let files = Mutex::new(Vec::new());
|
||||
@@ -4441,6 +4460,9 @@ impl Shared {
|
||||
pub(super) fn decoration_sets(&self) -> BTreeMap<String, Vec<super::DecorationSet>> {
|
||||
self.decorations.lock().clone()
|
||||
}
|
||||
pub(super) fn console_rules(&self) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
|
||||
self.console_rules.lock().clone()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -4612,6 +4634,34 @@ mod workbench_tests {
|
||||
assert!(api.shared.decoration_sets().is_empty());
|
||||
}
|
||||
#[test]
|
||||
fn console_rules_replace_keep_the_last_valid_list_and_go_with_the_plugin() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let api = api(dir.path(), false, None);
|
||||
let rule = |pattern: &str| ide_plugin::ConsoleRule {
|
||||
pattern: pattern.into(),
|
||||
ignore_case: false,
|
||||
foreground: Some("bright-yellow".into()),
|
||||
background: Some("navy".into()),
|
||||
styles: vec!["bold".into()],
|
||||
whole_line: true,
|
||||
enabled: true,
|
||||
};
|
||||
// No capability, and no trusted project, is needed: the rules read nothing.
|
||||
api.console_rules(vec![rule(r"\[AUDIT\]"), rule(r"JOB-\d+")]).unwrap();
|
||||
let rules = &api.shared.console_rules()["test"];
|
||||
assert_eq!(rules.len(), 2);
|
||||
assert_eq!((rules[0].foreground.as_deref(), rules[0].background.as_deref()), (Some("bright-yellow"), None));
|
||||
assert!(matches!(api.console_rules(vec![rule("(a+)+b")]), Err(HostError::Invalid(_))));
|
||||
assert_eq!(api.shared.console_rules()["test"].len(), 2);
|
||||
api.console_rules(vec![rule("x")]).unwrap();
|
||||
assert_eq!(api.shared.console_rules()["test"].len(), 1);
|
||||
api.console_rules(Vec::new()).unwrap();
|
||||
assert!(api.shared.console_rules().is_empty());
|
||||
api.console_rules(vec![rule("x")]).unwrap();
|
||||
api.shared.clear_plugin("test", true);
|
||||
assert!(api.shared.console_rules().is_empty());
|
||||
}
|
||||
#[test]
|
||||
fn decoration_styles_keep_the_severity_palette_the_editor_renders() {
|
||||
// Inspection Lens colours typos and weak warnings with their own styles; the
|
||||
// host must keep them, not silently drop them the way an unknown style is dropped.
|
||||
|
||||
@@ -184,6 +184,12 @@ pub fn plugin_decoration_sets(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec
|
||||
plugins.decoration_sets()
|
||||
}
|
||||
|
||||
/// Every plugin's console highlight rules (later changes arrive as `consoleRulesChanged`).
|
||||
#[command(trust = trusted)]
|
||||
pub fn plugin_console_rules(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
|
||||
plugins.console_rules()
|
||||
}
|
||||
|
||||
/// Reports exactly one completion from the operation's launching window.
|
||||
#[command(trust = trusted)]
|
||||
pub fn plugin_finish_operation(
|
||||
@@ -296,6 +302,7 @@ ide_command::domain!(
|
||||
plugin_answer_prompt,
|
||||
plugin_cancel_task,
|
||||
plugin_choose_program,
|
||||
plugin_console_rules,
|
||||
plugin_content_tab_action,
|
||||
plugin_context_keys,
|
||||
plugin_debug_attach_target,
|
||||
|
||||
@@ -0,0 +1,325 @@
|
||||
//! Console highlight rules (API 1.12, `ui.set-console-rules`): validated here,
|
||||
//! matched by the windows with JavaScript's backtracking `RegExp`. A rule is
|
||||
//! refused unless its worst case on a line of [`LINE_LEN`] characters stays
|
||||
//! within [`MAX_STEPS`] backtracking steps, estimated from its structure.
|
||||
|
||||
use ide_plugin::ConsoleRule;
|
||||
use regex_syntax::hir::{Class, ClassUnicode, ClassUnicodeRange, Hir, HirKind, Look};
|
||||
|
||||
pub(crate) const MAX_RULES: usize = 100;
|
||||
/// The characters of a line the windows match rules against (`src/ui/consoleRules.ts`).
|
||||
const LINE_LEN: u64 = 2000;
|
||||
/// About 4 · 2000², a few milliseconds of `RegExp` work for one line.
|
||||
const MAX_STEPS: u64 = 4 * LINE_LEN * LINE_LEN;
|
||||
|
||||
const COLORS: &[&str] = &["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"];
|
||||
const STYLES: &[&str] = &["bold", "italic", "underline", "strikethrough", "dim"];
|
||||
|
||||
/// Validates every rule and drops colours and styles this host doesn't know.
|
||||
pub(crate) fn normalize(rules: Vec<ConsoleRule>) -> Result<Vec<ConsoleRule>, String> {
|
||||
if rules.len() > MAX_RULES {
|
||||
return Err(format!("at most {MAX_RULES} console rules"));
|
||||
}
|
||||
rules
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(i, rule)| {
|
||||
validate_pattern(&rule.pattern, rule.ignore_case).map_err(|e| format!("console rule {i}: {e}"))?;
|
||||
let mut styles: Vec<String> = Vec::new();
|
||||
for style in rule.styles {
|
||||
if STYLES.contains(&style.as_str()) && !styles.contains(&style) {
|
||||
styles.push(style);
|
||||
}
|
||||
}
|
||||
Ok(ConsoleRule {
|
||||
foreground: rule.foreground.filter(|c| known_color(c)),
|
||||
background: rule.background.filter(|c| known_color(c)),
|
||||
styles,
|
||||
..rule
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn known_color(name: &str) -> bool {
|
||||
COLORS.contains(&name.strip_prefix("bright-").unwrap_or(name))
|
||||
}
|
||||
|
||||
fn validate_pattern(pattern: &str, ignore_case: bool) -> Result<(), String> {
|
||||
if pattern.is_empty() {
|
||||
return Err("empty pattern".into());
|
||||
}
|
||||
if pattern.len() > super::icon_patterns::MAX_PATTERN_LEN {
|
||||
return Err(format!("pattern {pattern:?} is too long (max {})", super::icon_patterns::MAX_PATTERN_LEN));
|
||||
}
|
||||
if let Some(construct) = super::icon_patterns::unsupported_construct(pattern) {
|
||||
return Err(format!("pattern {pattern:?}: {construct} is not supported"));
|
||||
}
|
||||
let parse = |p: &str| {
|
||||
regex_syntax::ParserBuilder::new()
|
||||
.case_insensitive(ignore_case)
|
||||
.build()
|
||||
.parse(p)
|
||||
.map_err(|e| format!("invalid pattern {pattern:?}: {e}"))
|
||||
};
|
||||
parse(pattern)?;
|
||||
let hir = parse(&javascript_classes(pattern))?;
|
||||
let anchored = starts_anchored(&hir);
|
||||
let cost = cost(&hir, &ClassUnicode::empty(), true)
|
||||
.map_err(|why| format!("pattern {pattern:?}: {why} is not supported"))?;
|
||||
let starts = if anchored { 1 } else { LINE_LEN };
|
||||
if cost.work.saturating_mul(starts) > MAX_STEPS {
|
||||
return Err(format!(
|
||||
"pattern {pattern:?} could take too long on a long line: avoid two repetitions that can match the same text (`.*a.*b`, `\\w+\\w+`); a class such as `[^)]*` often helps"
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn starts_anchored(hir: &Hir) -> bool {
|
||||
match hir.kind() {
|
||||
HirKind::Look(Look::Start) => true,
|
||||
HirKind::Capture(c) => starts_anchored(&c.sub),
|
||||
HirKind::Concat(items) => items.first().is_some_and(starts_anchored),
|
||||
HirKind::Alternation(items) => items.iter().all(starts_anchored),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// From one start: `ways` the expression can end (each a backtracking point for
|
||||
/// what follows) and the `work` of trying them all when what follows fails.
|
||||
/// `scan`: the work is one pass over a run of characters.
|
||||
#[derive(Clone, Copy)]
|
||||
struct Cost {
|
||||
ways: u64,
|
||||
work: u64,
|
||||
scan: bool,
|
||||
}
|
||||
|
||||
const ONE: Cost = Cost { ways: 1, work: 1, scan: false };
|
||||
|
||||
/// `follow`: the characters what comes after `hir` can start with (empty when
|
||||
/// only assertions follow). `last`: nothing follows, so the first way to end is the match.
|
||||
fn cost(hir: &Hir, follow: &ClassUnicode, last: bool) -> Result<Cost, &'static str> {
|
||||
match hir.kind() {
|
||||
HirKind::Empty | HirKind::Literal(_) | HirKind::Class(_) | HirKind::Look(_) => Ok(ONE),
|
||||
HirKind::Capture(c) => cost(&c.sub, follow, last),
|
||||
HirKind::Concat(items) => {
|
||||
let mut total = Cost { ways: 1, work: 0, scan: false };
|
||||
let mut fixed = false;
|
||||
let mut scanned = None;
|
||||
for (i, item) in items.iter().enumerate() {
|
||||
let rest = &items[i + 1..];
|
||||
// Nothing after this can fail: the first way to end is the match.
|
||||
if last && rest.is_empty() && nullable(item) {
|
||||
total.work = total.work.saturating_add(total.ways);
|
||||
break;
|
||||
}
|
||||
let next = first_of_seq(rest, follow);
|
||||
let c = cost(item, &next, last && rest.is_empty())?;
|
||||
// In a run of single characters (`[Ee][Rr]…`) only the first one is tried each way,
|
||||
// and runs of one way cover different parts of the line: one pass in all.
|
||||
let single = c.ways == 1 && c.work == 1;
|
||||
let rescan = c.scan && scanned == Some(total.ways);
|
||||
if !(single && fixed) && !rescan {
|
||||
total.work = total.work.saturating_add(total.ways.saturating_mul(c.work));
|
||||
}
|
||||
fixed = single;
|
||||
if c.scan {
|
||||
scanned = Some(total.ways);
|
||||
}
|
||||
total.ways = total.ways.saturating_mul(c.ways);
|
||||
}
|
||||
Ok(Cost { ways: total.ways, work: total.work.max(1), scan: false })
|
||||
}
|
||||
HirKind::Alternation(items) => items.iter().try_fold(Cost { ways: 0, work: 0, scan: false }, |acc, h| {
|
||||
let c = cost(h, follow, last)?;
|
||||
Ok(Cost { ways: acc.ways.saturating_add(c.ways), work: acc.work.saturating_add(c.work), scan: false })
|
||||
}),
|
||||
HirKind::Repetition(r) => match r.max {
|
||||
None if matches!(r.sub.kind(), HirKind::Literal(_) | HirKind::Class(_)) => {
|
||||
// A run that what follows can't start inside ends in one place.
|
||||
let ways = if overlaps(&first(&r.sub), follow) { LINE_LEN } else { 1 };
|
||||
Ok(Cost { ways, work: LINE_LEN, scan: true })
|
||||
}
|
||||
None => Err("a repeated group (`(…)*`, `(…)+`)"),
|
||||
Some(max) => {
|
||||
// Each copy may end in `c.ways` places, and the count itself may vary.
|
||||
let c = cost(&r.sub, &union(&first(&r.sub), follow), false)?;
|
||||
let ways = c.ways.saturating_pow(max).saturating_mul(u64::from(max - r.min) + 1);
|
||||
Ok(Cost { ways, work: ways.saturating_mul(c.work).saturating_add(u64::from(max)), scan: false })
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn overlaps(a: &ClassUnicode, b: &ClassUnicode) -> bool {
|
||||
let mut both = a.clone();
|
||||
both.intersect(b);
|
||||
!both.ranges().is_empty()
|
||||
}
|
||||
|
||||
/// `pattern` with JavaScript's ASCII-only `\w` and `\d` (Rust's are Unicode), so that
|
||||
/// `\W` and `\D` include letters such as `é` as they do where the rules run.
|
||||
fn javascript_classes(pattern: &str) -> String {
|
||||
let mut out = String::with_capacity(pattern.len());
|
||||
let mut chars = pattern.chars();
|
||||
while let Some(c) = chars.next() {
|
||||
if c != '\\' {
|
||||
out.push(c);
|
||||
continue;
|
||||
}
|
||||
match chars.next() {
|
||||
Some('w') => out.push_str("[0-9A-Za-z_]"),
|
||||
Some('W') => out.push_str("[^0-9A-Za-z_]"),
|
||||
Some('d') => out.push_str("[0-9]"),
|
||||
Some('D') => out.push_str("[^0-9]"),
|
||||
Some(next) => {
|
||||
out.push('\\');
|
||||
out.push(next);
|
||||
}
|
||||
None => out.push('\\'),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn nullable(hir: &Hir) -> bool {
|
||||
hir.properties().minimum_len() == Some(0)
|
||||
}
|
||||
|
||||
/// The characters `hir` can start with (everything, for a byte class).
|
||||
fn first(hir: &Hir) -> ClassUnicode {
|
||||
match hir.kind() {
|
||||
HirKind::Empty | HirKind::Look(_) => ClassUnicode::empty(),
|
||||
HirKind::Literal(lit) => match std::str::from_utf8(&lit.0).ok().and_then(|s| s.chars().next()) {
|
||||
Some(c) => ClassUnicode::new([ClassUnicodeRange::new(c, c)]),
|
||||
None => any(),
|
||||
},
|
||||
HirKind::Class(Class::Unicode(class)) => class.clone(),
|
||||
HirKind::Class(Class::Bytes(_)) => any(),
|
||||
HirKind::Capture(c) => first(&c.sub),
|
||||
HirKind::Repetition(r) => first(&r.sub),
|
||||
HirKind::Concat(items) => first_of_seq(items, &ClassUnicode::empty()),
|
||||
HirKind::Alternation(items) => items.iter().fold(ClassUnicode::empty(), |acc, h| union(&acc, &first(h))),
|
||||
}
|
||||
}
|
||||
|
||||
/// The characters a sequence can start with, then `follow` if it may match nothing.
|
||||
fn first_of_seq(items: &[Hir], follow: &ClassUnicode) -> ClassUnicode {
|
||||
let mut set = ClassUnicode::empty();
|
||||
for item in items {
|
||||
set = union(&set, &first(item));
|
||||
if !nullable(item) {
|
||||
return set;
|
||||
}
|
||||
}
|
||||
union(&set, follow)
|
||||
}
|
||||
|
||||
fn union(a: &ClassUnicode, b: &ClassUnicode) -> ClassUnicode {
|
||||
let mut out = a.clone();
|
||||
out.union(b);
|
||||
out
|
||||
}
|
||||
|
||||
fn any() -> ClassUnicode {
|
||||
ClassUnicode::new([ClassUnicodeRange::new('\0', char::MAX)])
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn rule(pattern: &str) -> ConsoleRule {
|
||||
ConsoleRule {
|
||||
pattern: pattern.into(),
|
||||
ignore_case: false,
|
||||
foreground: Some("red".into()),
|
||||
background: None,
|
||||
styles: Vec::new(),
|
||||
whole_line: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
fn err(pattern: &str) -> String {
|
||||
validate_pattern(pattern, false).unwrap_err()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_typical_log_rules() {
|
||||
for pattern in [
|
||||
r"\[AUDIT\]",
|
||||
r"\[(AUDIT|METRIC|TASK-FAIL)\]",
|
||||
r"JOB-\d+",
|
||||
r"Exception in thread .*",
|
||||
r".*ERROR.*",
|
||||
r"took \d+(\.\d+)?ms",
|
||||
r"\d+\.\d+\.\d+\.\d+",
|
||||
r"\w+@\w+\.com",
|
||||
r"user=\S+\s+id=\d+",
|
||||
r#"^\s*at [^(]*\([^)]*\)$"#,
|
||||
r"^\[service-a\].*",
|
||||
r"SELECT .* FROM",
|
||||
r"\b(GET|POST|PUT|DELETE) /\S*",
|
||||
r"\d+(\.\d+){0,3}",
|
||||
r"\w+(-\w+){0,4}",
|
||||
r"(ERROR|WARN)\b.*$",
|
||||
] {
|
||||
assert!(validate_pattern(pattern, false).is_ok(), "{pattern}: {:?}", validate_pattern(pattern, false));
|
||||
assert!(validate_pattern(pattern, true).is_ok(), "{pattern} (ignore case)");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_patterns_that_backtrack_for_too_long() {
|
||||
// Each takes seconds or more on a 2000-character line in V8.
|
||||
assert!(err(r"(a+)+$").contains("repeated group"));
|
||||
assert!(err(r"^(a|aa)+b$").contains("repeated group"));
|
||||
assert!(err(r"a*a*a*b").contains("too long"));
|
||||
assert!(err(r".*a.*b").contains("too long"));
|
||||
assert!(err(r"\w+\w+!").contains("too long"));
|
||||
assert!(err(r"^(a?){30}a{30}$").contains("too long"));
|
||||
// A group before `$` or `\b` is not the end of the pattern: those can still fail.
|
||||
assert!(err(r"(x(a+)*)$").contains("repeated group"));
|
||||
assert!(err(r"(?:foo|x(a+)*)\b").contains("repeated group"));
|
||||
assert!(err(r"^(x\w*\w*\w*)$").contains("too long"));
|
||||
// JavaScript's `\W` matches `é` and `\D` matches `٣`, Rust's don't.
|
||||
assert!(err(r"\W+é+!").contains("too long"));
|
||||
assert!(err(r"[\D]+[٣]+!").contains("too long"));
|
||||
assert!(validate_pattern(r"\\w+\\w+!", false).is_ok(), "an escaped backslash, then `w`");
|
||||
assert!(validate_pattern(r"[0-9a-f]{32}", false).is_ok());
|
||||
// Anchored, the same shape tries one start instead of every position.
|
||||
assert!(validate_pattern(r"^\w+\w+!", false).is_ok());
|
||||
assert!(err(r"^.*a.*b.*c").contains("too long"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_constructs_javascript_reads_differently() {
|
||||
for pattern in [r"(?i)error", r"(?P<n>a)", r"(?=a)", r"\Aerror", r"error\z", r"\p{L}", r"[[:alpha:]]"] {
|
||||
assert!(err(pattern).contains("not supported"), "{pattern}");
|
||||
}
|
||||
assert!(err("(").contains("invalid pattern"));
|
||||
assert!(err("").contains("empty"));
|
||||
assert!(err(&"a".repeat(513)).contains("too long"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalizing_keeps_known_colours_and_styles_and_bounds_the_list() {
|
||||
let mut r = rule("x");
|
||||
r.foreground = Some("bright-cyan".into());
|
||||
r.background = Some("#ff0000".into());
|
||||
r.styles = vec!["bold".into(), "blink".into(), "bold".into(), "dim".into()];
|
||||
let out = normalize(vec![r, ConsoleRule { foreground: Some("teal".into()), ..rule("y") }]).unwrap();
|
||||
assert_eq!(out[0].foreground.as_deref(), Some("bright-cyan"));
|
||||
assert_eq!(out[0].background, None);
|
||||
assert_eq!(out[0].styles, ["bold", "dim"]);
|
||||
assert_eq!(out[1].foreground, None);
|
||||
|
||||
let e = normalize(vec![rule("ok"), rule(".*a.*b")]).unwrap_err();
|
||||
assert!(e.starts_with("console rule 1:"), "{e}");
|
||||
assert!(normalize(vec![rule("x"); MAX_RULES]).is_ok());
|
||||
assert!(normalize(vec![rule("x"); MAX_RULES + 1]).unwrap_err().contains("at most 100"));
|
||||
}
|
||||
}
|
||||
@@ -162,7 +162,8 @@ impl PluginHost {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// What a plugin receives for `document-changed`: the path relative to the file's own project.
|
||||
/// 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.
|
||||
pub(super) fn relativize_documents(
|
||||
shared: &super::api::Shared,
|
||||
client: Option<&str>,
|
||||
@@ -181,6 +182,7 @@ impl PluginHost {
|
||||
.to_string_lossy()
|
||||
.replace('\\', "/");
|
||||
change.path = relative;
|
||||
change.project = Some(ide_core::ipc_path::to_ipc(&root));
|
||||
Some(WorkbenchEvent::DocumentChanged(change))
|
||||
})
|
||||
.collect()
|
||||
|
||||
@@ -30,7 +30,7 @@ pub(crate) fn validate_pattern(pattern: &str) -> Result<(), String> {
|
||||
}
|
||||
}
|
||||
|
||||
fn unsupported_construct(pattern: &str) -> Option<&'static str> {
|
||||
pub(crate) fn unsupported_construct(pattern: &str) -> Option<&'static str> {
|
||||
if pattern.match_indices("(?").any(|(at, _)| !pattern[at + 2..].starts_with(':')) {
|
||||
return Some("an inline flag, lookaround or named group");
|
||||
}
|
||||
|
||||
@@ -20,6 +20,7 @@ mod auth;
|
||||
mod build_graph;
|
||||
pub mod commands;
|
||||
pub mod commit;
|
||||
mod console_rules;
|
||||
mod database;
|
||||
mod dependencies;
|
||||
pub(crate) mod diagnostics;
|
||||
@@ -438,6 +439,11 @@ impl PluginHost {
|
||||
self.shared.decoration_sets()
|
||||
}
|
||||
|
||||
/// Every plugin's console highlight rules, for windows opening after they were set.
|
||||
pub fn console_rules(&self) -> std::collections::BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
|
||||
self.shared.console_rules()
|
||||
}
|
||||
|
||||
/// Creates the host; call [`load_all`](Self::load_all) to load installed plugins.
|
||||
pub fn new(plugins_dir: PathBuf, sink: Arc<dyn PluginEventSink>, limits: Limits) -> IdeResult<Self> {
|
||||
std::fs::create_dir_all(&plugins_dir)?;
|
||||
|
||||
@@ -144,6 +144,7 @@ pub fn forwarded(event: &PluginEvent) -> bool {
|
||||
| PluginEvent::ContentTabReply { .. }
|
||||
| PluginEvent::OpenDiff { .. }
|
||||
| PluginEvent::DecorationsChanged { .. }
|
||||
| PluginEvent::ConsoleRulesChanged { .. }
|
||||
| PluginEvent::EditorOpen { .. }
|
||||
| PluginEvent::EditorRanges { .. }
|
||||
| PluginEvent::Notification { .. }
|
||||
|
||||
@@ -241,6 +241,9 @@ pub enum PluginEvent {
|
||||
/// Complete replacement of one plugin's project-scoped decorations.
|
||||
#[serde(rename_all = "camelCase")]
|
||||
DecorationsChanged { plugin_id: String, sets: Vec<DecorationSet> },
|
||||
/// Complete replacement of one plugin's console highlight rules (empty: none).
|
||||
#[serde(rename_all = "camelCase")]
|
||||
ConsoleRulesChanged { plugin_id: String, rules: Vec<ide_plugin::ConsoleRule> },
|
||||
/// Open a file in the invoking window.
|
||||
EditorOpen { path: ide_core::IpcPath, selection: Option<ide_core::Range> },
|
||||
/// Change selection or scrolling only in this window's already open editor.
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
//! watchers and the per-project services, opened by [`crate::Host::open_project`].
|
||||
|
||||
use crate::Host;
|
||||
use ide_core::workflow_settings::VcsMappings;
|
||||
use ide_core::{CancellationToken, IdeError, IdeEvent, IdeResult, LanguageId, SharedSink};
|
||||
use ide_index::ProjectIndex;
|
||||
use ide_language::{FileTypes, LanguageRegistry, SyntaxCache};
|
||||
@@ -272,6 +273,7 @@ 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);
|
||||
@@ -285,6 +287,8 @@ 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);
|
||||
}
|
||||
}));
|
||||
}
|
||||
@@ -321,7 +325,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(history.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver::new(history.clone())));
|
||||
documents.add_observer(Arc::new(DeployObserver {
|
||||
remote: self.remote.clone(),
|
||||
settings: settings.clone(),
|
||||
@@ -782,7 +786,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(history.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver::new(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
|
||||
@@ -952,10 +956,27 @@ fn scan_repositories(
|
||||
}
|
||||
}
|
||||
|
||||
/// The repository containing `root` and those nested below it or below a content root.
|
||||
/// The repository containing `root` and those nested below it or below a content root,
|
||||
/// with the project's Directory Mappings applied.
|
||||
/// The project-open scan and the watcher's rescan share these skip rules.
|
||||
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path, trusted: bool) -> IdeResult<Repos> {
|
||||
let ignored = settings.effective().ignored_names();
|
||||
let settings = settings.effective();
|
||||
let found = detect_repositories(root, &settings, build_cache, trusted)?;
|
||||
let mappings = &settings.vcs.mappings;
|
||||
if mappings.is_empty() {
|
||||
return Ok(found);
|
||||
}
|
||||
let resolve = |list: &[String]| -> Vec<PathBuf> { list.iter().map(|p| VcsMappings::resolve(root, p)).collect() };
|
||||
Ok(found.mapped(&resolve(&mappings.excluded), &resolve(&mappings.added), root))
|
||||
}
|
||||
|
||||
fn detect_repositories(
|
||||
root: &Path,
|
||||
settings: &ide_core::settings::Settings,
|
||||
build_cache: &Path,
|
||||
trusted: bool,
|
||||
) -> IdeResult<Repos> {
|
||||
let ignored = settings.ignored_names();
|
||||
let skip = |p: &Path| {
|
||||
p.file_name().is_some_and(|n| {
|
||||
let name = n.to_string_lossy();
|
||||
@@ -965,11 +986,17 @@ fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Pa
|
||||
})
|
||||
};
|
||||
let mut roots = vec![root.to_path_buf()];
|
||||
roots.extend(content_roots(&settings.effective(), root, build_cache, trusted));
|
||||
roots.extend(content_roots(settings, root, build_cache, trusted));
|
||||
Repos::discover_roots(&roots, &skip)
|
||||
}
|
||||
|
||||
impl Project {
|
||||
/// The repository roots detection finds, before Directory Mappings exclude or add any.
|
||||
pub fn detected_repository_roots(&self) -> IdeResult<Vec<PathBuf>> {
|
||||
let settings = self.settings.effective();
|
||||
Ok(detect_repositories(&self.root, &settings, &self.build_cache_dir(), self.is_trusted())?.roots())
|
||||
}
|
||||
|
||||
pub fn refresh_repositories(&self) {
|
||||
scan_repositories(
|
||||
&self.root,
|
||||
@@ -1073,6 +1100,7 @@ impl Project {
|
||||
apply_git_executable(&settings);
|
||||
}
|
||||
repo.set_ignored_names(settings.ignored_names());
|
||||
repo.set_cli_status(settings.vcs.git.cli_status);
|
||||
f(repo)
|
||||
}
|
||||
|
||||
@@ -1887,14 +1915,42 @@ impl DocumentObserver for SyntaxObserver {
|
||||
}
|
||||
}
|
||||
|
||||
struct HistoryObserver(Arc<LocalHistory>);
|
||||
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() }
|
||||
}
|
||||
}
|
||||
|
||||
impl DocumentObserver for HistoryObserver {
|
||||
fn saved(&self, _doc: ide_core::DocId, path: &Path, text: &str) {
|
||||
if let Err(e) = self.0.record(path, text, "Saved") {
|
||||
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") {
|
||||
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.
|
||||
|
||||
@@ -284,6 +284,18 @@ async fn files_of_a_project_attached_outside_go_by_their_absolute_path_everywher
|
||||
.map(|r| r["repositoryPathRelativeToProject"].as_str().unwrap())
|
||||
.collect();
|
||||
assert!(repos.contains(&shown("").trim_end_matches('/')), "{repos:?}");
|
||||
|
||||
// `paths` names such a project by its absolute path, in every tool.
|
||||
let only = json!([format!("{}/src/**", shown(""))]);
|
||||
let files = h.json("search_file", json!({"q":"*.rs","paths":only})).await;
|
||||
assert_eq!(files["items"], json!([{ "filePath": shown("src/lib.rs") }]));
|
||||
let text = h.json("search_text", json!({"q":"attached_marker","paths":only})).await;
|
||||
assert_eq!(text["items"][0]["filePath"], shown("src/lib.rs"), "{text}");
|
||||
let symbols = h.json("search_symbol", json!({"q":"attached_marker","paths":only})).await;
|
||||
assert_eq!(symbols["items"][0]["filePath"], shown("src/lib.rs"), "{symbols}");
|
||||
let status = h.json("git_status", json!({"paths":only})).await;
|
||||
assert_eq!(status["repositories"].as_array().unwrap().len(), 1, "{status}");
|
||||
assert_eq!(status["repositories"][0]["repositoryPathRelativeToProject"], shown("").trim_end_matches('/'));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
@@ -442,7 +454,7 @@ async fn git_status_and_diff_on_a_temporary_repository() {
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn scope_limits_the_query_tools_to_a_directory() {
|
||||
async fn paths_limit_the_query_tools_to_folders() {
|
||||
let h = Harness::new();
|
||||
std::fs::create_dir_all(h.root.join("lib")).unwrap();
|
||||
std::fs::write(h.root.join("lib/c.txt"), "needle\n").unwrap();
|
||||
@@ -452,17 +464,20 @@ async fn scope_limits_the_query_tools_to_a_directory() {
|
||||
out.dedup();
|
||||
out
|
||||
};
|
||||
assert_eq!(paths(&h.json("search_text", json!({"q":"needle","scope":"lib"})).await), ["lib/c.txt"]);
|
||||
assert_eq!(paths(&h.json("search_regex", json!({"q":"need.e","scope":"lib/"})).await), ["lib/c.txt"]);
|
||||
assert_eq!(paths(&h.json("search_text", json!({"q":"needle","paths":["lib/"]})).await), ["lib/c.txt"]);
|
||||
assert_eq!(paths(&h.json("search_regex", json!({"q":"need.e","paths":["lib/**"]})).await), ["lib/c.txt"]);
|
||||
let absolute = h.root.join("src").to_string_lossy().into_owned();
|
||||
assert_eq!(paths(&h.json("search_file", json!({"q":"*.txt","scope":absolute})).await), ["src/a.txt", "src/b.txt"]);
|
||||
// Within the scope, `paths` narrows further.
|
||||
assert_eq!(
|
||||
paths(&h.json("search_text", json!({"q":"needle","scope":"src","paths":["**/b.txt"]})).await),
|
||||
["src/b.txt"]
|
||||
paths(&h.json("search_file", json!({"q":"*.txt","paths":[absolute]})).await),
|
||||
["src/a.txt", "src/b.txt"]
|
||||
);
|
||||
assert!(h.error("search_text", json!({"q":"needle","scope":"missing"})).await.contains("is not a directory"));
|
||||
assert!(h.error("search_text", json!({"q":"needle","scope":".."})).await.contains("outside the project"));
|
||||
// Several folders at once, and exclusions.
|
||||
assert_eq!(
|
||||
paths(&h.json("search_text", json!({"q":"needle","paths":["src/**","lib/**","!**/a.txt"]})).await),
|
||||
["lib/c.txt", "src/b.txt"]
|
||||
);
|
||||
let outside = h.error("search_text", json!({"q":"needle","paths":["../**"]})).await;
|
||||
assert!(outside.contains("outside of the project directory"), "{outside}");
|
||||
|
||||
let git = |args: &[&str]| {
|
||||
let output = std::process::Command::new("git").current_dir(&h.root).args(args).output().unwrap();
|
||||
@@ -473,7 +488,7 @@ async fn scope_limits_the_query_tools_to_a_directory() {
|
||||
git(&["-c", "user.name=Test", "-c", "[email protected]", "commit", "-m", "Initial"]);
|
||||
std::fs::write(h.root.join("src/a.txt"), "changed\n").unwrap();
|
||||
std::fs::write(h.root.join("lib/c.txt"), "changed\n").unwrap();
|
||||
let status = h.json("git_status", json!({"scope":"lib"})).await;
|
||||
let status = h.json("git_status", json!({"paths":["lib/"]})).await;
|
||||
assert_eq!(status["repositories"].as_array().unwrap().len(), 1);
|
||||
assert_eq!(
|
||||
status["repositories"][0]["entries"],
|
||||
@@ -482,7 +497,63 @@ async fn scope_limits_the_query_tools_to_a_directory() {
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
|
||||
async fn excluded_and_ignored_folders_are_searched_when_asked_for() {
|
||||
let h = Harness::new();
|
||||
// `ignored/` is ignored by the project's `.gitignore`; `excluded/` is excluded in its settings.
|
||||
std::fs::create_dir_all(h.root.join("excluded")).unwrap();
|
||||
std::fs::write(h.root.join("excluded/e.txt"), "needle\n").unwrap();
|
||||
std::fs::create_dir_all(h.root.join("src/ignored")).unwrap();
|
||||
std::fs::write(h.root.join("src/ignored/x.txt"), "needle\n").unwrap();
|
||||
ide_host::ops::project::set_settings(
|
||||
&h.host,
|
||||
"main",
|
||||
ide_workspace::settings::SettingsScope::Project,
|
||||
"projectStructure.excluded",
|
||||
"[\"excluded\"]",
|
||||
)
|
||||
.unwrap();
|
||||
let found = |args: Value| {
|
||||
let h = &h;
|
||||
async move {
|
||||
let v = h.json(args["tool"].as_str().unwrap(), args["args"].clone()).await;
|
||||
let mut out: Vec<String> = v["items"]
|
||||
.as_array()
|
||||
.cloned()
|
||||
.unwrap_or_default()
|
||||
.iter()
|
||||
.map(|i| i["filePath"].as_str().unwrap().to_owned())
|
||||
.collect();
|
||||
out.sort();
|
||||
out.dedup();
|
||||
out
|
||||
}
|
||||
};
|
||||
let text = |args: Value| json!({ "tool": "search_text", "args": args });
|
||||
assert_eq!(found(text(json!({"q":"needle"}))).await, ["src/a.txt", "src/b.txt"]);
|
||||
let every = ["excluded/e.txt", "ignored/a.txt", "src/a.txt", "src/b.txt", "src/ignored/x.txt"];
|
||||
assert_eq!(found(text(json!({"q":"needle","includeExcluded":true}))).await, every);
|
||||
assert_eq!(found(json!({"tool":"search_regex","args":{"q":"need.e","includeExcluded":true}})).await, every);
|
||||
// `paths` only narrows: a folder the project leaves out stays out when named ...
|
||||
let nothing: Vec<String> = Vec::new();
|
||||
assert_eq!(found(text(json!({"q":"needle","paths":["ignored/"]}))).await, nothing);
|
||||
assert_eq!(found(text(json!({"q":"needle","paths":["excluded/"]}))).await, nothing);
|
||||
// ... and is searched, alone, when asked for.
|
||||
assert_eq!(
|
||||
found(text(json!({"q":"needle","paths":["ignored/","excluded/"],"includeExcluded":true}))).await,
|
||||
["excluded/e.txt", "ignored/a.txt"]
|
||||
);
|
||||
let file = |dir: &str| json!({"tool":"search_file","args":{"q":"*.txt","paths":[dir],"includeExcluded":true}});
|
||||
assert_eq!(found(file("excluded/")).await, ["excluded/e.txt"]);
|
||||
assert_eq!(found(file("ignored/")).await, ["ignored/a.txt"]);
|
||||
assert_eq!(found(text(json!({"q":"needle","paths":["src/"]}))).await, ["src/a.txt", "src/b.txt"]);
|
||||
assert_eq!(
|
||||
found(text(json!({"q":"needle","paths":["src/"],"includeExcluded":true}))).await,
|
||||
["src/a.txt", "src/b.txt", "src/ignored/x.txt"]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_symbol_search_with_paths_finds_matches_past_the_others() {
|
||||
let h = Harness::new();
|
||||
std::fs::create_dir_all(h.root.join("many")).unwrap();
|
||||
for i in 0..60 {
|
||||
@@ -498,12 +569,12 @@ async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
|
||||
assert!(std::time::Instant::now() < deadline, "the files were never indexed");
|
||||
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||
}
|
||||
let found = h.json("search_symbol", json!({"q":"pool_marker","scope":"zz","limit":1})).await;
|
||||
let found = h.json("search_symbol", json!({"q":"pool_marker","paths":["zz/"],"limit":1})).await;
|
||||
assert_eq!(found["items"][0]["filePath"], "zz/last.rs", "{found}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
|
||||
async fn paths_reach_an_attached_worktree_the_repository_ignores() {
|
||||
let h = Harness::new();
|
||||
h.trust().await;
|
||||
let git = |dir: &Path, args: &[&str]| {
|
||||
@@ -545,10 +616,14 @@ async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
|
||||
let everywhere = found(json!({"q":"needle"})).await;
|
||||
assert!(everywhere.contains(&".wt/feature/src/b.txt".to_owned()), "{everywhere:?}");
|
||||
assert_eq!(
|
||||
found(json!({"q":"needle","scope":".wt/feature/src"})).await,
|
||||
found(json!({"q":"needle","paths":[".wt/feature/src/"]})).await,
|
||||
[".wt/feature/src/a.txt", ".wt/feature/src/b.txt"]
|
||||
);
|
||||
assert_eq!(found(json!({"q":"needle","paths":[".wt/feature/src/b.txt"]})).await, [".wt/feature/src/b.txt"]);
|
||||
// With `includeExcluded` the root's walk enters the ignored worktree: its files still come once.
|
||||
let all = h.json("search_text", json!({"q":"needle","includeExcluded":true})).await;
|
||||
let items = all["items"].as_array().unwrap();
|
||||
assert_eq!(items.iter().filter(|i| i["filePath"] == ".wt/feature/src/b.txt").count(), 1, "{all}");
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
@@ -1217,8 +1292,8 @@ async fn call_hierarchy_pages_are_sorted_and_scoped() {
|
||||
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;
|
||||
let scoped = h.json("get_call_hierarchy", at(json!({"paths":["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");
|
||||
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the paths");
|
||||
}
|
||||
@@ -121,6 +121,7 @@ impl PluginWorkspace for TestWorkspace {
|
||||
scope: ide_search::SearchScope::Project,
|
||||
max_matches: limit,
|
||||
context: Default::default(),
|
||||
include_excluded: false,
|
||||
};
|
||||
let files = Mutex::new(Vec::new());
|
||||
let summary = ide_search::search(root, &query, &|_| None, cancel, &|file| files.lock().push(file))
|
||||
@@ -879,16 +880,15 @@ 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 f = fixture(Limits {
|
||||
let limits = 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());
|
||||
if f.host.set_capability("misbehave", "process:git", true).is_err() {
|
||||
return;
|
||||
}
|
||||
f.host.set_capability("misbehave", "process:git", true).expect("grant Git capability");
|
||||
// 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"));
|
||||
|
||||
@@ -897,6 +897,13 @@ 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]
|
||||
@@ -4854,6 +4861,49 @@ fn plugins_set_their_own_context_keys() {
|
||||
assert!(f.host.context_keys(Some("main")).is_empty(), "cleared when the plugin stops");
|
||||
}
|
||||
|
||||
/// `ui.set-console-rules` (API 1.12) replaces the plugin's rules for every window without a
|
||||
/// capability; unknown colours are dropped, an invalid rule keeps the previous list.
|
||||
#[test]
|
||||
fn plugins_replace_their_console_rules_and_lose_them_when_they_stop() {
|
||||
let f = fixture(Limits::default());
|
||||
f.install(&sample("jobs"));
|
||||
f.take_events();
|
||||
f.run("jobs", "console-rules", None).unwrap();
|
||||
let changed: Vec<_> = f
|
||||
.take_events()
|
||||
.into_iter()
|
||||
.filter_map(|(client, e)| match e {
|
||||
PluginEvent::ConsoleRulesChanged { plugin_id, rules } => Some((client, plugin_id, rules)),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(changed.len(), 1);
|
||||
let (client, plugin_id, rules) = &changed[0];
|
||||
assert_eq!((client.as_deref(), plugin_id.as_str()), (None, "jobs"));
|
||||
assert_eq!(rules.iter().map(|r| r.pattern.as_str()).collect::<Vec<_>>(), [r"\[AUDIT\]", r"job-\d+"]);
|
||||
assert!(
|
||||
rules[0].whole_line && rules[0].styles == ["bold"] && rules[0].foreground.as_deref() == Some("bright-yellow")
|
||||
);
|
||||
assert!(rules[1].ignore_case && rules[1].foreground.as_deref() == Some("cyan") && rules[1].background.is_none());
|
||||
assert_eq!(f.host.console_rules()["jobs"], *rules);
|
||||
|
||||
let err = f.run("jobs", "console-rules", Some("(a+)+b")).unwrap_err();
|
||||
assert!(err.contains("invalid") && err.contains("repeated group"), "{err}");
|
||||
assert!(f.run("jobs", "console-rules", Some(".*a.*b")).unwrap_err().contains("too long"));
|
||||
assert_eq!(f.host.console_rules()["jobs"].len(), 2, "an invalid list keeps the previous one");
|
||||
|
||||
f.run("jobs", "console-rules", Some("")).unwrap();
|
||||
assert!(f.host.console_rules().is_empty());
|
||||
|
||||
f.run("jobs", "console-rules", None).unwrap();
|
||||
f.take_events();
|
||||
f.host.set_enabled("jobs", false).unwrap();
|
||||
assert!(f.host.console_rules().is_empty(), "cleared when the plugin stops");
|
||||
assert!(f.take_events().iter().any(
|
||||
|(_, e)| matches!(e, PluginEvent::ConsoleRulesChanged { plugin_id, rules } if plugin_id == "jobs" && rules.is_empty())
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn context_keys_are_capped_and_windows_overlay_global_ones() {
|
||||
let f = fixture(Limits::default());
|
||||
@@ -5292,6 +5342,7 @@ 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(),
|
||||
@@ -5305,6 +5356,8 @@ 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]
|
||||
|
||||
@@ -47,6 +47,7 @@ async fn find(host: &Host, paths: Vec<PathBuf>, pattern: &str) -> Vec<ide_search
|
||||
scope: SearchScope::Files { paths: paths.into_iter().map(Into::into).collect() },
|
||||
max_matches: 0,
|
||||
context: Default::default(),
|
||||
include_excluded: false,
|
||||
},
|
||||
ide_host::ops::Channel::new(move |event| {
|
||||
if let search::SearchEvent::File { file } = event {
|
||||
@@ -165,6 +166,7 @@ async fn properties_search_git_and_document_coordinates_agree() {
|
||||
scope: SearchScope::Files { paths: vec![closed_path.clone().into()] },
|
||||
max_matches: 0,
|
||||
context: Default::default(),
|
||||
include_excluded: false,
|
||||
};
|
||||
search::replace_in_files(
|
||||
&host,
|
||||
|
||||
@@ -146,3 +146,52 @@ async fn replace_all_covers_matches_past_the_limit() {
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
/// #4202: a file the search preview holds open (no unsaved changes) is saved like a closed
|
||||
/// one; a buffer with unsaved edits is replaced in place and left for the editor to save.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn replace_all_saves_open_buffers_without_unsaved_changes() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
for name in ["previewed.txt", "edited.txt", "closed.txt"] {
|
||||
std::fs::write(root.join(name), "TOKEN\n").unwrap();
|
||||
}
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&root, true, false).unwrap();
|
||||
host.open_project("main", &root).unwrap();
|
||||
let project = host.project("main").unwrap();
|
||||
project.documents.open(&root.join("previewed.txt")).unwrap();
|
||||
let edited = project.documents.open(&root.join("edited.txt")).unwrap().id;
|
||||
project.documents.replace_all(edited, "TOKEN\nmore\n").unwrap();
|
||||
ops::search::replace_in_files(
|
||||
&host,
|
||||
"main",
|
||||
RequestId::next(),
|
||||
query("TOKEN", false),
|
||||
"DONE".into(),
|
||||
false,
|
||||
vec![],
|
||||
true,
|
||||
ops::Channel::new(|_| {}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let disk = |name: &str| std::fs::read_to_string(root.join(name)).unwrap();
|
||||
assert_eq!(disk("previewed.txt"), "DONE\n");
|
||||
assert_eq!(disk("closed.txt"), "DONE\n");
|
||||
assert_eq!(disk("edited.txt"), "TOKEN\n", "unsaved edits stay unsaved");
|
||||
assert_eq!(project.documents.text_snapshot(edited).unwrap().text, "DONE\nmore\n");
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -45,6 +45,9 @@ 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,15 +2,12 @@
|
||||
//! `ignore` crate) plus the user's `files.exclude` globs, below the project root
|
||||
//! and the extra content roots (Project Structure).
|
||||
//!
|
||||
//! Like IDEA, ignored directories are left out entirely, while ignored files in
|
||||
//! the remaining directories (`.env`) are listed by name only, so Go to File finds
|
||||
//! them but their symbols stay out of the index.
|
||||
//! Git-ignored files and folders are listed by name only: Go to File finds them
|
||||
//! without reading their contents or indexing their symbols. Excluded folders
|
||||
//! (including project-model outputs and dependencies) are not walked at all.
|
||||
|
||||
use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
|
||||
use ignore::gitignore::{Gitignore, GitignoreBuilder};
|
||||
use ignore::{WalkBuilder, WalkState};
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map::Entry;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc;
|
||||
@@ -25,9 +22,6 @@ pub(crate) struct PathFilter {
|
||||
/// Content roots outside `root`, indexed as `<folder name>/<path>`.
|
||||
extra: Vec<ExtraRoot>,
|
||||
excludes: GlobSet,
|
||||
/// Root-level ignore files, for paths reported by the watcher (the walker
|
||||
/// applies nested ignore files itself).
|
||||
gitignore: Gitignore,
|
||||
/// What the filter was built from: `(extra roots, exclude globs)`.
|
||||
config: (crate::IndexRoots, Vec<String>),
|
||||
}
|
||||
@@ -36,25 +30,11 @@ struct ExtraRoot {
|
||||
path: PathBuf,
|
||||
/// Shown before the paths inside it (`shared-lib/src/x.rs`).
|
||||
name: String,
|
||||
gitignore: Gitignore,
|
||||
}
|
||||
|
||||
fn root_ignores(root: &Path) -> Gitignore {
|
||||
let mut gi = GitignoreBuilder::new(root);
|
||||
for f in [".gitignore", ".ignore", ".git/info/exclude"] {
|
||||
let path = root.join(f);
|
||||
if path.is_file()
|
||||
&& let Some(e) = gi.add(&path)
|
||||
{
|
||||
tracing::debug!("{}: {e}", path.display());
|
||||
}
|
||||
}
|
||||
gi.build().unwrap_or_else(|_| Gitignore::empty())
|
||||
}
|
||||
|
||||
/// Whether walking `root` leaves out `dir`, a folder below it: `dir` or a folder between
|
||||
/// them is ignored (`.gitignore`, `.ignore`, `info/exclude`, the global excludes). Such a
|
||||
/// folder can be a root of its own, with its own rules, without its files being walked twice.
|
||||
/// Whether an ignore-aware content walk of `root` leaves out `dir` or an ancestor.
|
||||
/// An ignored folder can be an explicit content root with its own ignore rules,
|
||||
/// promoting its files from filename-only entries to indexable content.
|
||||
pub fn walk_skips(root: &Path, dir: &Path) -> bool {
|
||||
if dir == root || !dir.starts_with(root) || !dir.is_dir() {
|
||||
return false;
|
||||
@@ -150,14 +130,13 @@ impl PathFilter {
|
||||
Ok(rel) if extra_roots.include_root => rel_string(rel),
|
||||
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
|
||||
};
|
||||
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
|
||||
extra.push(ExtraRoot { name, path });
|
||||
}
|
||||
Self {
|
||||
root: root.to_owned(),
|
||||
include_root: extra_roots.include_root,
|
||||
extra,
|
||||
excludes,
|
||||
gitignore: root_ignores(root),
|
||||
config: (extra_roots.clone(), exclude_globs.to_vec()),
|
||||
}
|
||||
}
|
||||
@@ -170,7 +149,7 @@ impl PathFilter {
|
||||
/// Stable fingerprint of the persisted-scope configuration; a start-up
|
||||
/// snapshot is only trusted when this still matches.
|
||||
pub(crate) fn stamp(&self) -> String {
|
||||
let mut stamp = format!("include_root={}\n", self.config.0.include_root);
|
||||
let mut stamp = format!("ignored_folders=names\ninclude_root={}\n", self.config.0.include_root);
|
||||
for folder in &self.config.0.folders {
|
||||
stamp.push_str(&folder.to_string_lossy());
|
||||
stamp.push('\n');
|
||||
@@ -203,13 +182,13 @@ impl PathFilter {
|
||||
.chain(self.extra.iter().map(|e| e.path.as_path()))
|
||||
}
|
||||
|
||||
/// The root containing `path`, its display prefix (`None` for the project root) and ignore rules.
|
||||
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>, &Gitignore)> {
|
||||
/// The root containing `path` and its display prefix (`None` for the project root).
|
||||
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>)> {
|
||||
// An extra root inside the project root wins: its own rules apply below it.
|
||||
if let Some(e) = self.extra.iter().find(|e| path.starts_with(&e.path)) {
|
||||
return Some((e.path.as_path(), Some(e.name.as_str()), &e.gitignore));
|
||||
return Some((e.path.as_path(), Some(e.name.as_str())));
|
||||
}
|
||||
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
|
||||
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None))
|
||||
}
|
||||
|
||||
/// Whether `path` is (at or) below one of the roots.
|
||||
@@ -220,7 +199,7 @@ impl PathFilter {
|
||||
/// `/`-separated path relative to its root, as displayed; paths in extra
|
||||
/// content roots start with the root's folder name.
|
||||
pub(crate) fn rel(&self, path: &Path) -> Option<String> {
|
||||
let (base, prefix, _) = self.base_of(path)?;
|
||||
let (base, prefix) = self.base_of(path)?;
|
||||
let rel = rel_string(path.strip_prefix(base).ok()?);
|
||||
if rel.is_empty() {
|
||||
return None;
|
||||
@@ -241,6 +220,15 @@ impl PathFilter {
|
||||
(!rel.is_empty()).then_some(rel)
|
||||
}
|
||||
|
||||
/// Recent Files' stored form: the store key for a project file, the absolute
|
||||
/// path for one outside it (a scratch file). Loading joins it to the root,
|
||||
/// which leaves an absolute path as it is.
|
||||
pub(crate) fn recent_key(&self, path: &Path) -> Option<String> {
|
||||
self.store_key(path).or_else(|| {
|
||||
(path.is_absolute() && !path.starts_with(&self.root)).then(|| path.to_str().map(str::to_owned))?
|
||||
})
|
||||
}
|
||||
|
||||
fn excluded_rel(&self, rel: &str) -> bool {
|
||||
self.excludes.is_match(rel)
|
||||
}
|
||||
@@ -249,11 +237,10 @@ impl PathFilter {
|
||||
ALWAYS_SKIP.contains(&name)
|
||||
}
|
||||
|
||||
/// Whether a path reported by the watcher should be left out (outside the
|
||||
/// root, excluded, or an ignored directory or inside one). Ignored files
|
||||
/// elsewhere stay in, listed by name only.
|
||||
pub(crate) fn is_excluded(&self, path: &Path, is_dir: bool) -> bool {
|
||||
let Some((base, _, gitignore)) = self.base_of(path) else { return true };
|
||||
/// Whether a path is outside the roots, VCS metadata, or explicitly excluded.
|
||||
/// Git-ignore rules classify files as filename-only, not excluded.
|
||||
pub(crate) fn is_excluded(&self, path: &Path) -> bool {
|
||||
let Some((base, _)) = self.base_of(path) else { return true };
|
||||
let rel = path.strip_prefix(base).map(rel_string).unwrap_or_default();
|
||||
if rel.is_empty() {
|
||||
return true;
|
||||
@@ -271,32 +258,32 @@ impl PathFilter {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
let dir = if is_dir { Some(path) } else { path.parent().filter(|p| *p != base) };
|
||||
dir.is_some_and(|d| gitignore.matched_path_or_any_parents(d, true).is_ignore())
|
||||
false
|
||||
}
|
||||
|
||||
/// A filename walk: only explicit exclusions prune directories. Extra roots
|
||||
/// inside another root are walked separately, with their own ignore rules.
|
||||
fn walker(&self, dir: &Path) -> Option<WalkBuilder> {
|
||||
let (root, _) = self.base_of(dir)?;
|
||||
if dir != root && self.is_excluded(dir) {
|
||||
return None;
|
||||
}
|
||||
let root = root.to_path_buf();
|
||||
let excludes = self.excludes.clone();
|
||||
let extra: Vec<PathBuf> = self.extra.iter().filter(|e| e.path != dir).map(|e| e.path.clone()).collect();
|
||||
let mut builder = WalkBuilder::new(dir);
|
||||
builder.standard_filters(false).follow_links(false).filter_entry(move |e| {
|
||||
!Self::skip_name(&e.file_name().to_string_lossy())
|
||||
&& !glob_excluded(&excludes, &root, e.path())
|
||||
&& !extra.iter().any(|r| e.path() == r)
|
||||
});
|
||||
Some(builder)
|
||||
}
|
||||
|
||||
/// All directories at or below `dir` that the index would walk, in walk order.
|
||||
pub(crate) fn dirs(&self, dir: &Path) -> Vec<PathBuf> {
|
||||
let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };
|
||||
let root = root.to_path_buf();
|
||||
let excludes = self.excludes.clone();
|
||||
let walk_root = root.clone();
|
||||
let walk_excludes = excludes.clone();
|
||||
let walker = WalkBuilder::new(dir)
|
||||
.hidden(false)
|
||||
.parents(true)
|
||||
.ignore(true)
|
||||
.git_ignore(true)
|
||||
.git_global(true)
|
||||
.git_exclude(true)
|
||||
.require_git(ide_core::ignored::inside_git_repo(dir))
|
||||
.follow_links(false)
|
||||
.filter_entry(move |e| {
|
||||
let name = e.file_name().to_string_lossy();
|
||||
!Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())
|
||||
})
|
||||
.build();
|
||||
walker.flatten().filter(|e| e.file_type().is_some_and(|t| t.is_dir())).map(|e| e.into_path()).collect()
|
||||
let Some(builder) = self.walker(dir) else { return Vec::new() };
|
||||
builder.build().flatten().filter(|e| e.file_type().is_some_and(|t| t.is_dir())).map(|e| e.into_path()).collect()
|
||||
}
|
||||
|
||||
/// All indexable files at or below `dir`, walked in parallel.
|
||||
@@ -311,57 +298,35 @@ impl PathFilter {
|
||||
}
|
||||
|
||||
fn walk_to(&self, dir: &Path, max_depth: Option<usize>, cancel: &AtomicBool) -> Vec<Found> {
|
||||
let (tx, rx) = mpsc::channel::<Vec<Found>>();
|
||||
let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };
|
||||
let root = root.to_path_buf();
|
||||
let excludes = self.excludes.clone();
|
||||
let (walk_root, walk_excludes) = (root.clone(), excludes.clone());
|
||||
let walker = WalkBuilder::new(dir)
|
||||
let Some(mut builder) = self.walker(dir) else { return Vec::new() };
|
||||
let Some((root, _)) = self.base_of(dir) else { return Vec::new() };
|
||||
// Keep the matcher's root at the content root, even for a watcher scan
|
||||
// starting inside an ignored folder, so ancestor rules still apply.
|
||||
let matcher = WalkBuilder::new(root)
|
||||
.hidden(false)
|
||||
.parents(true)
|
||||
.ignore(true)
|
||||
.git_ignore(true)
|
||||
.git_global(true)
|
||||
.git_exclude(true)
|
||||
.require_git(ide_core::ignored::inside_git_repo(dir))
|
||||
.follow_links(false)
|
||||
.max_depth(max_depth)
|
||||
.filter_entry(move |e| {
|
||||
let name = e.file_name().to_string_lossy();
|
||||
!Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())
|
||||
})
|
||||
.build_parallel();
|
||||
walker.run(|| {
|
||||
let (root, excludes) = (&root, &excludes);
|
||||
.require_git(ide_core::ignored::inside_git_repo(root))
|
||||
.build_matchers()
|
||||
.pop()
|
||||
.expect("one content root");
|
||||
let (tx, rx) = mpsc::channel::<Vec<Found>>();
|
||||
builder.max_depth(max_depth).build_parallel().run(|| {
|
||||
let mut matcher = matcher.clone();
|
||||
let mut batch = Batch { tx: tx.clone(), items: Vec::with_capacity(256) };
|
||||
Box::new(move |entry| {
|
||||
if cancel.load(Ordering::Relaxed) {
|
||||
return WalkState::Quit;
|
||||
}
|
||||
let Ok(entry) = entry else { return WalkState::Continue };
|
||||
let Some(file_type) = entry.file_type() else { return WalkState::Continue };
|
||||
if file_type.is_dir() && max_depth.is_none_or(|max| entry.depth() < max) {
|
||||
// The walker drops ignored files unseen: list every file of a
|
||||
// walked directory; those the walker doesn't report are ignored.
|
||||
let Ok(children) = std::fs::read_dir(entry.path()) else { return WalkState::Continue };
|
||||
for child in children.flatten() {
|
||||
let path = child.path();
|
||||
if child.file_type().is_ok_and(|t| t.is_file())
|
||||
&& !Self::skip_name(&child.file_name().to_string_lossy())
|
||||
&& !glob_excluded(excludes, root, &path)
|
||||
&& let Ok(meta) = child.metadata()
|
||||
{
|
||||
batch.items.push(Found { path, mtime: mtime_of(&meta), size: meta.len(), ignored: true });
|
||||
}
|
||||
}
|
||||
} else if file_type.is_file()
|
||||
if entry.file_type().is_some_and(|t| t.is_file())
|
||||
&& let Ok(meta) = entry.metadata()
|
||||
&& let Ok(rel) = entry.path().strip_prefix(root)
|
||||
{
|
||||
let ignored = matcher.matched(rel, false).is_ignore();
|
||||
batch.items.push(Found {
|
||||
path: entry.into_path(),
|
||||
mtime: mtime_of(&meta),
|
||||
size: meta.len(),
|
||||
ignored: false,
|
||||
ignored,
|
||||
});
|
||||
}
|
||||
if batch.items.len() >= 256 && batch.tx.send(std::mem::take(&mut batch.items)).is_err() {
|
||||
@@ -371,17 +336,7 @@ impl PathFilter {
|
||||
})
|
||||
});
|
||||
drop(tx);
|
||||
// Each file comes once from its directory listing and, unless ignored, once from the walker.
|
||||
let mut by_path: HashMap<PathBuf, Found> = HashMap::new();
|
||||
for f in rx.into_iter().flatten() {
|
||||
match by_path.entry(f.path.clone()) {
|
||||
Entry::Occupied(mut e) => e.get_mut().ignored &= f.ignored,
|
||||
Entry::Vacant(e) => {
|
||||
e.insert(f);
|
||||
}
|
||||
}
|
||||
}
|
||||
by_path.into_values().collect()
|
||||
rx.into_iter().flatten().collect()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -426,23 +381,26 @@ mod tests {
|
||||
touch(&root, f);
|
||||
}
|
||||
std::fs::write(root.join(".gitignore"), "build/\n").unwrap();
|
||||
let filter =
|
||||
PathFilter::new(&root, &vec![].into(), &["**/node_modules".into(), "target".into(), "docs/**".into()]);
|
||||
let filter = PathFilter::new(
|
||||
&root,
|
||||
&vec![].into(),
|
||||
&["**/node_modules".into(), "target".into(), "/build".into(), "docs/**".into()],
|
||||
);
|
||||
let mut found: Vec<String> =
|
||||
filter.walk(&root, &AtomicBool::new(false)).iter().filter_map(|f| filter.rel(&f.path)).collect();
|
||||
found.sort();
|
||||
assert_eq!(found, vec![".github/workflows/ci.yml", ".gitignore", "src/a.rs", "src/deep/b.rs"]);
|
||||
|
||||
assert!(filter.is_excluded(&root.join("node_modules/y.js"), false));
|
||||
assert!(filter.is_excluded(&root.join("a/target/z.rs"), false));
|
||||
assert!(filter.is_excluded(&root.join("build/new.rs"), false));
|
||||
assert!(filter.is_excluded(&root.join(".git/HEAD"), false));
|
||||
assert!(filter.is_excluded(Path::new("/elsewhere/x.rs"), false));
|
||||
assert!(!filter.is_excluded(&root.join("src/new.rs"), false));
|
||||
assert!(filter.is_excluded(&root.join("node_modules/y.js")));
|
||||
assert!(filter.is_excluded(&root.join("a/target/z.rs")));
|
||||
assert!(filter.is_excluded(&root.join("build/new.rs")));
|
||||
assert!(filter.is_excluded(&root.join(".git/HEAD")));
|
||||
assert!(filter.is_excluded(Path::new("/elsewhere/x.rs")));
|
||||
assert!(!filter.is_excluded(&root.join("src/new.rs")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignored_files_are_listed_but_ignored_directories_are_not() {
|
||||
fn ignored_files_and_directories_are_listed_by_name_only() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(dir.path()).unwrap();
|
||||
for f in [
|
||||
@@ -488,11 +446,15 @@ src/local/
|
||||
let expected = [
|
||||
(".env", true),
|
||||
(".gitignore", false),
|
||||
("build/nested/deep.rs", true),
|
||||
("build/out.rs", true),
|
||||
("logs/app.log", true),
|
||||
("pkg/.gitignore", false),
|
||||
("pkg/gen.rs", true),
|
||||
("pkg/keep.rs", false),
|
||||
("src/a.rs", false),
|
||||
("src/debug.log", true),
|
||||
("src/local/secrets.json", true),
|
||||
];
|
||||
assert_eq!(found, expected.map(|(p, i)| (p.to_owned(), i)));
|
||||
|
||||
@@ -505,18 +467,15 @@ src/local/
|
||||
let top: Vec<String> = filter.list_dir(&root).iter().filter_map(|f| filter.rel(&f.path)).collect();
|
||||
assert!(top.iter().all(|p| !p.contains('/')), "{top:?}");
|
||||
|
||||
for (rel, excluded) in [
|
||||
(".env", false),
|
||||
("src/new.log", false),
|
||||
("src/new.rs", false),
|
||||
("build/x.rs", true),
|
||||
("logs/app.log", true),
|
||||
("src/local/x.json", true),
|
||||
] {
|
||||
assert_eq!(filter.is_excluded(&root.join(rel), false), excluded, "{rel}");
|
||||
for rel in
|
||||
[".env", "src/new.log", "src/new.rs", "build/x.rs", "logs/app.log", "src/local/x.json", "build", "src"]
|
||||
{
|
||||
assert!(!filter.is_excluded(&root.join(rel)), "{rel}");
|
||||
}
|
||||
assert!(filter.is_excluded(&root.join("build"), true));
|
||||
assert!(!filter.is_excluded(&root.join("src"), true));
|
||||
let listed = filter.list_dir(&root.join("src/local"));
|
||||
assert_eq!(listed.len(), 1);
|
||||
assert_eq!(listed[0].path, root.join("src/local/secrets.json"));
|
||||
assert!(listed[0].ignored);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -535,7 +494,7 @@ src/local/
|
||||
let mut found: Vec<String> =
|
||||
filter.walk(&root, &AtomicBool::new(false)).iter().filter_map(|f| filter.rel(&f.path)).collect();
|
||||
found.sort();
|
||||
assert_eq!(found, [".gitignore", "src/a.rs"]);
|
||||
assert_eq!(found, [".gitignore", "out/x.rs", "src/a.rs"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -555,12 +514,12 @@ src/local/
|
||||
.filter_map(|f| filter.rel(&f.path))
|
||||
.collect();
|
||||
found.sort();
|
||||
assert_eq!(found, ["shared-lib/.gitignore", "shared-lib/src/b.rs", "src/a.rs"]);
|
||||
assert_eq!(found, ["shared-lib/.gitignore", "shared-lib/out/x.rs", "shared-lib/src/b.rs", "src/a.rs"]);
|
||||
assert_eq!(filter.store_key(&shared.join("src/b.rs")), None, "extra roots are not persisted");
|
||||
assert_eq!(filter.store_key(&root.join("src/a.rs")).as_deref(), Some("src/a.rs"));
|
||||
assert!(!filter.is_excluded(&shared.join("src/new.rs"), false));
|
||||
assert!(filter.is_excluded(&shared.join("target/y.rs"), false));
|
||||
assert!(filter.is_excluded(&shared.join("out/y.rs"), false));
|
||||
assert!(!filter.is_excluded(&shared.join("src/new.rs")));
|
||||
assert!(filter.is_excluded(&shared.join("target/y.rs")));
|
||||
assert!(!filter.is_excluded(&shared.join("out/y.rs")));
|
||||
assert!(filter.same_config(&vec![shared.clone(), root.join("src")].into(), &["target".into()]));
|
||||
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
|
||||
}
|
||||
@@ -589,10 +548,49 @@ src/local/
|
||||
.filter_map(|f| filter.rel(&f.path))
|
||||
.collect();
|
||||
found.sort();
|
||||
assert_eq!(found, [".wt/feature/.gitignore", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]);
|
||||
assert_eq!(
|
||||
found,
|
||||
[".wt/feature/.gitignore", ".wt/feature/out/c.rs", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]
|
||||
);
|
||||
assert_eq!(filter.store_key(&nested.join("src/b.rs")), None, "extra roots are not persisted");
|
||||
assert!(!filter.is_excluded(&nested.join("src/new.rs"), false));
|
||||
assert!(filter.is_excluded(&nested.join("out/new.rs"), false));
|
||||
assert!(filter.is_excluded(&root.join(".wt/other/x.rs"), false));
|
||||
assert!(!filter.is_excluded(&nested.join("src/new.rs")));
|
||||
assert!(!filter.is_excluded(&nested.join("out/new.rs")));
|
||||
assert!(!filter.is_excluded(&root.join(".wt/other/x.rs")));
|
||||
let own_files = filter.walk(&nested, &AtomicBool::new(false));
|
||||
assert!(!own_files.iter().find(|f| f.path == nested.join("src/b.rs")).unwrap().ignored);
|
||||
assert!(own_files.iter().find(|f| f.path == nested.join("out/c.rs")).unwrap().ignored);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_exclusions_prune_filename_walks_and_watcher_subtrees() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(dir.path()).unwrap();
|
||||
// The caller supplies files.exclude and the project model's anchored
|
||||
// output/dependency/environment roots; ignored business folders stay in.
|
||||
let excluded = ["node_modules", "jvm/build", "rust/target", ".venv", "python/__pycache__", "private"];
|
||||
for folder in excluded {
|
||||
touch(&root, &format!("{folder}/nested/hidden.ts"));
|
||||
}
|
||||
touch(&root, "notes/nested/todo.ts");
|
||||
touch(&root, "internal/build/source.ts");
|
||||
std::fs::write(root.join(".gitignore"), "notes/\ninternal/\n").unwrap();
|
||||
let globs: Vec<String> = excluded.iter().map(|p| format!("/{p}")).collect();
|
||||
let filter = PathFilter::new(&root, &vec![].into(), &globs);
|
||||
let mut found = filter.walk(&root, &AtomicBool::new(false));
|
||||
found.sort_by(|a, b| a.path.cmp(&b.path));
|
||||
assert_eq!(
|
||||
found.iter().map(|f| filter.rel(&f.path).unwrap()).collect::<Vec<_>>(),
|
||||
[".gitignore", "internal/build/source.ts", "notes/nested/todo.ts"]
|
||||
);
|
||||
assert!(found[1..].iter().all(|f| f.ignored));
|
||||
let dirs = filter.dirs(&root);
|
||||
assert!(dirs.contains(&root.join("notes/nested")));
|
||||
for folder in excluded {
|
||||
let subtree = root.join(folder).join("nested");
|
||||
assert!(filter.is_excluded(&subtree));
|
||||
assert!(filter.walk(&subtree, &AtomicBool::new(false)).is_empty());
|
||||
assert!(filter.list_dir(&subtree).is_empty());
|
||||
assert!(!dirs.iter().any(|d| d.starts_with(root.join(folder))));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -400,15 +400,10 @@ impl ProjectIndex {
|
||||
|
||||
/// Boost for "recent files" ranking.
|
||||
/// Records a recently opened file; a virtual document's URI (library
|
||||
/// class) is kept verbatim, like IDEA lists library classes in Recent Files.
|
||||
/// class) is kept verbatim, and a file outside the project (a scratch file)
|
||||
/// by its absolute path.
|
||||
pub fn mark_recent(&self, path: &Path) {
|
||||
let path = match path.to_str() {
|
||||
Some(s) if ide_core::text::is_virtual_uri(s) => path.to_owned(),
|
||||
_ => match self.normalize(path) {
|
||||
Some(p) => p,
|
||||
None => return,
|
||||
},
|
||||
};
|
||||
let Some(path) = self.recent_key(path) else { return };
|
||||
{
|
||||
let mut r = self.shared.recent.lock();
|
||||
r.retain(|p| p != &path);
|
||||
@@ -420,13 +415,7 @@ impl ProjectIndex {
|
||||
|
||||
/// Drops a file from Recent Files (Delete in the ⌘E popup).
|
||||
pub fn remove_recent(&self, path: &Path) {
|
||||
let path = match path.to_str() {
|
||||
Some(s) if ide_core::text::is_virtual_uri(s) => path.to_owned(),
|
||||
_ => match self.normalize(path) {
|
||||
Some(p) => p,
|
||||
None => return,
|
||||
},
|
||||
};
|
||||
let Some(path) = self.recent_key(path) else { return };
|
||||
{
|
||||
let mut r = self.shared.recent.lock();
|
||||
let before = r.len();
|
||||
@@ -473,6 +462,20 @@ impl ProjectIndex {
|
||||
&self.root
|
||||
}
|
||||
|
||||
/// How Recent Files stores `path`: a virtual URI verbatim, a project file normalized,
|
||||
/// and an existing file outside the root canonicalized. Excluded files under the root
|
||||
/// are left out.
|
||||
fn recent_key(&self, path: &Path) -> Option<PathBuf> {
|
||||
if path.to_str().is_some_and(ide_core::text::is_virtual_uri) {
|
||||
return Some(path.to_owned());
|
||||
}
|
||||
if let Some(p) = self.normalize(path) {
|
||||
return Some(p);
|
||||
}
|
||||
let p = dunce::canonicalize(path).ok().filter(|p| p.is_file())?;
|
||||
(!p.starts_with(&self.root)).then_some(p)
|
||||
}
|
||||
|
||||
/// Absolute path inside the root (or a content root), or `None` for paths outside the project.
|
||||
fn normalize(&self, path: &Path) -> Option<PathBuf> {
|
||||
let filter = self.shared.filter();
|
||||
|
||||
@@ -57,6 +57,15 @@ fn files(idx: &ProjectIndex, q: &str) -> Vec<String> {
|
||||
idx.find_files(q, 20).into_iter().map(|m| m.rel_path).collect()
|
||||
}
|
||||
|
||||
fn assert_filename_only(idx: &ProjectIndex, path: &str) {
|
||||
assert!(files(idx, path).iter().any(|found| found == path), "{path} must be findable");
|
||||
let data = idx.shared.data.read();
|
||||
let entry = data.files.iter().flatten().find(|entry| entry.rel.as_ref() == path).unwrap();
|
||||
assert!(entry.ignored, "{path} must remain classified as ignored");
|
||||
assert_eq!(entry.hash, [0; 32], "{path} must not be content-hashed");
|
||||
assert_eq!(entry.sym_len, 0, "{path} must not have symbols");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exact_file_names_keep_all_source_candidates() {
|
||||
let f = Fixture::new(&[
|
||||
@@ -251,6 +260,26 @@ fn recent_files_skip_deleted_files_but_keep_virtual_documents() {
|
||||
assert_eq!(idx.recent_files(), vec![virt]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recent_files_keep_files_outside_the_project() {
|
||||
let fx = sample();
|
||||
let scratches = tempfile::tempdir().unwrap();
|
||||
let scratch = dunce::canonicalize(scratches.path()).unwrap().join("generated-requests.http");
|
||||
std::fs::write(&scratch, "GET http://localhost\n").unwrap();
|
||||
let app = fx.root.join("web/app.py");
|
||||
{
|
||||
let idx = fx.open();
|
||||
idx.mark_recent(&app);
|
||||
idx.mark_recent(&scratch);
|
||||
assert_eq!(idx.recent_files(), vec![scratch.clone(), app.clone()]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
}
|
||||
let idx = fx.open();
|
||||
assert_eq!(idx.recent_files(), vec![scratch.clone(), app.clone()], "persisted by absolute path");
|
||||
idx.remove_recent(&scratch);
|
||||
assert_eq!(idx.recent_files(), vec![app]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistence_skips_unchanged_files_on_reopen() {
|
||||
let fx = sample();
|
||||
@@ -348,7 +377,7 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
|
||||
let idx = fx.open();
|
||||
assert_eq!(files(&idx, ".env"), vec![".env"], "the reported case: a git-ignored root file");
|
||||
assert_eq!(files(&idx, "config.local"), vec!["src/config.local.ts"]);
|
||||
assert!(files(&idx, "bundle").is_empty(), "ignored directories stay out");
|
||||
assert_eq!(files(&idx, "bundle"), ["dist/bundle.js"]);
|
||||
assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty(), "ignored files are listed by name only");
|
||||
assert_eq!(symbols(&idx, "app", SymbolFilter::All), vec!["app"]);
|
||||
|
||||
@@ -359,7 +388,8 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert_eq!(files(&idx, "fresh.local"), vec!["src/fresh.local.ts"]);
|
||||
assert!(symbols(&idx, "freshLocal", SymbolFilter::All).is_empty());
|
||||
assert!(files(&idx, "more.js").is_empty());
|
||||
assert_eq!(files(&idx, "more.js"), ["dist/more.js"]);
|
||||
assert!(symbols(&idx, "more", SymbolFilter::All).is_empty());
|
||||
|
||||
// Nested ignore files apply to watcher updates as they do to the scan.
|
||||
fx.write("pkg/.gitignore", "gen.ts\n");
|
||||
@@ -386,6 +416,93 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
|
||||
assert_eq!(files(&idx, "bundle"), vec!["dist/bundle.js"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn go_to_file_finds_files_in_ignored_folders() {
|
||||
let fx = Fixture::new(&[
|
||||
(".git/info/exclude", "/notes/\n"),
|
||||
(".gitignore", "/local/\n"),
|
||||
(".ignore", "/scratch/\n"),
|
||||
("pkg/.gitignore", "private/\n"),
|
||||
("notes/todo.ts", "export class IgnoredNote {}\n"),
|
||||
("notes/deep/other.ts", "export class IgnoredOther {}\n"),
|
||||
("local/config.ts", "export class IgnoredConfig {}\n"),
|
||||
("scratch/draft.ts", "export class IgnoredDraft {}\n"),
|
||||
("pkg/private/data.ts", "export class IgnoredData {}\n"),
|
||||
("pkg/public.ts", "export class PublicThing {}\n"),
|
||||
("node_modules/dep.ts", "export class Dependency {}\n"),
|
||||
("target/gen.ts", "export class Generated {}\n"),
|
||||
]);
|
||||
std::fs::create_dir(fx.root.join("notes/empty")).unwrap();
|
||||
let idx = fx.open();
|
||||
for path in ["notes/todo.ts", "notes/deep/other.ts", "local/config.ts", "scratch/draft.ts", "pkg/private/data.ts"] {
|
||||
assert_filename_only(&idx, path);
|
||||
}
|
||||
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
|
||||
assert_eq!(symbols(&idx, "PublicThing", SymbolFilter::Types), ["PublicThing"]);
|
||||
assert!(files(&idx, "node_modules/dep.ts").is_empty());
|
||||
assert!(files(&idx, "target/gen.ts").is_empty());
|
||||
|
||||
let fresh = fx.write("pkg/private/new.ts", "export class IgnoredFresh {}\n");
|
||||
fx.write("notes/new/deep.ts", "export class IgnoredDeep {}\n");
|
||||
let dependency = fx.write("node_modules/new.ts", "export class DependencyFresh {}\n");
|
||||
idx.update(&[fresh.clone(), fx.root.join("notes/new"), dependency], &[]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert_filename_only(&idx, "pkg/private/new.ts");
|
||||
assert_filename_only(&idx, "notes/new/deep.ts");
|
||||
assert!(files(&idx, "node_modules/new.ts").is_empty());
|
||||
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
|
||||
|
||||
std::fs::remove_file(&fresh).unwrap();
|
||||
std::fs::remove_dir_all(fx.root.join("notes/deep")).unwrap();
|
||||
idx.update(&[], &[fresh, fx.root.join("notes/deep")]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert!(files(&idx, "pkg/private/new.ts").is_empty());
|
||||
assert!(files(&idx, "notes/deep/other.ts").is_empty());
|
||||
drop(idx);
|
||||
|
||||
// New files in populated and previously empty ignored directories invalidate the manifest.
|
||||
let idx = fx.open();
|
||||
assert_eq!(files(&idx, "notes/todo.ts"), ["notes/todo.ts"]);
|
||||
drop(idx);
|
||||
fx.write("notes/offline.ts", "export class IgnoredOffline {}\n");
|
||||
fx.write("notes/empty/offline.ts", "export class IgnoredEmptyOffline {}\n");
|
||||
let idx = fx.open();
|
||||
assert_filename_only(&idx, "notes/offline.ts");
|
||||
assert_filename_only(&idx, "notes/empty/offline.ts");
|
||||
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_content_roots_keep_their_own_ignored_files_filename_only() {
|
||||
let fx = Fixture::new(&[("src/app.ts", "export class App {}\n")]);
|
||||
let shared = fx._dir.path().join("shared");
|
||||
std::fs::create_dir_all(shared.join("private")).unwrap();
|
||||
std::fs::create_dir_all(shared.join("node_modules")).unwrap();
|
||||
std::fs::write(shared.join(".ignore"), "private/\n").unwrap();
|
||||
std::fs::write(shared.join("private/local.ts"), "export class SharedIgnored {}\n").unwrap();
|
||||
std::fs::write(shared.join("public.ts"), "export class SharedPublic {}\n").unwrap();
|
||||
std::fs::write(shared.join("node_modules/dep.ts"), "export class SharedDependency {}\n").unwrap();
|
||||
let idx = fx.open();
|
||||
idx.set_scope(vec![shared.clone()], vec!["**/node_modules".into(), "**/target".into()]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert_filename_only(&idx, "shared/private/local.ts");
|
||||
assert_eq!(symbols(&idx, "SharedPublic", SymbolFilter::Types), ["SharedPublic"]);
|
||||
assert!(symbols(&idx, "SharedIgnored", SymbolFilter::All).is_empty());
|
||||
assert!(files(&idx, "shared/node_modules/dep.ts").is_empty());
|
||||
|
||||
std::fs::create_dir(shared.join("private/new")).unwrap();
|
||||
std::fs::write(shared.join("private/new/fresh.ts"), "export class SharedFresh {}\n").unwrap();
|
||||
idx.update(&[shared.join("private/new")], &[]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert_filename_only(&idx, "shared/private/new/fresh.ts");
|
||||
assert!(symbols(&idx, "SharedFresh", SymbolFilter::All).is_empty());
|
||||
std::fs::remove_dir_all(shared.join("private/new")).unwrap();
|
||||
idx.update(&[], &[shared.join("private/new")]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert!(files(&idx, "shared/private/new/fresh.ts").is_empty());
|
||||
assert_filename_only(&idx, "shared/private/local.ts");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn second_window_on_same_project_works_in_memory() {
|
||||
let fx = sample();
|
||||
@@ -834,13 +951,19 @@ fn warm_start_detects_changed_ignore_rules() {
|
||||
let f = Fixture::new(&[("sub/generated/a.rs", "fn a() {}\n"), (".git/HEAD", "ref: refs/heads/main\n")]);
|
||||
f.write("sub/.gitignore", "");
|
||||
let idx = f.open();
|
||||
assert_eq!(idx.status().files, 2, "generated/a.rs plus .gitignore itself");
|
||||
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
|
||||
drop(idx);
|
||||
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
f.write("sub/.gitignore", "generated/\n");
|
||||
let idx = f.open();
|
||||
assert_eq!(idx.status().files, 1, "an updated ignore rule invalidates the warm snapshot");
|
||||
assert_filename_only(&idx, "sub/generated/a.rs");
|
||||
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "changed rules invalidate cached symbols");
|
||||
drop(idx);
|
||||
|
||||
f.write("sub/.gitignore", "");
|
||||
let idx = f.open();
|
||||
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unchanged contents are parsed after unignoring");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -851,20 +974,24 @@ fn warm_start_detects_changed_ignore_rules_above_the_project() {
|
||||
std::fs::create_dir_all(repo.join(".git/info")).unwrap();
|
||||
std::fs::write(repo.join(".git/HEAD"), "ref: refs/heads/main\n").unwrap();
|
||||
let idx = f.open();
|
||||
assert_eq!(idx.status().files, 2);
|
||||
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
|
||||
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
|
||||
drop(idx);
|
||||
|
||||
std::fs::write(repo.join(".gitignore"), "proj/generated/\n").unwrap();
|
||||
let idx = f.open();
|
||||
assert_eq!(idx.status().files, 1, "a new ignore file above the project invalidates the warm snapshot");
|
||||
assert_filename_only(&idx, "generated/a.rs");
|
||||
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "new ancestor rules invalidate cached symbols");
|
||||
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
|
||||
drop(idx);
|
||||
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
std::fs::write(repo.join(".gitignore"), "").unwrap();
|
||||
std::fs::write(repo.join(".git/info/exclude"), "proj/src/\n").unwrap();
|
||||
let idx = f.open();
|
||||
assert_eq!(idx.status().files, 1, "so do the enclosing repository's changed rules");
|
||||
assert!(!symbols(&idx, "a", SymbolFilter::All).is_empty());
|
||||
assert_filename_only(&idx, "src/b.rs");
|
||||
assert!(symbols(&idx, "b", SymbolFilter::All).is_empty());
|
||||
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unignored contents are re-parsed unchanged");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -881,12 +1008,20 @@ fn warm_start_detects_a_changed_exclude_file_of_a_linked_worktree() {
|
||||
std::fs::write(worktree.join("commondir"), "../..\n").unwrap();
|
||||
std::fs::write(f.root.join(".git"), format!("gitdir: {}\n", worktree.display())).unwrap();
|
||||
let idx = f.open();
|
||||
assert_eq!(idx.status().files, 2);
|
||||
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
|
||||
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
|
||||
drop(idx);
|
||||
|
||||
std::fs::write(main.join("info/exclude"), "generated/\n").unwrap();
|
||||
let idx = f.open();
|
||||
assert_eq!(idx.status().files, 1, "the shared exclude file invalidates the warm snapshot");
|
||||
assert_filename_only(&idx, "generated/a.rs");
|
||||
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "shared exclude rules invalidate cached symbols");
|
||||
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
|
||||
drop(idx);
|
||||
|
||||
std::fs::write(main.join("info/exclude"), "").unwrap();
|
||||
let idx = f.open();
|
||||
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unignored contents are re-parsed unchanged");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -919,19 +1054,24 @@ fn rule_changes_refresh_only_the_affected_index_subtree() {
|
||||
fx.write(rule, "");
|
||||
let idx = fx.open();
|
||||
assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
|
||||
assert_eq!(symbols(&idx, "generated", SymbolFilter::All), ["generated"]);
|
||||
assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
|
||||
fx.write(rule, "generated/\nlocal.ts\n");
|
||||
let dirs = [fx.root.join(subtree)];
|
||||
idx.ignore_rules_changed(&dirs);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert!(files(&idx, "file.ts").is_empty(), "{rule}: ignored directory remained indexed");
|
||||
assert_eq!(files(&idx, "local.ts"), ["sub/local.ts"]);
|
||||
assert_filename_only(&idx, "sub/generated/file.ts");
|
||||
assert!(symbols(&idx, "generated", SymbolFilter::All).is_empty(), "{rule}: ignored symbols remained indexed");
|
||||
assert_filename_only(&idx, "sub/local.ts");
|
||||
assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty());
|
||||
assert_eq!(files(&idx, "keep.ts"), ["other/keep.ts"]);
|
||||
assert_eq!(symbols(&idx, "keep", SymbolFilter::All), ["keep"]);
|
||||
|
||||
fx.write(rule, "");
|
||||
idx.ignore_rules_changed(&dirs);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
|
||||
assert_eq!(symbols(&idx, "generated", SymbolFilter::All), ["generated"]);
|
||||
assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
|
||||
// The cached root matcher must also follow the rules for later watcher updates.
|
||||
let fresh = fx.write("sub/generated/new.ts", "export function fresh() {}\n");
|
||||
@@ -946,7 +1086,7 @@ fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
|
||||
let fx = Fixture::new(&[
|
||||
(".git/HEAD", "ref: refs/heads/main\n"),
|
||||
(".git/info/exclude", ""),
|
||||
("member/generated/item.txt", "x"),
|
||||
("member/generated/item.rs", "fn member_item() {}\n"),
|
||||
]);
|
||||
let idx = ProjectIndex::open(
|
||||
&fx.root,
|
||||
@@ -959,15 +1099,18 @@ fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
|
||||
)
|
||||
.unwrap();
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
|
||||
assert_eq!(files(&idx, "item.rs"), ["member/generated/item.rs"]);
|
||||
assert_eq!(symbols(&idx, "member_item", SymbolFilter::All), ["member_item"]);
|
||||
fx.write(".git/info/exclude", "generated/\n");
|
||||
idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert!(files(&idx, "item.txt").is_empty());
|
||||
assert_filename_only(&idx, "member/generated/item.rs");
|
||||
assert!(symbols(&idx, "member_item", SymbolFilter::All).is_empty());
|
||||
fx.write(".git/info/exclude", "");
|
||||
idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
|
||||
assert_eq!(files(&idx, "item.rs"), ["member/generated/item.rs"]);
|
||||
assert_eq!(symbols(&idx, "member_item", SymbolFilter::All), ["member_item"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -591,7 +591,7 @@ impl Shared {
|
||||
let update_elapsed = update_started.elapsed();
|
||||
let snapshot_started = Instant::now();
|
||||
if let Some(store) = &self.store {
|
||||
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
|
||||
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.recent_key(p)).collect();
|
||||
let d = self.data.read();
|
||||
let snapshot_started = Instant::now();
|
||||
if let Err(e) = store.save_snapshot(&d, &filter, guard) {
|
||||
@@ -926,7 +926,7 @@ impl Shared {
|
||||
continue;
|
||||
}
|
||||
let Ok(meta) = std::fs::symlink_metadata(&path) else { continue };
|
||||
if filter.is_excluded(&path, meta.is_dir()) {
|
||||
if filter.is_excluded(&path) {
|
||||
continue;
|
||||
}
|
||||
if meta.is_dir() {
|
||||
@@ -976,7 +976,7 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
if save_recent && let Some(store) = &self.store {
|
||||
let rels: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
|
||||
let rels: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.recent_key(p)).collect();
|
||||
if let Err(e) = store.save_recent(&rels) {
|
||||
tracing::warn!("index cache: saving recent files failed: {e}");
|
||||
}
|
||||
|
||||
@@ -407,18 +407,14 @@ impl Peer {
|
||||
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);
|
||||
cmd.current_dir(cwd)
|
||||
.envs(ide_core::process::shell_env_in(cwd))
|
||||
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())));
|
||||
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))
|
||||
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
cmd.args(args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true);
|
||||
let mut child = cmd.spawn()?;
|
||||
let stdin = child.stdin.take().ok_or_else(|| std::io::Error::other("child stdin unavailable"))?;
|
||||
let stdout = child.stdout.take().ok_or_else(|| std::io::Error::other("child stdout unavailable"))?;
|
||||
|
||||
@@ -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, PythonClassFacts, PythonFacts, PythonMethodFacts};
|
||||
pub use syntax::{MethodBody, PhpAlignment, PythonClassFacts, PythonFacts, PythonMethodFacts};
|
||||
|
||||
/// Parsed form of `languages/<id>.toml`. Backend-only; the UI gets [`LanguageInfo`].
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
|
||||
@@ -10,6 +10,7 @@ mod inheritance;
|
||||
pub(crate) mod lines;
|
||||
mod literals;
|
||||
mod outline;
|
||||
mod php_align;
|
||||
mod python_facts;
|
||||
mod rst;
|
||||
mod selection;
|
||||
@@ -28,6 +29,7 @@ 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;
|
||||
|
||||
@@ -0,0 +1,368 @@
|
||||
//! 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",
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -65,6 +65,28 @@ pub(crate) fn lenient_diagnostics(server: &str, items: Value) -> Vec<lsp::Diagno
|
||||
parsed
|
||||
}
|
||||
|
||||
/// rust-analyzer publishes its own analysis next to `cargo check`'s (flycheck): one type
|
||||
/// mismatch then arrives as `rust-analyzer(E0308)` and `rustc(E0308)`. Its own entry is
|
||||
/// dropped when the compiler reports the same code and severity over an overlapping range.
|
||||
fn drop_compiler_duplicates(diagnostics: &mut Vec<lsp::Diagnostic>) {
|
||||
let overlaps = |a: &lsp::Range, b: &lsp::Range| a.start <= b.end && b.start <= a.end;
|
||||
let compiler: Vec<(lsp::Range, Option<lsp::NumberOrString>, Option<lsp::DiagnosticSeverity>)> = diagnostics
|
||||
.iter()
|
||||
.filter(|d| d.source.as_deref() == Some("rustc") && d.code.is_some())
|
||||
.map(|d| (d.range, d.code.clone(), d.severity))
|
||||
.collect();
|
||||
if compiler.is_empty() {
|
||||
return;
|
||||
}
|
||||
diagnostics.retain(|d| {
|
||||
d.source.as_deref() != Some("rust-analyzer")
|
||||
|| d.code.is_none()
|
||||
|| !compiler
|
||||
.iter()
|
||||
.any(|(range, code, severity)| code == &d.code && severity == &d.severity && overlaps(range, &d.range))
|
||||
});
|
||||
}
|
||||
|
||||
impl ClientHandler {
|
||||
pub fn new(mgr: Weak<LspManager>, server: Arc<Server>, generation: u64) -> Self {
|
||||
Self { mgr, server, generation }
|
||||
@@ -293,11 +315,20 @@ impl ClientHandler {
|
||||
}
|
||||
};
|
||||
params.diagnostics = lenient_diagnostics(&self.server.name, raw.unwrap_or(Value::Null));
|
||||
drop_compiler_duplicates(&mut params.diagnostics);
|
||||
let Some(path) = uri_to_path(params.uri.as_str())
|
||||
.or_else(|| crate::notebook::is_cell_uri(params.uri.as_str()).then(|| PathBuf::from(params.uri.as_str())))
|
||||
else {
|
||||
return;
|
||||
};
|
||||
if self.server.name == crate::compose::SERVER {
|
||||
// Maven resource-filtering placeholders (`@profileActive@`) parse as invalid
|
||||
// YAML but are replaced before the file is ever read: their parser error is noise.
|
||||
let text = mgr.docs.lock().values().find(|d| d.path == path).map(|d| d.text.as_str().to_owned());
|
||||
if let Some(text) = text {
|
||||
params.diagnostics.retain(|d| !crate::maven_placeholder::false_positive(&text, d));
|
||||
}
|
||||
}
|
||||
if self.server.name == "jdtls"
|
||||
&& let Some(failure) = crate::jdtls::build_plan_failure(&path, &self.server.root, ¶ms.diagnostics)
|
||||
{
|
||||
@@ -435,6 +466,14 @@ impl ClientHandler {
|
||||
.find_map(|base| section.split('.').try_fold(base, |v, key| v.get(key)))
|
||||
.cloned()
|
||||
.unwrap_or(Value::Null),
|
||||
None if self.server.name == "eslint" => {
|
||||
let mut settings = options.clone();
|
||||
settings["workspaceFolder"] = json!({
|
||||
"uri": crate::uri::path_to_uri(&self.server.root),
|
||||
"name": self.server.root.file_name().map_or_else(|| "root".into(), |name| name.to_string_lossy().into_owned()),
|
||||
});
|
||||
settings
|
||||
}
|
||||
None => options.clone(),
|
||||
})
|
||||
.collect(),
|
||||
@@ -693,6 +732,28 @@ mod tests {
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
#[test]
|
||||
fn rust_analyzer_s_own_entry_yields_to_the_compiler_s_for_the_same_error() {
|
||||
let diagnostic = |source: &str, code: &str, line: u32, severity| lsp::Diagnostic {
|
||||
range: lsp::Range::new(lsp::Position::new(line, 21), lsp::Position::new(line, 27)),
|
||||
severity: Some(severity),
|
||||
code: Some(lsp::NumberOrString::String(code.into())),
|
||||
source: Some(source.into()),
|
||||
message: format!("{source} {code}"),
|
||||
..Default::default()
|
||||
};
|
||||
let error = lsp::DiagnosticSeverity::ERROR;
|
||||
let mut items = vec![
|
||||
diagnostic("rust-analyzer", "E0308", 1, error),
|
||||
diagnostic("rustc", "E0308", 1, error),
|
||||
diagnostic("rust-analyzer", "E0308", 5, error),
|
||||
diagnostic("rust-analyzer", "unused_variables", 1, lsp::DiagnosticSeverity::WARNING),
|
||||
];
|
||||
drop_compiler_duplicates(&mut items);
|
||||
let left: Vec<_> = items.iter().map(|d| (d.message.as_str(), d.range.start.line)).collect();
|
||||
assert_eq!(left, [("rustc E0308", 1), ("rust-analyzer E0308", 5), ("rust-analyzer unused_variables", 1)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tsserver_aborts_are_out_of_memory() {
|
||||
assert!(tsserver_ran_out_of_memory("TSServer exited. Code: 134. Signal: null"));
|
||||
|
||||
@@ -23,6 +23,7 @@ pub(crate) mod configuration;
|
||||
mod extract_interface;
|
||||
mod formatter;
|
||||
mod generated;
|
||||
pub(crate) use generated::is_processor_output;
|
||||
mod hierarchy;
|
||||
pub(crate) mod jvm_inspect;
|
||||
mod move_refactoring;
|
||||
|
||||
@@ -25,6 +25,18 @@ pub(crate) struct GeneratedScan {
|
||||
pub roots: Vec<GeneratedRoot>,
|
||||
}
|
||||
|
||||
/// Whether `path` is in (or is) an annotation-processor output folder:
|
||||
/// `generated-sources/annotations` or `generated-test-sources/test-annotations`. jdtls
|
||||
/// runs the processors itself and writes there; javac (a Maven build) writes the same
|
||||
/// files, and jdtls must not take those as edits (#4128).
|
||||
pub(crate) fn is_processor_output(path: &Path) -> bool {
|
||||
let parts: Vec<_> = path.components().map(|c| c.as_os_str()).collect();
|
||||
parts.windows(2).any(|w| {
|
||||
(w[0] == "generated-sources" && w[1] == "annotations")
|
||||
|| (w[0] == "generated-test-sources" && w[1] == "test-annotations")
|
||||
})
|
||||
}
|
||||
|
||||
/// Generated Java source folders under `root` (a reactor or one module).
|
||||
pub(crate) fn scan(root: &Path) -> GeneratedScan {
|
||||
let mut modules = Vec::new();
|
||||
@@ -260,6 +272,20 @@ fn plugins_removed(build: &str) -> String {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn recognizes_annotation_processor_output() {
|
||||
for (path, expected) in [
|
||||
("/p/m/target/generated-sources/annotations/com/x/FooMappingImpl.java", true),
|
||||
("/p/m/target/generated-sources/annotations", true),
|
||||
("/p/m/build-out/generated-test-sources/test-annotations/com/x/T.java", true),
|
||||
("/p/m/target/generated-sources/protobuf/java/com/x/Hello.java", false),
|
||||
("/p/m/src/main/java/annotations/Foo.java", false),
|
||||
("/p/m/target/classes/com/x/FooMappingImpl.class", false),
|
||||
] {
|
||||
assert_eq!(is_processor_output(Path::new(path)), expected, "{path}");
|
||||
}
|
||||
}
|
||||
|
||||
fn write(root: &Path, rel: &str, text: &str) {
|
||||
let path = root.join(rel);
|
||||
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
|
||||
@@ -160,12 +160,13 @@ const DEAD_SHIM_MESSAGES: &[&str] =
|
||||
/// server that dies like that on every start is missing (an install hint), not crashing.
|
||||
/// Anything but a clear "not installed" answer from the shim counts as working.
|
||||
fn reject_dead_shim(binary: PathBuf, search: &OsStr, root: &Path) -> Option<PathBuf> {
|
||||
if !binary.parent().is_some_and(|d| d.file_name().is_some_and(|n| n == "shims")) {
|
||||
if binary.parent().and_then(Path::file_name) != Some(OsStr::new("shims")) {
|
||||
return Some(binary);
|
||||
}
|
||||
let Ok(mut child) = ide_core::process::prepare(std::process::Command::new(&binary).current_dir(root))
|
||||
let mut cmd = std::process::Command::new(&binary);
|
||||
cmd.current_dir(root).env("PATH", search);
|
||||
let Ok(mut child) = ide_core::process::prepare(&mut cmd)
|
||||
.arg("--version")
|
||||
.env("PATH", search)
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::null())
|
||||
.stderr(std::process::Stdio::piped())
|
||||
|
||||
@@ -25,6 +25,7 @@ mod kotlin_lsp;
|
||||
mod launch;
|
||||
mod library_source;
|
||||
mod loading;
|
||||
mod maven_placeholder;
|
||||
mod message_requests;
|
||||
mod notebook;
|
||||
mod phoxite;
|
||||
@@ -1833,8 +1834,11 @@ impl LspManager {
|
||||
/// the same class from its Java model instead, decompiled with method bodies and navigable.
|
||||
/// Its documents belong to jdtls ([`Self::virtual_document`] records it).
|
||||
async fn jdt_library_classes(&self, snap: &DocSnap, pos: Pos, locs: Vec<Location>) -> Vec<Location> {
|
||||
let jar_class = |l: &Location| l.uri.as_deref().is_some_and(|u| u.starts_with("jar:") && u.ends_with(".class"));
|
||||
if !locs.iter().any(jar_class)
|
||||
let lib_class = |u: &str| {
|
||||
(u.starts_with("jar:") && u.ends_with(".class"))
|
||||
|| (u.starts_with("jdt://contents/") && u.contains(".class"))
|
||||
};
|
||||
if !locs.iter().any(|l| l.uri.as_deref().is_some_and(lib_class))
|
||||
|| !self.servers.lock().iter().any(|s| s.name == jdtls::SERVER && s.running().is_some())
|
||||
{
|
||||
return locs;
|
||||
@@ -1842,27 +1846,54 @@ impl LspManager {
|
||||
let name = library_source::identifier_at(snap.text.line(pos.line as usize), pos.col).map(str::to_owned);
|
||||
let mut out = Vec::with_capacity(locs.len());
|
||||
for loc in locs {
|
||||
let entry = loc.uri.as_deref().filter(|_| jar_class(&loc)).and_then(library_source::parse);
|
||||
let Some(entry) = entry else {
|
||||
let Some(original) = loc.uri.as_deref().filter(|u| lib_class(u)) else {
|
||||
out.push(loc);
|
||||
continue;
|
||||
};
|
||||
// The Kotlin server may name the jar by another path than jdtls (its own copy of a
|
||||
// `system`-scope jar): its stub would be all the user gets, so take jdtls' only class
|
||||
// of that name.
|
||||
let uri = match self.archive_class(entry.jar, entry.entry, true).await {
|
||||
Ok(uri) => uri,
|
||||
Err(e) => {
|
||||
tracing::info!("library class stays a stub: {}", e.message);
|
||||
let jdt = original.starts_with("jdt:");
|
||||
let uri = if !jdt {
|
||||
let Some(entry) = library_source::parse(original) else {
|
||||
out.push(loc);
|
||||
continue;
|
||||
};
|
||||
// The Kotlin server may name the jar by another path than jdtls (its own copy of a
|
||||
// `system`-scope jar): its stub would be all the user gets, so take jdtls' only class
|
||||
// of that name.
|
||||
match self.archive_class(entry.jar, entry.entry, true).await {
|
||||
Ok(uri) => uri,
|
||||
Err(e) => {
|
||||
tracing::info!("library class stays a stub: {}", e.message);
|
||||
out.push(loc);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
original.to_owned()
|
||||
};
|
||||
let range = match (&name, self.virtual_document(&uri).await) {
|
||||
(Some(name), Ok(doc)) => library_source::declaration_range(&doc.text, name),
|
||||
let doc = self.virtual_document(&uri).await.ok();
|
||||
let range = match (&name, &doc) {
|
||||
// jdtls' own class: its range is exact (overloads included) unless it maps a
|
||||
// Lombok-generated member onto the annotation or class header, which doesn't
|
||||
// name the member; only then look the declaration up in the source.
|
||||
(Some(name), Some(doc)) if jdt => {
|
||||
let line = doc.text.lines().nth(loc.range.start.line as usize).unwrap_or_default();
|
||||
if library_source::identifier_at(line, loc.range.start.col) == Some(name.as_str()) {
|
||||
loc.range
|
||||
} else {
|
||||
Some(library_source::declaration_range(&doc.text, name))
|
||||
.filter(|r| *r != Range::default())
|
||||
.unwrap_or(loc.range)
|
||||
}
|
||||
}
|
||||
(Some(name), Some(doc)) => library_source::declaration_range(&doc.text, name),
|
||||
_ if jdt => loc.range,
|
||||
_ => Range::default(),
|
||||
};
|
||||
out.push(Location { path: uri.clone().into(), range, uri: Some(uri) });
|
||||
out.push(if jdt {
|
||||
Location { range, ..loc }
|
||||
} else {
|
||||
Location { path: uri.clone().into(), range, uri: Some(uri) }
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -3026,7 +3057,12 @@ impl LspManager {
|
||||
for s in servers {
|
||||
let Some(run) = s.running() else { continue };
|
||||
let open = open.get(&(s.id, run.generation)).filter(|_| run.caps.read().sync != SyncKind::None);
|
||||
// jdtls owns its annotation-processor output; javac's copy of those files is not an edit.
|
||||
let jdtls = s.name == "jdtls";
|
||||
let send = |p: &PathBuf, change: Change| {
|
||||
if jdtls && jdtls::is_processor_output(p) {
|
||||
return false;
|
||||
}
|
||||
change == Change::Deleted
|
||||
|| !open
|
||||
.is_some_and(|paths| paths.contains(p) || canonical.get(p).is_some_and(|c| paths.contains(c)))
|
||||
|
||||
@@ -180,6 +180,7 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
|
||||
const KEYWORDS: [&str; 9] = ["fun", "class", "interface", "object", "val", "var", "typealias", "enum", "record"];
|
||||
let is_ident = |c: char| c.is_alphanumeric() || c == '_' || c == '$';
|
||||
let mut fallback = None;
|
||||
let mut field = None;
|
||||
let mut block_comment = false;
|
||||
for (line_no, line) in text.lines().enumerate() {
|
||||
let trimmed = line.trim_start();
|
||||
@@ -223,9 +224,40 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
|
||||
if java_member && fallback.is_none() {
|
||||
fallback = Some(range);
|
||||
}
|
||||
// A Java field (`private String name;`, `int age = 5;`): Lombok sources declare only
|
||||
// the field, the accessors exist solely in the compiled class. A method of that name
|
||||
// still wins, so a same-named local declared before it is not taken.
|
||||
let java_field = matches!(line[end..].trim_start().chars().next(), Some(';' | '=' | ','))
|
||||
&& !head.trim_end().ends_with('.')
|
||||
&& !head.trim().is_empty()
|
||||
&& !head.contains(['=', '('])
|
||||
&& !words.iter().any(|w| matches!(*w, "return" | "throw" | "new" | "yield" | "assert"));
|
||||
if java_field && field.is_none() {
|
||||
field = Some(range);
|
||||
}
|
||||
}
|
||||
}
|
||||
fallback.unwrap_or_default()
|
||||
if let Some(range) = fallback.or(field) {
|
||||
return range;
|
||||
}
|
||||
accessor_field(name).map(|field| declaration_range(text, &field)).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// The field a Lombok/bean accessor stands for (`getName`/`setName` → `name`,
|
||||
/// `isActive` → `active`); `None` for names that are not accessors.
|
||||
fn accessor_field(name: &str) -> Option<String> {
|
||||
let rest = ["get", "set", "is"]
|
||||
.iter()
|
||||
.find_map(|p| name.strip_prefix(p))
|
||||
.filter(|r| r.chars().next().is_some_and(|c| c.is_uppercase()))?;
|
||||
let mut chars = rest.chars();
|
||||
let first = chars.next()?;
|
||||
// Bean convention: `getURL` → `URL`, `getName` → `name`.
|
||||
if rest.chars().nth(1).is_some_and(|c| c.is_uppercase()) {
|
||||
Some(rest.to_owned())
|
||||
} else {
|
||||
Some(first.to_lowercase().collect::<String>() + chars.as_str())
|
||||
}
|
||||
}
|
||||
|
||||
/// The identifier around `col` (UTF-16) of `line`.
|
||||
@@ -588,6 +620,35 @@ mod tests {
|
||||
assert_eq!(declared_package("class A"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lombok_accessors_and_java_fields_locate_the_field() {
|
||||
// Lombok sources declare only the field; the accessors exist only in the
|
||||
// compiled class, so navigation must fall back to the underlying field.
|
||||
let lombok = "package example.entity;\n\nimport lombok.Getter;\nimport lombok.Setter;\n\n@Getter\n@Setter\npublic class UserEntity {\n private String name;\n private int age;\n private boolean active;\n}\n";
|
||||
for (name, line, col) in [
|
||||
("getName", 8, 19),
|
||||
("setName", 8, 19),
|
||||
("name", 8, 19),
|
||||
("getAge", 9, 16),
|
||||
("isActive", 10, 20),
|
||||
("active", 10, 20),
|
||||
] {
|
||||
let r = declaration_range(lombok, name);
|
||||
assert_eq!((r.start.line, r.start.col), (line, col), "{name}");
|
||||
}
|
||||
// An explicitly declared accessor still wins over the field.
|
||||
let plain = "class Plain {\n private String name;\n public String getName() { return name; }\n}\n";
|
||||
assert_eq!(declaration_range(plain, "getName").start.line, 2);
|
||||
// Initialized fields count; a method beats a same-named local declared before it.
|
||||
let init = "class Init {\n private int count = 0;\n void a() {\n int size = 1;\n }\n int size() { return 2; }\n}\n";
|
||||
assert_eq!(declaration_range(init, "getCount").start.line, 1);
|
||||
assert_eq!(declaration_range(init, "size").start.line, 5);
|
||||
// Bean convention keeps acronyms; non-accessors are not remapped.
|
||||
assert_eq!(accessor_field("getURL").as_deref(), Some("URL"));
|
||||
assert_eq!(accessor_field("getter"), None);
|
||||
assert_eq!(declaration_range(lombok, "missing"), Range::default());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn locates_declarations_in_kotlin_and_java_sources() {
|
||||
let at = |text: &str, name: &str| {
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
//! `@property@` placeholders in YAML resources: Maven resource filtering replaces
|
||||
//! them before the file is ever read as YAML, so Spring projects use them unquoted
|
||||
//! (`spring.profiles.active: @profileActive@`). The YAML spec reserves `@` and the
|
||||
//! `yaml` parser behind `yaml-language-server` therefore reports
|
||||
//! "Plain value cannot start with reserved character @" for every one of them.
|
||||
//! The diagnostic is dropped when the reported scalar is exactly a Maven
|
||||
//! placeholder; anything else the parser flags keeps showing.
|
||||
|
||||
use lsp_types as lsp;
|
||||
|
||||
const RESERVED_AT: &str = "Plain value cannot start with reserved character @";
|
||||
|
||||
/// Whether `diagnostic` is the reserved-`@` parser error on a scalar whose text in
|
||||
/// `text` is exactly a Maven placeholder (`@token@`).
|
||||
pub(crate) fn false_positive(text: &str, diagnostic: &lsp::Diagnostic) -> bool {
|
||||
diagnostic.message == RESERVED_AT && placeholder_at(text, &diagnostic.range).is_some()
|
||||
}
|
||||
|
||||
/// The name between the `@`s of the diagnostic range, when it covers one whole placeholder.
|
||||
fn placeholder_at(text: &str, range: &lsp::Range) -> Option<String> {
|
||||
if range.start.line != range.end.line {
|
||||
return None;
|
||||
}
|
||||
let line = text.split_inclusive('\n').nth(range.start.line as usize)?;
|
||||
let line = line.trim_end_matches(['\n', '\r']);
|
||||
let start = utf16_to_byte(line, range.start.character)?.min(line.len());
|
||||
// The parser's scalar range ends one past the line (its newline), so the end clamps.
|
||||
let end = utf16_to_byte(line, range.end.character).unwrap_or(line.len());
|
||||
if end < start {
|
||||
return None;
|
||||
}
|
||||
let inner = line[start..end].strip_prefix('@')?.strip_suffix('@')?;
|
||||
(!inner.is_empty() && inner.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_')))
|
||||
.then(|| inner.to_owned())
|
||||
}
|
||||
|
||||
/// UTF-16 column → byte offset within one line, `None` inside a surrogate pair or past the 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 lsp_types::{Position, Range};
|
||||
|
||||
fn at(line: u32, from: u32, to: u32) -> Range {
|
||||
Range { start: Position::new(line, from), end: Position::new(line, to) }
|
||||
}
|
||||
|
||||
fn across(from: (u32, u32), to: (u32, u32)) -> Range {
|
||||
Range { start: Position::new(from.0, from.1), end: Position::new(to.0, to.1) }
|
||||
}
|
||||
|
||||
fn diagnostic(range: Range) -> lsp::Diagnostic {
|
||||
lsp::Diagnostic { range, message: RESERVED_AT.to_owned(), ..Default::default() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_maven_placeholder_placeholder_is_a_false_positive() {
|
||||
let text = "spring:\n profiles:\n active: @profileActive@\n";
|
||||
assert!(false_positive(text, &diagnostic(at(2, 12, 27))));
|
||||
// The parser ends the scalar's range one past the line (its newline): still caught.
|
||||
assert!(false_positive(text, &diagnostic(at(2, 12, 28))));
|
||||
// Columns also decode on a line with non-ASCII text before the scalar.
|
||||
let text = "name: 项目\nvalue: @profileActive@\n";
|
||||
assert!(false_positive(text, &diagnostic(at(1, 7, 22))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn other_reserved_character_errors_and_shapes_still_show() {
|
||||
let text = "active: @profileActive@\n";
|
||||
// Not the parser's message (a backtick, a different wording).
|
||||
assert!(!false_positive(
|
||||
text,
|
||||
&lsp::Diagnostic {
|
||||
message: "Plain value cannot start with reserved character `".to_owned(),
|
||||
..diagnostic(at(0, 8, 11))
|
||||
}
|
||||
));
|
||||
// The error's range is stale and no longer covers a placeholder.
|
||||
assert!(!false_positive(text, &diagnostic(at(0, 0, 10))));
|
||||
// A single `@`, an unpaired one or a name with spaces is no placeholder.
|
||||
assert!(!false_positive("active: @\n", &diagnostic(at(0, 8, 9))));
|
||||
assert!(!false_positive("active: @profile\n", &diagnostic(at(0, 8, 16))));
|
||||
assert!(!false_positive("active: @pro file@\n", &diagnostic(at(0, 8, 18))));
|
||||
// A range crossing lines is kept.
|
||||
assert!(!false_positive("a: @x@\nb: y\n", &diagnostic(across((0, 3), (1, 0)))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn utf16_columns_decode_multi_byte_and_surrogate_pairs() {
|
||||
// "é" is one UTF-16 unit; "😀" is two, and a column inside it is out of range.
|
||||
let line = "é😀@token@";
|
||||
assert_eq!(utf16_to_byte(line, 0), Some(0));
|
||||
assert_eq!(utf16_to_byte(line, 1), Some(2));
|
||||
assert_eq!(utf16_to_byte(line, 2), None);
|
||||
assert_eq!(utf16_to_byte(line, 3), Some(6));
|
||||
assert_eq!(utf16_to_byte(line, 4), Some(7));
|
||||
assert_eq!(utf16_to_byte(line, 10), Some(line.len()));
|
||||
}
|
||||
}
|
||||
@@ -94,10 +94,9 @@ pub(crate) fn connect_or_start(
|
||||
let args = substitute_args(&config.args, port, root);
|
||||
|
||||
let mut cmd = tokio::process::Command::new(binary);
|
||||
cmd.current_dir(root);
|
||||
cmd.current_dir(root).envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())));
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.args(&args)
|
||||
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped())
|
||||
|
||||
@@ -991,6 +991,33 @@ async fn files_changed_on_disk_reach_the_servers_of_their_language() {
|
||||
h.mgr.shutdown_all().await;
|
||||
}
|
||||
|
||||
/// jdtls runs the annotation processors itself and writes their output; a Maven build's
|
||||
/// copy of those files must not reach it as an edit, or jdtls recompiles javac's copy and
|
||||
/// overwrites its classes with broken ones (#4128).
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn jdtls_does_not_hear_of_annotation_processor_output() {
|
||||
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
|
||||
let (doc, _) = h.open("Open.java", "class Open {}");
|
||||
h.wait_status("jdtls", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("jdtls");
|
||||
let source = h.root.join("m/src/main/java/com/x/FooMapping.java");
|
||||
let generated = h.root.join("m/target/generated-sources/annotations/com/x/FooMappingImpl.java");
|
||||
let test_generated = h.root.join("m/target/generated-test-sources/test-annotations/com/x/T.java");
|
||||
h.mgr.watched_files_changed(
|
||||
&[test_generated],
|
||||
&[generated.clone(), source.clone()],
|
||||
std::slice::from_ref(&generated),
|
||||
&[h.root.join("m/target/generated-sources/annotations")],
|
||||
);
|
||||
eventually(|| !s.notified("workspace/didChangeWatchedFiles").is_empty()).await;
|
||||
h.mgr.hover(doc, Pos::new(0, 0), Default::default()).await.unwrap();
|
||||
assert_eq!(
|
||||
s.notified("workspace/didChangeWatchedFiles"),
|
||||
vec![json!({ "changes": [{ "uri": uri_of(&source), "type": 2 }] })]
|
||||
);
|
||||
h.mgr.shutdown_all().await;
|
||||
}
|
||||
|
||||
/// An external change to a document open on the server's current instance reaches it only
|
||||
/// through the reload's `didChange`: a watched-file change for it too would make a server
|
||||
/// that re-reads the file on one (csharp-ls) apply the reload and then the diff computed
|
||||
@@ -2568,6 +2595,35 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn eslint_configuration_includes_workspace_folder() {
|
||||
let h = harness_configured("mock", "mk", &[("eslint", incremental_caps()), ("mock", incremental_caps())], |cfg| {
|
||||
if cfg.name == "eslint" {
|
||||
cfg.settings = Some(json!({ "workingDirectory": { "mode": "auto" } }));
|
||||
}
|
||||
});
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("eslint", ServerStatus::Ready).await;
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
let items = json!({ "items": [{ "section": "" }] });
|
||||
let eslint: Value =
|
||||
h.launcher.state("eslint").peer().request("workspace/configuration", items.clone(), None).await.unwrap();
|
||||
assert_eq!(
|
||||
eslint,
|
||||
json!([{
|
||||
"flag": true,
|
||||
"nested": { "deep": 1 },
|
||||
"workingDirectory": { "mode": "auto" },
|
||||
"workspaceFolder": {
|
||||
"uri": uri_of(&h.root),
|
||||
"name": h.root.file_name().unwrap().to_string_lossy(),
|
||||
},
|
||||
}])
|
||||
);
|
||||
let other: Value = h.launcher.state("mock").peer().request("workspace/configuration", items, None).await.unwrap();
|
||||
assert_eq!(other, json!([{ "flag": true, "nested": { "deep": 1 } }]));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn settings_changes_reach_servers_without_restarts() {
|
||||
let h = harness(&[("mock", incremental_caps()), ("extra", incremental_caps())]);
|
||||
|
||||
@@ -56,7 +56,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
|
||||
use views_bindings::openidea::plugin::view_types as wit_vt;
|
||||
|
||||
/// The API version of the world above, `major.minor` of [`host_api`].
|
||||
pub const API_VERSION: &str = "1.11";
|
||||
pub const API_VERSION: &str = "1.12";
|
||||
const EPOCH_TICK: Duration = Duration::from_millis(10);
|
||||
pub(crate) const MAX_TEXT: usize = 1 << 20;
|
||||
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
|
||||
@@ -391,6 +391,11 @@ pub trait HostApi: Send + Sync {
|
||||
let _ = (client, id, item);
|
||||
Err(HostError::Invalid("window status unavailable".into()))
|
||||
}
|
||||
/// Replaces the plugin's console highlight rules (API 1.12); empty removes them.
|
||||
fn console_rules(&self, rules: Vec<crate::ConsoleRule>) -> Result<(), HostError> {
|
||||
let _ = rules;
|
||||
Err(HostError::Failed("console rules unavailable".into()))
|
||||
}
|
||||
/// Sets (`Some`, validated JSON text) or removes the plugin's context key,
|
||||
/// for window `client` (every window if `None`).
|
||||
fn set_context(&self, client: Option<&str>, key: &str, value: Option<String>) -> Result<(), HostError> {
|
||||
|
||||
@@ -72,6 +72,22 @@ pub struct StatusItem {
|
||||
pub command: Option<String>,
|
||||
}
|
||||
|
||||
/// A plugin's highlight rule for Run and Debug console output (API 1.12, `ui.set-console-rules`).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ConsoleRule {
|
||||
pub pattern: String,
|
||||
pub ignore_case: bool,
|
||||
/// A console palette colour (`red`, `bright-blue`); `None` keeps the text's own.
|
||||
pub foreground: Option<String>,
|
||||
pub background: Option<String>,
|
||||
/// `bold`, `italic`, `underline`, `strikethrough`, `dim`.
|
||||
pub styles: Vec<String>,
|
||||
/// The whole line, or only the matched text.
|
||||
pub whole_line: bool,
|
||||
pub enabled: bool,
|
||||
}
|
||||
|
||||
/// An entry of a plugin's `pick` or `pick-many`.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -250,6 +266,9 @@ pub struct DocumentTextChange {
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DocumentChanged {
|
||||
pub path: String,
|
||||
/// The open project `path` is relative to, set when the event is handed to a plugin
|
||||
/// (the editor posts the absolute path and `null`).
|
||||
pub project: Option<String>,
|
||||
pub base_version: u64,
|
||||
pub version: u64,
|
||||
pub changes: Vec<DocumentTextChange>,
|
||||
|
||||
@@ -506,6 +506,21 @@ impl ui::Host for StoreData {
|
||||
.window_status_item(self.invocation.client.as_deref().expect("checked"), &clip(id, 64), None)
|
||||
.map_err(to_wit))
|
||||
}
|
||||
fn set_console_rules(&mut self, rules: Vec<ui::ConsoleRule>) -> Fallible<()> {
|
||||
let rules = rules
|
||||
.into_iter()
|
||||
.map(|r| crate::ConsoleRule {
|
||||
pattern: r.pattern,
|
||||
ignore_case: r.ignore_case,
|
||||
foreground: r.foreground,
|
||||
background: r.background,
|
||||
styles: r.styles,
|
||||
whole_line: r.whole_line,
|
||||
enabled: r.enabled,
|
||||
})
|
||||
.collect();
|
||||
Ok(self.host.console_rules(rules).map_err(to_wit))
|
||||
}
|
||||
fn set_context(&mut self, key: String, value: ui::ContextValue) -> Fallible<()> {
|
||||
let valid_key =
|
||||
(1..=64).contains(&key.len()) && key.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-'));
|
||||
|
||||
@@ -91,16 +91,28 @@ fn the_sdk_carries_the_hosts_wit() {
|
||||
|
||||
#[test]
|
||||
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
|
||||
let host = v("1.11.0");
|
||||
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.11.0", "1.0.0-rc.1"]
|
||||
{
|
||||
let host = v("1.12.0");
|
||||
for ok in [
|
||||
"1.0.0",
|
||||
"1.3.0",
|
||||
"1.4.7",
|
||||
"1.5.0",
|
||||
"1.6.0",
|
||||
"1.7.0",
|
||||
"1.8.0",
|
||||
"1.9.0",
|
||||
"1.10.0",
|
||||
"1.11.0",
|
||||
"1.12.0",
|
||||
"1.0.0-rc.1",
|
||||
] {
|
||||
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
|
||||
}
|
||||
let newer = check_api(&v("1.12.0"), &host).unwrap_err();
|
||||
let newer = check_api(&v("1.13.0"), &host).unwrap_err();
|
||||
assert!(newer.contains("1.12") && newer.contains("update OpenIDEA"), "{newer}");
|
||||
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
|
||||
let older = check_api(&v("0.2.0"), &host).unwrap_err();
|
||||
assert!(older.contains("rebuild it with the 1.11 SDK"), "{older}");
|
||||
assert!(older.contains("rebuild it with the 1.12 SDK"), "{older}");
|
||||
// 0.x: every minor is its own API.
|
||||
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
|
||||
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
|
||||
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
c10d6f373bd3a701e201350d0272a211da72b23cef010144760db5bae44e2c11
|
||||
36b8ec8be8a65e60d601cd53e9ae0e8ab2865cb69de9b83ca31a9cb277aa0801
|
||||
Loaded 100 of 728 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача