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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 4867c99734 fix(ci): use a Windows-absolute devshell path in the project environment test 2026-11-18 15:06:51 +08:00
938 змінених файлів з 6822 додано та 37607 видалено

No files matched your search

-41
Переглянути файл
@@ -1,41 +0,0 @@
name: Cancel runs of closed PRs
on:
# pull_request_target so it also runs for PRs from forks. It never checks out or
# runs PR code: it only lists and cancels workflow runs of the closed PR's branch.
pull_request_target:
types: [closed]
permissions:
actions: write
jobs:
cancel:
runs-on: ubuntu-latest
steps:
- uses: actions/github-script@v8
with:
script: |
// A merged or closed PR's remaining CI only holds runners other PRs wait for.
const pr = context.payload.pull_request;
const { owner, repo } = context.repo;
const headRepo = pr.head.repo?.full_name;
// The API's status filter lags behind new runs: list the branch and check each one.
const runs = await github.paginate(github.rest.actions.listWorkflowRunsForRepo, {
owner,
repo,
branch: pr.head.ref,
per_page: 100,
});
let cancelled = 0;
for (const run of runs) {
if (run.id === context.runId || run.status === 'completed') continue;
if (run.head_repository?.full_name !== headRepo) continue;
if (!['pull_request', 'pull_request_target'].includes(run.event)) continue;
try {
await github.rest.actions.cancelWorkflowRun({ owner, repo, run_id: run.id });
cancelled++;
} catch (e) {
core.warning(`run ${run.id}: ${e.message}`);
}
}
core.info(`Cancelled ${cancelled} run(s) of #${pr.number}`);
+18 -86
Переглянути файл
@@ -5,7 +5,6 @@ on:
pull_request:
branches: [main]
types: [opened, synchronize, reopened]
merge_group:
workflow_dispatch:
permissions:
@@ -13,9 +12,8 @@ permissions:
concurrency:
group: ci-${{ github.ref }}
# A newer push supersedes a pull request's run in progress. Runs on main and in the merge
# queue finish, so a broken main shows up and the queue's required checks report.
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
# A newer push supersedes the run in progress, on main too.
cancel-in-progress: true
env:
CARGO_TERM_COLOR: always
@@ -25,7 +23,7 @@ env:
jobs:
# Which parts a pull request touches, so jobs it can't affect skip and leave the
# shared runners to others. Pushes, the merge queue and manual runs always run everything.
# shared runners to others. Pushes and manual runs always run everything.
changes:
name: Changes
runs-on: ubuntu-latest
@@ -34,12 +32,7 @@ jobs:
pull-requests: read
outputs:
rust: ${{ steps.classify.outputs.rust }}
server: ${{ steps.classify.outputs.server }}
plugins: ${{ steps.classify.outputs.plugins }}
deny: ${{ steps.classify.outputs.deny }}
frontend: ${{ steps.classify.outputs.frontend }}
e2e: ${{ steps.classify.outputs.e2e }}
catalog: ${{ steps.classify.outputs.catalog }}
steps:
- id: classify
env:
@@ -47,55 +40,26 @@ jobs:
PR: ${{ github.event.pull_request.number }}
run: |
set -euo pipefail
jobs="rust server plugins deny frontend e2e catalog"
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
for job in $jobs; do echo "$job=true" >> "$GITHUB_OUTPUT"; done
echo "rust=true" >> "$GITHUB_OUTPUT"
echo "frontend=true" >> "$GITHUB_OUTPUT"
exit 0
fi
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
cat files.txt
# A change to CI itself runs everything.
ci='^\.github/(workflows/ci\.yml|actions/)'
docs='^(docs/|\.agents/|\.claude/|\.idea/|\.github/ISSUE_TEMPLATE/|\.github/pull_request_template\.md$|[^/]+\.md$|LICENSE$|NOTICE$)'
# Frontend-only paths. The Rust code embeds a few files under src/; those stay out.
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|evals/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
embedded='^src/(bindings\.ts|styles/tokens\.css|features/plugins/views/frame-bridge\.js|platform/keymaps/)'
# Plugin web pages are their own pnpm projects, checked by the Plugins job only.
plugin_web='^plugins/official/[^/]+/web-src/'
# Paths the frontend checks never read...
backend='^(crates/|src-tauri/|sdk/|wit/|java/|fixtures/|Cargo\.(toml|lock)$|deny\.toml$|rustfmt\.toml$|rust-toolchain(\.toml)?$|\.cargo/)'
# ...except these, which frontend tests and e2e fixtures load.
read_by_web='^(fixtures/(folding|django-app)/|crates/ide-plugin/tests/fixtures/|crates/ide-db/(src|tests/fixtures)/snowflake/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# What the browser app and its e2e tests are built from.
app='^(src/|e2e/|public/|index\.html$|vite\.config\.ts$|tsconfig\.json$|playwright\.config\.ts$|package\.json$|pnpm-(lock|workspace)\.yaml$|crates/ide-plugin/tests/fixtures/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# The plugin workspaces: the SDK, the plugins, their interface and the host's fixture plugins.
plugin_ws='^(sdk/|plugins/|wit/|crates/ide-plugin/tests/fixtures/|rust-toolchain(\.toml)?$)'
# Never compiled into the openidea-server binary.
not_server='^(src-tauri/|sdk/|fixtures/|crates/[^/]+/(tests|benches)/)'
deps='(^|/)Cargo\.(toml|lock)$|^deny\.toml$'
# The text catalog test reads the string literals of every Rust source.
rust_source='^(crates|src-tauri/src)/.*\.rs$'
any() { grep -Eq "$1" files.txt; }
outside() { [ -n "$(grep -Ev "$1" files.txt || true)" ]; }
set_job() { echo "$1=$2" | tee -a "$GITHUB_OUTPUT"; }
if any "$ci"; then
for job in $jobs; do set_job "$job" true; done
exit 0
fi
on() { if "${@:2}"; then set_job "$1" true; else set_job "$1" false; fi; }
rust_build() { outside "$1" || any "$embedded"; }
web_checks() { outside "$docs|$plugin_web|$backend" || any "$read_by_web"; }
catalog_only() { ! web_checks && any "$rust_source"; }
on rust rust_build "$docs|$web|$plugin_web"
on server rust_build "$docs|$web|$plugin_web|$not_server"
on plugins any "$plugin_ws"
on deny any "$deps"
on frontend web_checks
on e2e any "$app"
on catalog catalog_only
# A job runs when any changed file falls outside the paths that can't affect it.
rust=false
if grep -Ev "$docs|$web" files.txt | grep -q . || grep -Eq "$embedded" files.txt; then rust=true; fi
frontend=false
if grep -Ev "$docs" files.txt | grep -q .; then frontend=true; fi
echo "rust=$rust frontend=$frontend"
echo "rust=$rust" >> "$GITHUB_OUTPUT"
echo "frontend=$frontend" >> "$GITHUB_OUTPUT"
rust:
name: Rust (${{ matrix.os }})
@@ -142,28 +106,12 @@ jobs:
if: runner.os == 'Linux'
run: git diff --exit-code src/bindings.ts src-tauri/tests/commands.snap
# One check that always reports, for the ruleset to require: a skipped matrix job reports
# under its unexpanded name, so the per-OS checks never appear on frontend-only PRs.
rust-checks:
name: Rust checks
needs: [changes, rust]
if: always()
runs-on: ubuntu-latest
timeout-minutes: 5
steps:
- env:
CHANGES: ${{ needs.changes.result }}
RUST: ${{ needs.rust.result }}
run: |
echo "changes: $CHANGES, rust: $RUST"
[ "$CHANGES" = success ] && { [ "$RUST" = success ] || [ "$RUST" = skipped ]; }
# The remote development server ships as a static Linux binary (release-build.yml):
# keep that build working.
server:
name: Remote server (linux musl)
needs: changes
if: needs.changes.outputs.server == 'true'
if: needs.changes.outputs.rust == 'true'
timeout-minutes: 40
runs-on: ubuntu-22.04
steps:
@@ -181,7 +129,7 @@ jobs:
plugins:
name: Plugins (SDK, official, fixtures)
needs: changes
if: needs.changes.outputs.plugins == 'true'
if: needs.changes.outputs.rust == 'true'
timeout-minutes: 30
runs-on: ubuntu-22.04
env:
@@ -233,7 +181,7 @@ jobs:
deny:
name: Cargo deny
needs: changes
if: needs.changes.outputs.deny == 'true'
if: needs.changes.outputs.rust == 'true'
timeout-minutes: 15
runs-on: ubuntu-latest
steps:
@@ -262,26 +210,10 @@ jobs:
- run: pnpm test
- run: pnpm build
# A backend-only change can still drop a string the text catalog uses: run that one test.
catalog:
name: Text catalog
needs: changes
if: needs.changes.outputs.catalog == 'true'
timeout-minutes: 15
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v5
- uses: pnpm/action-setup@v5
with: { version: 11 }
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm vitest run src/platform/locales/textCatalog.test.ts
e2e:
name: E2E (${{ matrix.shard }}/2)
needs: changes
if: needs.changes.outputs.e2e == 'true'
if: needs.changes.outputs.frontend == 'true'
timeout-minutes: 30
runs-on: ubuntu-24.04
strategy:
+1 -67
Переглянути файл
@@ -15,7 +15,6 @@ on:
- "crates/**"
- "languages/**"
- "fixtures/**"
- "java/**"
- "Cargo.toml"
- "Cargo.lock"
- "src/features/run/**"
@@ -42,77 +41,12 @@ env:
CARGO_INCREMENTAL: 0
jobs:
# The languages a pull request can affect: a change to one language's fixture, definition or
# JDT LS bundle runs that language; crates the smoke doesn't exercise and other crates' tests
# run none; anything else runs them all. Pushes and manual runs always run them all.
changes:
name: Changes
runs-on: ubuntu-latest
timeout-minutes: 5
permissions:
pull-requests: read
outputs:
languages: ${{ steps.classify.outputs.languages }}
steps:
- id: classify
env:
GH_TOKEN: ${{ github.token }}
PR: ${{ github.event.pull_request.number }}
run: |
set -euo pipefail
all="typescript python rust go java kotlin php c cpp"
emit() { tr ' ' '\n' <<< "$1" | { grep . || true; } | sort -u | jq -Rsc 'split("\n") | map(select(. != ""))'; }
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
echo "languages=$(emit "$all")" | tee -a "$GITHUB_OUTPUT"
exit 0
fi
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
cat files.txt
# Crates outside what the smoke runs (language servers, debuggers, run configurations,
# SDKs, build tools and the project model): cargo metadata, deps of ide-lsp/dap/run/sdk/tools.
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-search|ide-spell|ide-ssh|ide-streams|ide-vcs|ide-web)/'
# The workflow's paths, less those handled per language below.
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger)/|src/platform/|smoke/|package\.json$|pnpm-lock\.yaml$|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
langs=""
while read -r f; do
case "$f" in
crates/ide-host/tests/language_smoke.rs | crates/ide-host/tests/project_smoke.rs) langs="$all"; break ;;
crates/*/tests/* | crates/*/benches/*) ;;
fixtures/ts-app/*) langs+=" typescript" ;;
fixtures/python-app/*) langs+=" python" ;;
fixtures/rust-app/*) langs+=" rust" ;;
fixtures/go-app/*) langs+=" go" ;;
fixtures/java-app/*) langs+=" java" ;;
fixtures/kotlin-gradle/*) langs+=" kotlin" ;;
fixtures/php-app/*) langs+=" php" ;;
fixtures/c-app/*) langs+=" c cpp" ;;
fixtures/*) ;;
languages/typescript.toml | languages/typescriptreact.toml | languages/javascript.toml | languages/javascriptreact.toml) langs+=" typescript" ;;
languages/python.toml) langs+=" python" ;;
languages/rust.toml) langs+=" rust" ;;
languages/go.toml | languages/gomod.toml | languages/gowork.toml) langs+=" go" ;;
languages/java.toml) langs+=" java" ;;
languages/kotlin.toml) langs+=" kotlin" ;;
languages/php.toml) langs+=" php" ;;
languages/c.toml) langs+=" c" ;;
languages/cpp.toml) langs+=" cpp" ;;
languages/*) ;;
java/kotlin-bridge/*) langs+=" kotlin" ;;
java/*) langs+=" java kotlin" ;;
*) if grep -Eq "$smoke" <<< "$f" && ! grep -Eq "$unused" <<< "$f"; then langs="$all"; break; fi ;;
esac
done < files.txt
echo "languages=$(emit "$langs")" | tee -a "$GITHUB_OUTPUT"
smoke:
name: Language smoke (${{ matrix.language }})
needs: changes
if: needs.changes.outputs.languages != '[]'
strategy:
fail-fast: false
matrix:
language: ${{ fromJSON(needs.changes.outputs.languages) }}
language: [typescript, python, rust, go, java, kotlin, php, c, cpp]
# C/C++ debug with GDB, whose DAP interpreter needs 14+: 22.04 ships 12.1, 24.04 ships 15.
runs-on: ${{ (matrix.language == 'c' || matrix.language == 'cpp') && 'ubuntu-24.04' || 'ubuntu-22.04' }}
timeout-minutes: 40
Створено
-15
Переглянути файл
@@ -4319,7 +4319,6 @@ dependencies = [
"futures",
"ide-core",
"ide-http",
"ide-sdk",
"ide-ssh",
"notify",
"open",
@@ -4341,7 +4340,6 @@ dependencies = [
"tracing",
"uuid",
"zeroize",
"zip",
]
[[package]]
@@ -4378,17 +4376,6 @@ dependencies = [
"zip",
]
[[package]]
name = "ide-flutter"
version = "0.1.48"
dependencies = [
"ide-android",
"ide-core",
"parking_lot",
"serde_json",
"tempfile",
]
[[package]]
name = "ide-fonts"
version = "0.1.48"
@@ -4455,7 +4442,6 @@ dependencies = [
"ide-db",
"ide-docker",
"ide-extension",
"ide-flutter",
"ide-heap",
"ide-http",
"ide-index",
@@ -6748,7 +6734,6 @@ dependencies = [
"tracing",
"tracing-appender",
"tracing-subscriber",
"webkit2gtk",
"webview2-com",
"windows",
"windows-sys 0.61.2",
-30
Переглянути файл
@@ -194,36 +194,6 @@ declarations, key and animation binding names (`(keydown.enter)`, `[@fade]`,
`(@fade.done)`), runs of text that entities split (`a && b`) parsed as one, and one
token for `{` and `}`.
## Julia CodeMirror language support
[`@plutojl/lang-julia`](https://github.com/JuliaPluto/lang-julia) 1.2.0 and its
[`@plutojl/lezer-julia`](https://github.com/JuliaPluto/lezer-julia) parser dependency
provide the Julia CodeMirror 6 language mode. Both packages are MIT licensed;
the full license text is below. The mode wraps a Lezer grammar and exposes its
syntax tags through `julia()`.
### MIT License (@plutojl/lang-julia and @plutojl/lezer-julia)
Copyright (c) 2021 Andrey Popp
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
## nvim-treesitter queries
`crates/ide-syntax/queries/<grammar>/locals.scm` are derived from the `locals.scm`
+1 -5
Переглянути файл
@@ -203,11 +203,7 @@ async fn a_task_runs_on_a_v2_agent_and_resumes_its_session() {
let agent2 = Arc::new(FakeV2Agent::default());
let mgr2 = manager(tmp.path(), agent2.clone());
mgr2.prompt(&task.id, text("again"), false).await.unwrap();
// The task is Ready until the resumed turn starts: wait for the turn's entries first.
let deadline = std::time::Instant::now() + Duration::from_secs(10);
while mgr2.entries(&task.id, None).unwrap().len() < 8 && std::time::Instant::now() < deadline {
tokio::time::sleep(Duration::from_millis(10)).await;
}
tokio::time::sleep(Duration::from_millis(50)).await;
wait_for(&mgr2, &task.id, AgentStatus::Ready).await;
let entries = mgr2.entries(&task.id, None).unwrap();
assert_eq!(summary(&entries[6..]), ["user: again", "agent: second turn"]);
-25
Переглянути файл
@@ -213,31 +213,6 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
/// Availability for an explicit session switch must come from a recent discovery for this
/// launch, not from the display fallback or a different project's session report.
pub(super) fn fresh_model(
&self,
shared: &Shared,
spec: &provider::ProviderSpec,
model: &str,
) -> Option<crate::AgentConfigValue> {
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
let select = |catalog: &CatalogData| {
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
return None;
}
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
};
let state = self.state.lock();
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
}
let cache = shared.known.lock();
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
let state = self.state.lock();
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
+2 -227
Переглянути файл
@@ -11,7 +11,6 @@ const PROVIDER: &str = "catalog-test";
#[derive(Debug)]
struct Pending {
launch: usize,
method: String,
params: Value,
reply: oneshot::Sender<Result<Value, String>>,
@@ -45,7 +44,7 @@ impl Harness {
let launches = launches.clone();
let live = live.clone();
move |_, _, client, _| {
let launch = launches.fetch_add(1, Ordering::SeqCst);
launches.fetch_add(1, Ordering::SeqCst);
live.fetch_add(1, Ordering::SeqCst);
let guard = Live(live.clone());
let pending = pending_tx.clone();
@@ -76,17 +75,10 @@ impl Harness {
}
let response = match request["method"].as_str().unwrap() {
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
"session/new"
| "session/set_config_option"
| "session/set_model"
| "session/load"
| "session/resume"
| "session/prompt"
| "session/set_mode" => {
"session/new" | "session/set_config_option" | "session/set_model" => {
let (reply, mut result) = oneshot::channel();
pending
.send(Pending {
launch,
method: request["method"].as_str().unwrap().to_owned(),
params: request["params"].clone(),
reply,
@@ -298,223 +290,6 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
}
#[tokio::test]
async fn discovered_model_is_confirmed_by_the_live_session() {
switch_chat_model(ChatSwitch::Live).await;
}
#[tokio::test]
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
switch_chat_model(ChatSwitch::Resume).await;
}
#[tokio::test]
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
switch_chat_model(ChatSwitch::ResumeFails).await;
}
#[tokio::test]
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
switch_chat_model(ChatSwitch::Unavailable).await;
}
#[tokio::test]
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
switch_chat_model(ChatSwitch::Idle).await;
}
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
Resume,
ResumeFails,
Unavailable,
Idle,
}
async fn switch_chat_model(scenario: ChatSwitch) {
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
}));
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
let task = manager
.create(NewAgentTask {
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
provider: PROVIDER.into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
let mut initial = response(&["old"], &["low", "high"]);
initial["sessionId"] = json!("saved-chat");
initial["modes"] = json!({
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
});
next.reply.send(Ok(initial.clone())).unwrap();
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(0, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
{
let mode = manager.set_config(&task.id, "mode", "ask".into());
tokio::pin!(mode);
let set = next_chat_request(&mut harness, mode.as_mut()).await;
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
mode.await.unwrap();
}
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
if matches!(scenario, ChatSwitch::Idle) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
let mut events = events(&manager);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let offline = matches!(scenario, ChatSwitch::Idle);
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
// A fallback selection settles without waiting for a new process.
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not open another session: {request:?}"),
}
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
let current = snapshot(&manager);
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
if !live {
let load = harness.next().await;
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
}}))
.unwrap();
if load_fails {
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "config_option_update",
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
}}))
.unwrap();
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
} else {
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
let mut resumed = response(models, &["low", "high"]);
resumed["modes"] = initial["modes"].clone();
load.reply.send(Ok(resumed)).unwrap();
}
if load_fails || unavailable {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let task = snapshot(&manager);
assert_eq!(task.model.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
if load_fails {
manager
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
.await
.unwrap();
let retry = harness.next().await;
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
assert_eq!(retry.params["sessionId"], "saved-chat");
retry.reply.send(Ok(initial.clone())).unwrap();
let set = harness.next().await;
assert_eq!(set.method, "session/set_mode");
set.reply.send(Ok(json!({}))).unwrap();
let prompt = harness.next().await;
assert_eq!(prompt.method, "session/prompt");
assert_eq!(prompt.params["sessionId"], "saved-chat");
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
}
manager.shutdown();
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
}
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("new"));
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
let task = manager.task(id).unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
while task.state.lock().task.status != status || task.state.lock().busy {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
}
async fn next_chat_request(
harness: &mut Harness,
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
) -> Pending {
tokio::select! {
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
request = harness.next() => request,
}
}
#[tokio::test]
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let tmp = tempfile::tempdir().unwrap();
-17
Переглянути файл
@@ -219,23 +219,6 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
}
}
/// Legacy setters and agents that report the change in a notification may return no model.
pub(super) fn accepts_model(reply: &Value, id: &str, value: &str) -> bool {
reply
.get("configOptions")
.and_then(Value::as_array)
.and_then(|options| {
options.iter().find(|option| {
option.get("category").and_then(Value::as_str) == Some("model")
|| option.get("id").or_else(|| option.get("configId")).and_then(Value::as_str) == Some(id)
})
})
.and_then(|option| option.get("currentValue"))
.or_else(|| reply.pointer("/models/currentModelId"))
.and_then(Value::as_str)
.is_none_or(|current| current == value)
}
/// `available_commands_update`.
pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
update
+74 -451
Переглянути файл
@@ -20,7 +20,6 @@ mod native;
mod provider;
pub mod registry;
pub mod security;
mod shell;
mod skills;
mod timeline;
mod worktree;
@@ -125,9 +124,6 @@ type Connector = Arc<
/// Returns the configured MCP servers (User and Workspace) for this project.
pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
/// Returns the executable of the running built-in MCP server, if any.
pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
struct CopilotBinaryKey {
command: String,
@@ -151,7 +147,6 @@ struct Shared {
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
idle_release_ms: AtomicU64,
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
mcp_executable_hook: RwLock<Option<Arc<McpExecutableFn>>>,
/// Monotonic id for [`AgentEvent::Attention`] episodes.
attention_seq: AtomicU64,
}
@@ -224,12 +219,8 @@ impl Shared {
overrides: &BTreeMap<String, bool>,
) -> McpForSession {
let builtin_off = overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false);
let mut servers = if builtin_off {
Vec::new()
} else {
let exe = self.mcp_executable_hook.read().as_ref().and_then(|hook| hook());
stdio_mcp_servers(exe.as_deref(), init.mcp_stdio(), &self.paths.project_root)
};
let mut servers =
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
let off = Self::mcp_off(&configured, provider, overrides);
@@ -357,9 +348,6 @@ struct TaskFile {
/// Settings the user chose, re-applied to every new or reloaded session.
#[serde(default)]
wanted: Vec<AgentConfigChoice>,
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
#[serde(default, skip_serializing_if = "Option::is_none")]
pending_model: Option<String>,
/// In the project's own checkout: files already changed when the task started.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
before: BTreeMap<String, worktree::Stamp>,
@@ -371,9 +359,6 @@ struct TaskFile {
/// `None` for a worktree task, and a task saved before these were recorded.
#[serde(default, skip_serializing_if = "Option::is_none")]
touched: Option<BTreeSet<String>>,
/// The checkout as the last turn started, its copies in the store's `<id>.turn` folder.
#[serde(default, skip_serializing_if = "Option::is_none")]
turn: Option<worktree::TurnStart>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
subagents: Vec<SavedSubagent>,
/// Turns to drop from the session once it is loaded (a fork of an earlier point).
@@ -392,14 +377,11 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
pending_model: Option<String>,
model_choice: u64,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
/// See `TaskFile::touched`.
touched: Option<Arc<BTreeSet<String>>>,
/// See `TaskFile::turn`.
turn: Option<Arc<worktree::TurnStart>>,
pending_rollback: u32,
/// The user named the task; see `TaskFile::title_renamed`.
title_renamed: bool,
@@ -409,27 +391,6 @@ struct TaskState {
/// the like), as it sent them: unlike a turn they outlive it, so an idle release
/// waits for the last one. A (re)started process runs nothing yet.
background_tasks: Vec<Value>,
/// Shell commands the user ran with `!` since the last prompt, as the text block that
/// goes ahead of the next one.
shell_context: Vec<String>,
}
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.
@@ -524,7 +485,6 @@ impl AgentManager {
copilot_acp_fallback: Mutex::new(HashSet::new()),
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
mcp_servers_hook: RwLock::new(None),
mcp_executable_hook: RwLock::new(None),
attention_seq: AtomicU64::new(0),
});
shared.paths.catalogs.subscribe(&shared);
@@ -559,7 +519,7 @@ impl AgentManager {
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
*self.shared.sink.write() = Some(sink);
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().task.clone()).collect();
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
tasks
}
@@ -659,11 +619,6 @@ impl AgentManager {
*self.shared.mcp_servers_hook.write() = Some(Arc::from(hook));
}
/// Provides the executable of the running built-in MCP server for this host.
pub fn set_mcp_executable_hook(&self, hook: Box<McpExecutableFn>) {
*self.shared.mcp_executable_hook.write() = Some(Arc::from(hook));
}
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
/// in the project: what the agent offered last time there, unadvertised builtins,
/// and, for Claude Code, skills and custom commands on disk it has not listed.
@@ -795,11 +750,9 @@ impl AgentManager {
session_id: Some(session_id.to_owned()),
entries: Vec::new(),
wanted: Vec::new(),
pending_model: None,
before: BTreeMap::new(),
saved: None,
touched: Some(BTreeSet::new()),
turn: None,
subagents: Vec::new(),
pending_rollback: 0,
title_renamed: true,
@@ -910,11 +863,9 @@ impl AgentManager {
session_id: None,
entries: Vec::new(),
wanted: req.config,
pending_model: None,
before,
saved,
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
turn: None,
subagents: Vec::new(),
pending_rollback: 0,
title_renamed: false,
@@ -975,26 +926,6 @@ impl AgentManager {
Ok(())
}
/// Runs `command` (a composer line starting with `!`) in the task's folder with the user's
/// shell, without starting a turn: it shows as one entry with its output and exit code,
/// and goes to the agent with the next message.
pub async fn run_shell(&self, id: &str, command: &str, cancel: ide_core::CancellationToken) -> IdeResult<()> {
let task = self.task(id)?;
let command = command.trim();
if command.is_empty() {
return Err(IdeError::invalid("empty command"));
}
let cwd = {
let s = task.state.lock();
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
s.task.cwd.0.clone()
};
task.shell(command, &cwd, &cancel).await;
Ok(())
}
/// Drops a queued message.
pub fn unqueue(&self, id: &str, queued: &str) -> IdeResult<AgentQueued> {
let task = self.task(id)?;
@@ -1063,7 +994,7 @@ impl AgentManager {
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
let task = self.task(id)?;
let (target, change) = {
let (target, model_choice, previous_levels) = {
let mut s = task.state.lock();
let target = s
.task
@@ -1073,28 +1004,22 @@ impl AgentManager {
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if !target.values.iter().any(|v| v.value == value) {
if target.category.as_deref() != Some("model") {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
(target, None)
} else {
let switching_model = target.category.as_deref() == Some("model");
if switching_model {
s.model_choice += 1;
s.pending_model = None;
}
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current =
Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, Some((s.model_choice, previous_levels)))
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
};
let Some((model_choice, previous_levels)) = change else {
return task.switch_discovered_model(target, value).await;
if target.category.as_deref() == Some("model") {
s.model_choice += 1;
}
let previous_levels =
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
} else {
None
};
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, s.model_choice, previous_levels)
};
let previous = target.current.clone();
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
@@ -1261,12 +1186,9 @@ impl AgentManager {
session_id: Some(session),
entries,
wanted: s.wanted.clone(),
pending_model: None,
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
// The source's next turn replaces its copies: the fork's last turn is one of its own.
turn: None,
subagents: s.conversation.saved_subagents(),
pending_rollback: total - keep,
title_renamed: s.title_renamed,
@@ -1306,7 +1228,6 @@ impl AgentManager {
_ => None,
};
s.session_id = None;
s.pending_model = None;
s.conversation = Conversation::default();
// The fresh session reports its own usage; nothing carries over.
s.task.usage = None;
@@ -1607,7 +1528,6 @@ impl AgentManager {
self.tasks.write().remove(id);
*task.deleted.lock() = true;
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{id}.json")));
let _ = std::fs::remove_dir_all(task.turn_dir());
let saved = task.state.lock().saved.clone();
if let Some(saved) = saved
&& !self.tasks.read().values().any(|t| t.state.lock().saved.as_ref() == Some(&saved))
@@ -1650,47 +1570,18 @@ impl AgentManager {
.await
}
/// The files the task's last turn changed, against the checkout as it started (while a
/// turn runs: that turn's so far). None before the task's first turn.
pub async fn turn_changes(&self, id: &str) -> IdeResult<Vec<AgentChange>> {
let (cwd, turn, dir) = self.task(id)?.last_turn();
let Some(turn) = turn else { return Ok(Vec::new()) };
blocking(move || {
let changed = match &turn.changed {
Some(changed) => changed.clone(),
None => worktree::changed_in_turn(&cwd, &turn)?.1,
};
worktree::turn_changes(&cwd, &turn, &dir, &changed)
})
.await
}
/// Content of `path` (in the task's directory) as `view` compares it: when the task
/// started, in `HEAD`, or when the last turn started.
pub async fn base_text(&self, id: &str, path: PathBuf, view: AgentChangesView) -> IdeResult<Option<String>> {
let task = self.task(id)?;
if view == AgentChangesView::LastTurn {
let (cwd, turn, dir) = task.last_turn();
let Some(turn) = turn else { return Ok(None) };
return blocking(move || worktree::turn_text(&cwd, &path, &turn, &dir)).await;
}
let at = task.base();
blocking(move || {
let rev = match view {
AgentChangesView::Group => worktree::head_commit(at.cwd())?,
_ => at.rev()?,
};
match rev {
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
None => Ok(None),
}
/// Content of `path` (in the task's directory) when the task started.
pub async fn base_text(&self, id: &str, path: PathBuf) -> IdeResult<Option<String>> {
let at = self.task(id)?.base();
blocking(move || match at.rev()? {
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
None => Ok(None),
})
.await
}
/// Rollback: puts the task's changed files among `rel_paths` (all with `None`) back as
/// `view` compares them: as they were when it started, as they are in `HEAD`, or as they
/// were when its last turn started.
/// `view` compares them: as they were when it started, or as they are in `HEAD`.
pub async fn rollback_changes(
&self,
id: &str,
@@ -1701,18 +1592,15 @@ impl AgentManager {
if task.state.lock().busy {
return Err(IdeError::invalid("the agent is working: stop it before rolling back its changes"));
}
if view == AgentChangesView::LastTurn {
return self.rollback_turn(&task, rel_paths).await;
}
let at = task.base();
let (before, saved, touched) = {
let s = task.state.lock();
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)), s.touched.clone())
};
let (restamped, restored) = blocking(move || {
let restamped = blocking(move || {
let (changes, rev) = match view {
AgentChangesView::Group => (at.grouped_changes(&before)?.uncommitted, worktree::head_commit(at.cwd())?),
AgentChangesView::SinceStart | AgentChangesView::LastTurn => (at.changes(&before)?, at.rev()?),
AgentChangesView::SinceStart => (at.changes(&before)?, at.rev()?),
};
let changes = worktree::made_by_task(changes, touched.as_deref());
let sources = match rev.as_deref() {
@@ -1720,7 +1608,6 @@ impl AgentManager {
None => Default::default(),
};
let mut restamped = Vec::new();
let mut restored = Vec::new();
for change in changes.iter().filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path))) {
// A rename goes back to its old path too; the new one is taken away first, so a
// case-only rename on a case-insensitive disk ends as the old file.
@@ -1730,58 +1617,6 @@ impl AgentManager {
if before.contains_key(&change.rel_path) {
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
}
restored.push(change.rel_path.clone());
}
}
Ok((restamped, restored))
})
.await?;
{
let mut s = task.state.lock();
if !restamped.is_empty() {
let mut before = (*s.before).clone();
before.extend(restamped);
s.before = Arc::new(before);
}
// Rolled back further than the last turn: what it changed there is gone, not the turn's to list.
if let Some(turn) = &s.turn
&& let Some(changed) = &turn.changed
&& restored.iter().any(|rel| changed.contains(rel))
{
let changed = changed.iter().filter(|rel| !restored.contains(rel)).cloned().collect();
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(changed), ..(**turn).clone() }));
}
}
task.persist();
Ok(())
}
/// Puts the last turn's changed files among `rel_paths` (all with `None`) back as they
/// were when it started.
async fn rollback_turn(&self, task: &Task, rel_paths: Option<Vec<String>>) -> IdeResult<()> {
let (cwd, turn, dir) = task.last_turn();
let Some(turn) = turn else { return Ok(()) };
let (before, saved) = {
let s = task.state.lock();
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)))
};
let restamped = blocking(move || {
let changed = match &turn.changed {
Some(changed) => changed.clone(),
None => worktree::changed_in_turn(&cwd, &turn)?.1,
};
let mut restamped = Vec::new();
for change in worktree::turn_changes(&cwd, &turn, &dir, &changed)?
.iter()
.filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path)))
{
worktree::restore_turn(&cwd, &turn, &dir, change)?;
// Back to the user's own edits from before the task: not a change of the task.
if let Some(Some(_)) = before.get(&change.rel_path)
&& let Some(copy) = saved.as_deref().and_then(|d| worktree::saved_copy(d, &change.rel_path))
&& std::fs::read(&change.path.0).is_ok_and(|now| now == copy)
{
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
}
}
Ok(restamped)
@@ -1855,7 +1690,7 @@ impl AgentManager {
s.task.mcp_overrides = cleaned;
s.task.updated_ms = now_ms();
}
(changed, s.busy, !s.background_tasks.is_empty(), s.snapshot())
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
};
if changed {
task.persist();
@@ -1913,17 +1748,14 @@ 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,
background_tasks: Vec::new(),
shell_context: Vec::new(),
}),
live: Mutex::new(None),
connecting: tokio::sync::Mutex::new(()),
@@ -1953,48 +1785,31 @@ impl Task {
(s.before.clone(), s.touched.clone())
}
/// Where the copies of the files already changed as the last turn started are kept.
fn turn_dir(&self) -> PathBuf {
self.shared.paths.store_dir.join(format!("{}.turn", self.id))
}
/// The checkout as the last turn started, with the folder of its copies.
fn last_turn(&self) -> (PathBuf, Option<Arc<worktree::TurnStart>>, PathBuf) {
let s = self.state.lock();
(s.task.cwd.0.clone(), s.turn.clone(), self.turn_dir())
}
/// Records the checkout as a turn starts: what the turn's changes are compared with.
async fn checkout_before_turn(&self) {
let (cwd, previous, dir) = self.last_turn();
let turn = match blocking(move || worktree::start_turn(&cwd, &dir, previous.as_deref())).await {
Ok(turn) => Some(Arc::new(turn)),
Err(e) => {
tracing::warn!("recording the checkout as a turn of agent task {} starts: {e}", self.id);
None
}
/// The changed files of the checkout as a turn starts, when the task records what its turns change.
async fn checkout_before_turn(&self) -> Option<Snapshot> {
let cwd = {
let s = self.state.lock();
s.touched.as_ref()?;
s.task.cwd.0.clone()
};
self.state.lock().turn = turn;
self.persist();
blocking(move || worktree::snapshot(&cwd)).await.ok()
}
/// Records the files that changed in the checkout while the turn ran: the turn's, and in
/// the project's own checkout also the task's.
async fn record_turn_changes(&self) {
let (cwd, turn, _) = self.last_turn();
let Some(turn) = turn else { return };
let start = turn.clone();
let Ok((in_worktree, all)) = blocking(move || worktree::changed_in_turn(&cwd, &start)).await else { return };
/// Records the files that changed in the checkout since `start`, as the turn ends, as the task's.
async fn record_turn_changes(&self, start: Option<Snapshot>) {
let Some(start) = start else { return };
let cwd = self.state.lock().task.cwd.0.clone();
let Ok(end) = blocking(move || worktree::snapshot(&cwd)).await else { return };
let changed = worktree::changed_between(&start, &end);
if changed.is_empty() {
return;
}
{
let mut s = self.state.lock();
if !in_worktree.is_empty()
&& let Some(touched) = &s.touched
{
let mut touched = (**touched).clone();
touched.extend(in_worktree);
s.touched = Some(Arc::new(touched));
}
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(all), ..(*turn).clone() }));
let Some(touched) = &s.touched else { return };
let mut touched = (**touched).clone();
touched.extend(changed);
s.touched = Some(Arc::new(touched));
}
self.persist();
}
@@ -2011,7 +1826,7 @@ impl Task {
}
fn emit_task(&self) {
let task = self.state.lock().snapshot();
let task = self.state.lock().task.clone();
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
}
@@ -2108,11 +1923,9 @@ impl Task {
session_id: s.session_id.clone(),
entries: s.conversation.main.entries.clone(),
wanted: s.wanted.clone(),
pending_model: s.pending_model.clone(),
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
turn: s.turn.as_deref().cloned(),
subagents: s.conversation.saved_subagents(),
pending_rollback: s.pending_rollback,
title_renamed: s.title_renamed,
@@ -2154,33 +1967,6 @@ impl Task {
}
}
/// Folds an update made here (not by the agent) into the main conversation.
fn apply_local(self: &Arc<Self>, update: &Value) {
let changed = self.state.lock().conversation.apply(None, update, now_ms());
self.mark_dirty(changed);
}
async fn shell(self: &Arc<Self>, command: &str, cwd: &Path, cancel: &ide_core::CancellationToken) {
let call = format!("shell-{}", uuid::Uuid::new_v4().simple());
self.apply_local(&json!({
"sessionUpdate": "tool_call",
"toolCallId": call,
"title": format!("! {command}"),
"kind": "execute",
"status": "in_progress",
}));
let ran = shell::run(command, cwd, cancel).await;
let status = if ran.code == Some(0) { "completed" } else { "failed" };
self.apply_local(&json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call,
"status": status,
"content": [{ "type": "content", "content": { "type": "text", "text": ran.shown() } }],
}));
self.state.lock().shell_context.push(ran.context(command));
self.persist();
}
fn push_entry(self: &Arc<Self>, entry: AgentEntry) -> usize {
let i = self.state.lock().conversation.main.push(entry);
self.mark_dirty([(None, i)]);
@@ -2191,11 +1977,11 @@ impl Task {
/// the user stops one. The caller set `busy`.
async fn run(self: Arc<Self>, mut prompt: AgentPrompt) {
loop {
self.checkout_before_turn().await;
let start = self.checkout_before_turn().await;
let result = self.turn(&prompt).await;
self.cancel_pending.store(false, Ordering::Release);
tokio::time::sleep(TURN_GRACE).await;
self.record_turn_changes().await;
self.record_turn_changes(start).await;
let changed = self.state.lock().conversation.end_turn(Some(now_ms()));
self.mark_dirty(changed);
let send_now = self.send_now.swap(false, Ordering::AcqRel);
@@ -2241,7 +2027,7 @@ impl Task {
}
}
/// Drops an idle resumable live session so the next turn reloads it.
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
fn recycle_resumable_session(&self) {
self.mcp_reload_pending.store(false, Ordering::Release);
let live = {
@@ -2249,110 +2035,12 @@ impl Task {
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
};
if let Some(live) = live {
tracing::debug!("agent task {}: recycling idle resumable session", self.id);
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
live.peer.kill();
self.clear_shown_background();
}
}
async fn switch_discovered_model(&self, target: AgentConfigOption, value: String) -> IdeResult<()> {
let provider = self.state.lock().task.provider.clone();
let spec = self.shared.spec(&provider).ok_or_else(|| IdeError::not_found("no such agent"))?;
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
})?;
let model_choice = {
let mut s = self.state.lock();
s.model_choice += 1;
s.model_choice
};
// A prompt starting during the switch must not grab the peer we're about to recycle.
let _connecting = self.connecting.lock().await;
{
let s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
}
let live = self.live.lock().clone();
let result = if let Some(live) = live.as_ref().filter(|l| !l.peer.is_closed()) {
let (method, mut params) = config::set_request(&target, &value);
params["sessionId"] = json!(live.session);
match live.peer.request::<_, Value>(method, params, None).await {
Ok(reply) if config::accepts_model(&reply, &target.id, &value) => Ok(Some(reply)),
Ok(_) => Err(format!("The agent did not switch to model {value}.")),
Err(e) => Err(self.describe(e)),
}
} else {
Ok(None)
};
let accepted = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let pending = match result {
Ok(Some(reply)) => {
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut s.task.config, options);
} else if s.task.model.as_deref() != Some(value.as_str()) {
s.task.config.retain(|o| !config::is_per_model_option(o));
}
let model =
if let Some(i) = s.task.config.iter().position(|o| o.category.as_deref() == Some("model")) {
&mut s.task.config[i]
} else {
s.task.config.push(target.clone());
s.task.config.last_mut().unwrap()
};
if !model.values.iter().any(|v| v.value == value) {
model.values.push(candidate);
}
model.current = Some(value.clone());
s.task.model = Some(value.clone());
sync_usage_context_size(&mut s.task);
false
}
refused => {
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
true
}
};
s.wanted.retain(|c| c.id != target.id);
s.pending_model = pending.then(|| target.id.clone());
s.wanted.push(AgentConfigChoice { id: target.id, value });
(!pending).then(|| {
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
})
};
if let Some((config, model)) = accepted {
self.shared.remember(&provider, Some(&config), None, model.as_deref());
} else {
self.recycle_resumable_session();
}
self.persist();
self.emit_task();
Ok(())
}
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
/// reloads its session: the next message starts it again with the conversation intact.
@@ -2497,14 +2185,7 @@ impl Task {
if !prompt.images.is_empty() && !live.capabilities.images {
return Err(Failure::from("This agent can't read images.".to_owned()));
}
let shell = std::mem::take(&mut self.state.lock().shell_context);
let with_shell = |mut content: Vec<Value>| {
if !shell.is_empty() {
content.insert(0, json!({ "type": "text", "text": shell.join("\n") }));
}
content
};
let mut content = with_shell(self.content(&live, prompt).await);
let mut content = self.content(&live, prompt).await;
let mut result: Result<Value, RpcError> =
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
if live.driver == provider::Driver::Copilot
@@ -2526,7 +2207,7 @@ impl Task {
if !prompt.images.is_empty() && !live.capabilities.images {
return Err(Failure::from("This agent can't read images.".to_owned()));
}
content = with_shell(self.content(&live, prompt).await);
content = self.content(&live, prompt).await;
result = live
.peer
.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None)
@@ -2607,12 +2288,10 @@ impl Task {
{
return Ok(live);
}
let (provider_id, cwd, saved, pending) = {
let (provider_id, cwd, saved) = {
let s = self.state.lock();
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
};
let pending_model = pending.as_ref().map(|(choice, _)| choice);
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
@@ -2621,8 +2300,8 @@ impl Task {
} else {
raw_spec.clone()
};
let opened = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone(), pending_model).await {
Ok(live) => Ok(live),
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
Ok(live) => live,
Err(err) if can_fallback && err.allow_acp_fallback => {
tracing::warn!(
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
@@ -2631,32 +2310,9 @@ impl Task {
);
self.shared.mark_copilot_acp_fallback(&raw_spec);
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
self.open_session(&provider_id, acp_spec, &cwd, saved, pending_model).await
}
Err(err) => Err(err),
};
let live = match opened {
Ok(live) => live,
Err(err) => {
if let Some((choice, previous)) = pending {
let mut s = self.state.lock();
if s.pending_model() == Some(&choice) {
s.pending_model = None;
s.wanted.retain(|c| c.id != choice.id);
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
model.current.clone_from(&previous);
}
s.task.model.clone_from(&previous);
if let Some(value) = previous {
s.wanted.push(AgentConfigChoice { id: choice.id, value });
}
drop(s);
self.persist();
self.emit_task();
}
}
return Err(err.message);
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
}
Err(err) => return Err(err.message),
};
*self.live.lock() = Some(live.clone());
Ok(live)
@@ -2668,7 +2324,6 @@ impl Task {
spec: provider::ProviderSpec,
cwd: &Path,
saved: Option<String>,
pending_model: Option<&AgentConfigChoice>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
@@ -2718,12 +2373,6 @@ 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);
@@ -2739,16 +2388,6 @@ 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!(
@@ -2820,19 +2459,6 @@ impl Task {
});
let mut model_options = known;
for choice in &wanted {
let pending = pending_model == Some(choice);
if pending
&& !options.iter().any(|o| {
o.id == choice.id
&& (o.values.iter().any(|v| v.value == choice.value)
|| (known && o.current.as_deref() == Some(choice.value.as_str())))
})
{
return Err(SessionOpenError {
message: format!("The reloaded session does not offer model {}.", choice.value),
allow_acp_fallback: false,
});
}
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
if o.id == config::CURSOR_APPROVAL {
@@ -2853,12 +2479,6 @@ impl Task {
params["sessionId"] = json!(session_id);
match peer.request::<_, Value>(method, params, None).await {
Ok(reply) => {
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
return Err(SessionOpenError {
message: format!("The reloaded session did not switch to model {}.", choice.value),
allow_acp_fallback: false,
});
}
if let Some(fresh) = reply.get("configOptions") {
config::merge_update(&mut options, fresh);
model_options = true;
@@ -2872,9 +2492,6 @@ impl Task {
o.current = Some(choice.value.clone());
}
}
Err(e) if pending => {
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
}
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
}
}
@@ -2884,7 +2501,6 @@ 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);
@@ -3782,14 +3398,21 @@ mod tests;
/// The name agents know the built-in server by (its tools are `mcp__OpenIDEA__…` in Claude Code).
const BUILTIN_SERVER: &str = "OpenIDEA";
// The desktop advertises its relay only while the built-in server is listening.
static MCP_EXECUTABLE: parking_lot::RwLock<Option<std::path::PathBuf>> = parking_lot::RwLock::new(None);
pub fn set_mcp_executable(executable: Option<std::path::PathBuf>) {
*MCP_EXECUTABLE.write() = executable;
}
fn mcp_servers_for(supported: bool, root: &std::path::Path) -> Vec<Value> {
stdio_mcp_servers(MCP_EXECUTABLE.read().as_deref(), supported, root)
}
fn stdio_mcp_servers(executable: Option<&std::path::Path>, supported: bool, root: &std::path::Path) -> Vec<Value> {
let Some(executable) = executable.filter(|_| supported) else { return Vec::new() };
let command = ide_mcp::stdio_command(executable, root);
let env: Vec<Value> = ["OPENIDEA_SERVER_HOME", "OPENIDEA_DATA_DIR"]
.into_iter()
.filter_map(|name| std::env::var(name).ok().map(|value| json!({ "name": name, "value": value })))
.collect();
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": env })]
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": [] })]
}
/// What was sent of a streaming message: its first `bytes` (`utf16` UTF-16 units), which
+51 -438
Переглянути файл
@@ -399,429 +399,163 @@ pub fn apply_save_json(
Ok(saved_names)
}
const COPILOT_PLUGIN_MANIFESTS: &[&str] = &[
".github/plugin/plugin.json",
".plugin/plugin.json",
".claude-plugin/plugin.json",
".cursor-plugin/plugin.json",
"plugin.json",
];
#[derive(Clone, PartialEq, Eq)]
#[derive(Clone, Copy, PartialEq, Eq)]
enum SourceFormat {
Jsonc,
CodexToml,
CopilotPlugin { root: PathBuf },
}
#[derive(Clone)]
struct SourceSpec {
id: String,
label: String,
id: &'static str,
label: &'static str,
path: PathBuf,
format: SourceFormat,
suggested_scope: McpScope,
native_provider: Option<&'static str>,
claude_project_lookup: bool,
disabled_servers: std::sync::Arc<BTreeSet<String>>,
}
#[derive(Default)]
struct CopilotSettings {
disabled_mcp_servers: std::sync::Arc<BTreeSet<String>>,
disabled_plugins: BTreeSet<String>,
}
fn external_source_specs(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<SourceSpec> {
let mut specs = Vec::new();
let no_disabled: std::sync::Arc<BTreeSet<String>> = std::sync::Arc::new(BTreeSet::new());
if let Some(root) = workspace_root {
specs.push(SourceSpec {
id: "workspace-mcp".into(),
label: "Project (.mcp.json)".into(),
id: "workspace-mcp",
label: "Project (.mcp.json)",
path: root.join(".mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("claude"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "vscode-mcp".into(),
label: "VS Code (.vscode/mcp.json)".into(),
id: "vscode-mcp",
label: "VS Code (.vscode/mcp.json)",
path: root.join(".vscode").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "cursor-project".into(),
label: "Cursor Project (.cursor/mcp.json)".into(),
id: "cursor-project",
label: "Cursor Project (.cursor/mcp.json)",
path: root.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("cursor"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "codex-project".into(),
label: "Codex Project (.codex/config.toml)".into(),
id: "codex-project",
label: "Codex Project (.codex/config.toml)",
path: root.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::Workspace,
native_provider: Some("codex"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "gemini-project".into(),
label: "Gemini Project (.gemini/settings.json)".into(),
id: "gemini-project",
label: "Gemini Project (.gemini/settings.json)",
path: root.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("gemini"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
}
if let Some(home) = home_dir {
let copilot_dir = home.join(".copilot");
let copilot_settings = read_copilot_settings(&copilot_dir);
specs.push(SourceSpec {
id: "copilot-cli".into(),
label: "GitHub Copilot CLI".into(),
path: copilot_dir.join("mcp-config.json"),
id: "copilot-cli",
label: "GitHub Copilot CLI",
path: home.join(".copilot").join("mcp-config.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("copilot"),
claude_project_lookup: false,
disabled_servers: copilot_settings.disabled_mcp_servers.clone(),
});
specs.extend(copilot_plugin_source_specs(&copilot_dir, &copilot_settings));
specs.push(SourceSpec {
id: "claude-code".into(),
label: "Claude Code".into(),
id: "claude-code",
label: "Claude Code",
path: home.join(".claude.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("claude"),
claude_project_lookup: true,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "codex".into(),
label: "Codex".into(),
id: "codex",
label: "Codex",
path: home.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::User,
native_provider: Some("codex"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "cursor".into(),
label: "Cursor".into(),
id: "cursor",
label: "Cursor",
path: home.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("cursor"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "gemini".into(),
label: "Gemini CLI".into(),
id: "gemini",
label: "Gemini CLI",
path: home.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("gemini"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "jetbrains-air".into(),
label: "JetBrains Air".into(),
id: "jetbrains-air",
label: "JetBrains Air",
path: home.join(".jetbrains").join("mcp").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "copilot-intellij".into(),
label: "GitHub Copilot (JetBrains)".into(),
id: "copilot-intellij",
label: "GitHub Copilot (JetBrains)",
path: home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled,
});
}
specs
}
fn read_copilot_settings(copilot_dir: &Path) -> CopilotSettings {
let Ok(text) = std::fs::read_to_string(copilot_dir.join("settings.json")) else {
return CopilotSettings::default();
};
let Ok(root) = parse_jsonc_value(&text) else {
return CopilotSettings::default();
};
let disabled_mcp_servers = root
.get("disabledMcpServers")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned))
.collect::<BTreeSet<_>>()
})
.unwrap_or_default();
let disabled_plugins = root
.get("enabledPlugins")
.and_then(Value::as_object)
.map(|obj| {
obj.iter()
.filter(|(_, v)| v.as_bool() == Some(false))
.map(|(k, _)| k.trim().to_owned())
.filter(|k| !k.is_empty())
.collect::<BTreeSet<_>>()
})
.unwrap_or_default();
CopilotSettings { disabled_mcp_servers: std::sync::Arc::new(disabled_mcp_servers), disabled_plugins }
}
fn copilot_plugin_source_specs(copilot_dir: &Path, settings: &CopilotSettings) -> Vec<SourceSpec> {
let Ok(text) = std::fs::read_to_string(copilot_dir.join("config.json")) else {
return Vec::new();
};
let Ok(root) = parse_jsonc_value(&text) else {
return Vec::new();
};
let Some(installed) = root.get("installedPlugins").and_then(Value::as_array) else {
return Vec::new();
};
let mut seen_ids = HashSet::new();
let mut specs = Vec::new();
for entry in installed {
let Some(obj) = entry.as_object() else { continue };
if obj.get("enabled").and_then(Value::as_bool) == Some(false) {
continue;
}
let Some(name) = obj.get("name").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()) else {
continue;
};
let marketplace = obj.get("marketplace").and_then(Value::as_str).map(str::trim).unwrap_or_default();
if settings.disabled_plugins.contains(name)
|| (!marketplace.is_empty()
&& (settings.disabled_plugins.contains(&format!("{name}@{marketplace}"))
|| settings.disabled_plugins.contains(&format!("{marketplace}/{name}"))))
{
continue;
}
let Some(raw_cache) = obj.get("cache_path").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty())
else {
continue;
};
let plugin_root =
if Path::new(raw_cache).is_relative() { copilot_dir.join(raw_cache) } else { PathBuf::from(raw_cache) };
if !plugin_root.is_dir() {
continue;
}
let Some((manifest_path, _)) = read_copilot_plugin_servers(&plugin_root) else {
continue;
};
let base_id = if marketplace.is_empty() {
format!("copilot-plugin:{name}")
} else {
format!("copilot-plugin:{marketplace}/{name}")
};
let mut id = base_id.clone();
let mut suffix = 2usize;
while !seen_ids.insert(id.clone()) {
id = format!("{base_id}#{suffix}");
suffix += 1;
}
let label = if marketplace.is_empty() {
format!("GitHub Copilot Plugin ({name})")
} else {
format!("GitHub Copilot Plugin ({name} · {marketplace})")
};
specs.push(SourceSpec {
id,
label,
path: manifest_path,
format: SourceFormat::CopilotPlugin { root: plugin_root },
suggested_scope: McpScope::User,
native_provider: Some("copilot"),
claude_project_lookup: false,
disabled_servers: settings.disabled_mcp_servers.clone(),
});
}
specs
}
fn resolve_within_dir(base_dir: &Path, candidate: &Path) -> Option<PathBuf> {
if candidate.as_os_str().is_empty() {
return None;
}
let base_canon = dunce::canonicalize(base_dir).ok()?;
let clean = candidate.strip_prefix(".").unwrap_or(candidate);
let joined = if clean.is_relative() { base_dir.join(clean) } else { clean.to_path_buf() };
let meta = std::fs::metadata(&joined).ok()?;
if !meta.is_file() {
return None;
}
let target_canon = dunce::canonicalize(&joined).ok()?;
target_canon.starts_with(&base_canon).then_some(joined)
}
fn expand_plugin_root_vars(value: &str, root: &str) -> String {
value.replace("${COPILOT_PLUGIN_ROOT}", root).replace("${CLAUDE_PLUGIN_ROOT}", root).replace("${PLUGIN_ROOT}", root)
}
fn expand_plugin_servers(servers: &mut BTreeMap<String, AgentMcpServer>, plugin_root: &Path) {
let root = plugin_root.to_string_lossy();
for srv in servers.values_mut() {
if let Some(cmd) = srv.command.as_mut() {
*cmd = expand_plugin_root_vars(cmd, &root);
}
for arg in &mut srv.args {
*arg = expand_plugin_root_vars(arg, &root);
}
if let Some(url) = srv.url.as_mut() {
*url = expand_plugin_root_vars(url, &root);
}
for val in srv.env.values_mut() {
*val = expand_plugin_root_vars(val, &root);
}
for val in srv.headers.values_mut() {
*val = expand_plugin_root_vars(val, &root);
}
}
}
fn extract_plugin_manifest_servers(
plugin_root: &Path,
manifest_path: &Path,
mcp_val: &Value,
) -> (PathBuf, BTreeMap<String, AgentMcpServer>) {
match mcp_val {
Value::String(rel) => {
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
let map = read_external_file(&path);
return (path, map);
}
(manifest_path.to_path_buf(), BTreeMap::new())
}
Value::Object(_) => {
let wrapper = json!({ "mcpServers": mcp_val });
(manifest_path.to_path_buf(), extract_servers_from_root(&wrapper, None))
}
Value::Array(items) => {
let mut merged = BTreeMap::new();
let mut first_path: Option<PathBuf> = None;
for item in items {
match item {
Value::String(rel) => {
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
let map = read_external_file(&path);
if !map.is_empty() && first_path.is_none() {
first_path = Some(path);
}
merged.extend(map);
}
}
Value::Object(_) => {
let map = extract_servers_from_root(item, None);
if !map.is_empty() && first_path.is_none() {
first_path = Some(manifest_path.to_path_buf());
}
merged.extend(map);
}
_ => {}
}
}
(first_path.unwrap_or_else(|| manifest_path.to_path_buf()), merged)
}
_ => (manifest_path.to_path_buf(), BTreeMap::new()),
}
}
fn read_copilot_plugin_servers(plugin_root: &Path) -> Option<(PathBuf, BTreeMap<String, AgentMcpServer>)> {
if let Some(dot_mcp) = resolve_within_dir(plugin_root, Path::new(".mcp.json")) {
let mut servers = read_external_file(&dot_mcp);
if !servers.is_empty() {
expand_plugin_servers(&mut servers, plugin_root);
return Some((dot_mcp, servers));
}
}
for rel in COPILOT_PLUGIN_MANIFESTS {
let Some(manifest_path) = resolve_within_dir(plugin_root, Path::new(rel)) else {
continue;
};
let Ok(text) = std::fs::read_to_string(&manifest_path) else {
continue;
};
let Ok(manifest) = parse_jsonc_value(&text) else {
continue;
};
let Some(mcp_val) = manifest.get("mcpServers") else {
continue;
};
let (source_path, mut servers) = extract_plugin_manifest_servers(plugin_root, &manifest_path, mcp_val);
if !servers.is_empty() {
expand_plugin_servers(&mut servers, plugin_root);
return Some((source_path, servers));
}
}
None
}
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
let mut servers = match &spec.format {
SourceFormat::CopilotPlugin { root } => {
read_copilot_plugin_servers(root).map(|(_, map)| map).unwrap_or_default()
}
SourceFormat::CodexToml => {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
parse_codex_toml_servers(&text)
}
SourceFormat::Jsonc => {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
};
let mut map = extract_servers_from_root(&root, None);
if spec.claude_project_lookup
&& let Some(ws) = workspace_root
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
{
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
for (proj_key, proj_val) in projects {
let matches =
Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
if matches {
for (name, srv) in extract_servers_from_root(proj_val, None) {
map.insert(name, srv);
}
}
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
if spec.format == SourceFormat::CodexToml {
return parse_codex_toml_servers(&text);
}
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
};
let mut servers = extract_servers_from_root(&root, None);
if spec.claude_project_lookup
&& let Some(ws) = workspace_root
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
{
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
for (proj_key, proj_val) in projects {
let matches = Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
if matches {
for (name, srv) in extract_servers_from_root(proj_val, None) {
servers.insert(name, srv);
}
}
map
}
};
for name in spec.disabled_servers.iter() {
if let Some(srv) = servers.get_mut(name) {
srv.enabled = false;
}
}
servers
@@ -878,8 +612,8 @@ pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option
})
.collect();
out.push(McpExternalSource {
id: spec.id,
label: spec.label,
id: spec.id.to_owned(),
label: spec.label.to_owned(),
path: IpcPath(spec.path),
suggested_scope: spec.suggested_scope,
native_provider: spec.native_provider.map(str::to_owned),
@@ -907,7 +641,7 @@ pub fn apply_import_selected(
let mut by_source: BTreeMap<&str, BTreeMap<String, AgentMcpServer>> = BTreeMap::new();
for spec in &specs {
if selections.iter().any(|s| s.source_id == spec.id) {
by_source.insert(spec.id.as_str(), read_source_servers(spec, workspace_root));
by_source.insert(spec.id, read_source_servers(spec, workspace_root));
}
}
let target = match scope {
@@ -1636,125 +1370,4 @@ mod tests {
assert_eq!(workspace["events-sse"].transport, McpTransport::Sse);
assert_eq!(workspace["events-sse"].url.as_deref(), Some("https://sse.example.com/events"));
}
#[test]
fn discovers_and_imports_copilot_installed_plugin_mcp_servers() {
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("home");
let copilot = home.join(".copilot");
let azure_root = copilot.join("installed-plugins/_direct/azure-skills");
let inline_root = copilot.join("installed-plugins/awesome-copilot/inline-tools");
let disabled_root = copilot.join("installed-plugins/_direct/disabled-plug");
let outside_root = tmp.path().join("outside");
std::fs::create_dir_all(azure_root.join(".plugin")).unwrap();
std::fs::create_dir_all(inline_root.join(".claude-plugin")).unwrap();
std::fs::create_dir_all(&disabled_root).unwrap();
std::fs::create_dir_all(&outside_root).unwrap();
std::fs::write(
azure_root.join(".plugin/plugin.json"),
r#"{"name":"azure","version":"1.2.106","mcpServers":"./.mcp.json"}"#,
)
.unwrap();
std::fs::write(
azure_root.join(".mcp.json"),
r#"{"mcpServers":{"azure":{"command":"npx","args":["-y","@azure/mcp@latest","${COPILOT_PLUGIN_ROOT}/cfg"],"env":{"PLUG_DIR":"${CLAUDE_PLUGIN_ROOT}"}}}}"#,
)
.unwrap();
std::fs::write(
inline_root.join(".claude-plugin/plugin.json"),
r#"{"name":"inline-tools","version":"0.1.0","mcpServers":{"inline-srv":{"command":"${PLUGIN_ROOT}/bin/run","args":["--stdio"]},"muted-srv":{"command":"echo","args":["off"]}}}"#,
)
.unwrap();
std::fs::write(
disabled_root.join(".mcp.json"),
r#"{"mcpServers":{"never":{"command":"npx","args":["never"]}}}"#,
)
.unwrap();
std::fs::write(outside_root.join("secret.json"), r#"{"mcpServers":{"escaped":{"command":"sh"}}}"#).unwrap();
let escape_root = copilot.join("installed-plugins/_direct/escape-plug");
std::fs::create_dir_all(escape_root.join(".plugin")).unwrap();
std::fs::write(
escape_root.join(".plugin/plugin.json"),
r#"{"name":"escape-plug","mcpServers":"../../../../outside/secret.json"}"#,
)
.unwrap();
// `~/.copilot/config.json` includes leading `//` comments in Copilot CLI.
let config_json = format!(
"// Managed automatically.\n{}",
serde_json::json!({
"installedPlugins": [
{
"name": "azure",
"marketplace": "",
"enabled": true,
"cache_path": azure_root,
},
{
"name": "inline-tools",
"marketplace": "awesome-copilot",
"enabled": true,
"cache_path": inline_root,
},
{
"name": "disabled-plug",
"marketplace": "",
"enabled": false,
"cache_path": disabled_root,
},
{
"name": "escape-plug",
"marketplace": "",
"enabled": true,
"cache_path": escape_root,
}
]
})
);
std::fs::write(copilot.join("config.json"), config_json).unwrap();
std::fs::write(copilot.join("settings.json"), r#"{"disabledMcpServers":["muted-srv"]}"#).unwrap();
let sources = discover_external_sources(Some(&home), None);
assert_eq!(sources.len(), 2);
let azure_src = sources.iter().find(|s| s.id == "copilot-plugin:azure").unwrap();
assert_eq!(azure_src.label, "GitHub Copilot Plugin (azure)");
assert_eq!(azure_src.native_provider.as_deref(), Some("copilot"));
assert_eq!(azure_src.path.0, azure_root.join(".mcp.json"));
assert_eq!(azure_src.servers.len(), 1);
assert!(azure_src.servers[0].enabled);
assert_eq!(
azure_src.servers[0].args,
vec!["-y", "@azure/mcp@latest", &format!("{}/cfg", azure_root.display())]
);
let inline_src = sources.iter().find(|s| s.id == "copilot-plugin:awesome-copilot/inline-tools").unwrap();
assert_eq!(inline_src.label, "GitHub Copilot Plugin (inline-tools · awesome-copilot)");
assert_eq!(inline_src.path.0, inline_root.join(".claude-plugin/plugin.json"));
let active = inline_src.servers.iter().find(|s| s.name == "inline-srv").unwrap();
assert!(active.enabled);
assert_eq!(active.command.as_deref(), Some(format!("{}/bin/run", inline_root.display()).as_str()));
let muted = inline_src.servers.iter().find(|s| s.name == "muted-srv").unwrap();
assert!(!muted.enabled);
let mut user = BTreeMap::new();
let mut workspace = BTreeMap::new();
let imported = apply_import_selected(
&mut user,
&mut workspace,
Some(&home),
None,
McpScope::User,
&[McpImportSelection { source_id: "copilot-plugin:azure".into(), name: "azure".into() }],
false,
)
.unwrap();
assert_eq!(imported, vec!["azure".to_string()]);
assert_eq!(user["azure"].env.get("PLUG_DIR").map(String::as_str), Some(azure_root.to_str().unwrap()));
}
}
-2
Переглянути файл
@@ -672,8 +672,6 @@ pub enum AgentChangesView {
SinceStart,
/// The uncommitted files against `HEAD`; commits made since the start stay.
Group,
/// What the last turn changed, against the checkout as that turn started.
LastTurn,
}
/// A task's uncommitted files and the commits made since it started.
+15 -272
Переглянути файл
@@ -24,9 +24,7 @@ use std::process::Command;
use std::time::Duration;
pub const REGISTRY_URL: &str = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
const COPILOT_RELEASE_BASE: &str = "https://github.com/github/copilot-cli/releases/download";
const MAX_REGISTRY_BYTES: u64 = 1024 * 1024;
const MAX_CHECKSUM_BYTES: u64 = 64 * 1024;
/// [`maintain`] refreshes a saved index older than this, so updates show without opening
/// the registry.
const REFRESH_AFTER: Duration = Duration::from_secs(24 * 60 * 60);
@@ -144,9 +142,6 @@ struct Binary {
env: BTreeMap<String, String>,
#[serde(default)]
sha256: Option<String>,
/// Checksum manifest (`SHA256SUMS.txt`) naming `archive`'s filename when `sha256` is not inline.
#[serde(skip)]
sha256_url: Option<String>,
}
#[derive(Clone, Debug, Deserialize)]
@@ -177,48 +172,11 @@ fn parse(text: &str) -> IdeResult<Vec<Entry>> {
if let Some(name) = provider::builtin_name(&e.id) {
e.name = name.to_owned();
}
if e.id == "copilot" {
add_copilot_release_binaries(&mut e, COPILOT_RELEASE_BASE);
}
e
})
.collect())
}
/// Upstream `github-copilot-cli` lists only an `npx` wrapper in the ACP Registry, while
/// `github/copilot-cli` publishes standalone archives and `SHA256SUMS.txt` on every GitHub
/// release. Supplying them installs Copilot without Node.js, npm, `~/.npmrc`, or mirror lag.
fn add_copilot_release_binaries(entry: &mut Entry, release_base: &str) {
let tag = format!("v{}", entry.version.trim_start_matches('v'));
let base = format!("{}/{}", release_base.trim_end_matches('/'), tag);
let sha256_url = format!("{base}/SHA256SUMS.txt");
let (args, env) = match &entry.distribution.npx {
Some(p) => (p.args.clone(), p.env.clone()),
None => (vec!["--acp".into()], BTreeMap::new()),
};
let linux = if cfg!(target_env = "musl") { "linuxmusl" } else { "linux" };
let linux_arm = format!("copilot-{linux}-arm64.tar.gz");
let linux_x64 = format!("copilot-{linux}-x64.tar.gz");
let targets = [
("darwin-aarch64", "copilot-darwin-arm64.tar.gz", "./copilot"),
("darwin-x86_64", "copilot-darwin-x64.tar.gz", "./copilot"),
("linux-aarch64", linux_arm.as_str(), "./copilot"),
("linux-x86_64", linux_x64.as_str(), "./copilot"),
("windows-aarch64", "copilot-win32-arm64.zip", "copilot.exe"),
("windows-x86_64", "copilot-win32-x64.zip", "copilot.exe"),
];
for (key, asset, cmd) in targets {
entry.distribution.binary.entry(key.to_owned()).or_insert_with(|| Binary {
archive: format!("{base}/{asset}"),
cmd: cmd.to_owned(),
args: args.clone(),
env: env.clone(),
sha256: None,
sha256_url: Some(sha256_url.clone()),
});
}
}
fn safe_segment(s: &str) -> bool {
!s.is_empty()
&& !s.starts_with('.')
@@ -358,7 +316,7 @@ fn visible(
None
};
let choice = choose(e, platform, on_path);
let no_checksum = matches!(choice, Some(Choice::Binary(b)) if b.sha256.is_none() && b.sha256_url.is_none());
let no_checksum = matches!(choice, Some(Choice::Binary(b)) if b.sha256.is_none());
let distribution = choice.map(|c| c.kind());
if distribution.is_none() && installed.is_none() {
return None;
@@ -465,20 +423,6 @@ fn install_entry(
on_path: &dyn Fn(&str) -> bool,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<()> {
install_entry_with(paths, entry, platform, on_path, &install_npm, cancel, emit)
}
type NpmInstaller = dyn Fn(&Package, &Entry, &Path, Platform, &CancellationToken, Emit) -> IdeResult<PathBuf>;
fn install_entry_with(
paths: &RegistryPaths,
entry: &Entry,
platform: Platform,
on_path: &dyn Fn(&str) -> bool,
npm_installer: &NpmInstaller,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<()> {
if is_builtin(&entry.id) {
return Err(IdeError::invalid(format!("{} is built in", entry.name)));
@@ -499,32 +443,9 @@ fn install_entry_with(
}
fs::create_dir_all(&dir)?;
let installed = match &choice {
Choice::Binary(b) => match install_binary(b, &dir, cancel, emit) {
Ok(exe) => Ok((exe, b.args.clone(), b.env.clone())),
Err(e)
if !cancel.is_cancelled()
&& e.kind != ErrorKind::Cancelled
&& !e.message.starts_with("checksum mismatch:")
&& entry.distribution.npx.is_some()
&& on_path("npm")
&& on_path("node") =>
{
let p = entry.distribution.npx.as_ref().expect("checked");
emit(InstallEvent::Line {
text: format!("Binary download failed ({}); falling back to npm…", e.message),
});
fs::remove_dir_all(&dir)?;
fs::create_dir_all(&dir)?;
npm_installer(p, entry, &dir, platform, cancel, emit)
.map(|exe| (exe, p.args.clone(), p.env.clone()))
.map_err(|npm_err| {
IdeError::new(npm_err.kind, format!("{}; npm fallback failed: {}", e.message, npm_err.message))
})
}
Err(e) => Err(e),
},
Choice::Binary(b) => install_binary(b, &dir, cancel, emit).map(|exe| (exe, b.args.clone(), b.env.clone())),
Choice::Npx(p) => {
npm_installer(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
install_npm(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
}
Choice::Uvx(p) => {
install_uv(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
@@ -587,23 +508,13 @@ fn install_binary(b: &Binary, dir: &Path, cancel: &CancellationToken, emit: Emit
fs::create_dir_all(&downloads)?;
let file = downloads.join(name);
emit(InstallEvent::Line { text: format!("Downloading {}", b.archive) });
let http = http()?;
http.download(&b.archive, &file, None, cancel, emit)?;
match (&b.sha256, &b.sha256_url) {
(Some(expected), _) => {
http()?.download(&b.archive, &file, None, cancel, emit)?;
match &b.sha256 {
Some(expected) => {
verify_sha256(&file, expected)?;
emit(InstallEvent::Line { text: "SHA-256 checksum verified".into() });
}
(None, Some(checksum_url)) => {
check_url(checksum_url)?;
let text = http.get_text_limited(checksum_url, Some(MAX_CHECKSUM_BYTES), cancel)?;
let expected = ide_tools::sources::parse_checksum(&text, name).ok_or_else(|| {
IdeError::new(ErrorKind::Protocol, format!("no SHA-256 checksum for {name} in {checksum_url}"))
})?;
verify_sha256(&file, &expected)?;
emit(InstallEvent::Line { text: "SHA-256 checksum verified".into() });
}
(None, None) => emit(InstallEvent::Line { text: "The registry gives no checksum for this download".into() }),
None => emit(InstallEvent::Line { text: "The registry gives no checksum for this download".into() }),
}
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
@@ -656,20 +567,6 @@ fn install_npm(
platform: Platform,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<PathBuf> {
let (name, _) = split_npm_spec(&p.package);
let npm = which::which("npm").map_err(|_| IdeError::unavailable(format!("npm is required to install {name}")))?;
install_npm_with(&npm, p, entry, dir, platform, cancel, emit)
}
fn install_npm_with(
npm: &Path,
p: &Package,
entry: &Entry,
dir: &Path,
platform: Platform,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<PathBuf> {
let (name, version) = split_npm_spec(&p.package);
let spec = match version {
@@ -677,27 +574,10 @@ fn install_npm_with(
_ => format!("{name}@{}", entry.version),
};
check_spec(&spec)?;
let specs = [spec.clone()];
ide_tools::run_npm_with_public_fallback(
|extra| {
if !extra.is_empty() {
let _ = fs::remove_dir_all(dir.join("node_modules"));
}
let mut cmd = Command::new(npm);
cmd.arg("install")
.arg("--prefix")
.arg(dir)
.args(["--no-audit", "--no-fund"])
.args(extra)
.arg(&spec)
.current_dir(dir);
cmd
},
&specs,
false,
cancel,
emit,
)?;
let npm = which::which("npm").map_err(|_| IdeError::unavailable(format!("npm is required to install {name}")))?;
let mut cmd = Command::new(npm);
cmd.arg("install").arg("--prefix").arg(dir).args(["--no-audit", "--no-fund"]).arg(&spec).current_dir(dir);
ide_tools::run_streamed(cmd, cancel, emit)?;
let modules = dir.join("node_modules");
let manifest: serde_json::Value = fs::read_to_string(modules.join(name).join("package.json"))
.ok()
@@ -992,58 +872,6 @@ mod tests {
assert!(check_url("ftp://x/a").is_err());
}
#[cfg(unix)]
#[test]
fn npm_registry_agent_retries_against_public_npmjs_on_mirror_miss() {
let dir = tempfile::tempdir().unwrap();
let install_dir = dir.path().join("acme/1.2.0");
fs::create_dir_all(&install_dir).unwrap();
let log = dir.path().join("npm-calls.log");
let npm = dir.path().join("npm");
fs::write(
&npm,
format!(
r#"#!/bin/sh
echo "$@" >> '{}'
case " $* " in
*" --registry=https://registry.npmjs.org/ --@acme:registry=https://registry.npmjs.org/ "*)
prefix=""; while [ $# -gt 0 ]; do [ "$1" = "--prefix" ] && prefix="$2"; shift; done
mkdir -p "$prefix/node_modules/.bin" "$prefix/node_modules/@acme/agent-acp"
printf '#!/bin/sh\necho 1.2.0\n' > "$prefix/node_modules/.bin/agent-acp"
chmod +x "$prefix/node_modules/.bin/agent-acp"
printf '{{"bin":"cli.js"}}\n' > "$prefix/node_modules/@acme/agent-acp/package.json"
exit 0
;;
*)
echo "npm error code ETARGET" >&2
echo "npm error notarget No matching version found for @acme/[email protected]." >&2
exit 1
;;
esac
"#,
log.display()
),
)
.unwrap();
archive::make_executable(&npm).unwrap();
let index = r#"{"agents":[
{"id":"acme","name":"Acme","version":"1.2.0",
"distribution":{"npx":{"package":"@acme/[email protected]","args":["--acp"]}}}
]}"#;
let entry = parse(index).unwrap().remove(0);
let pkg = entry.distribution.npx.as_ref().unwrap();
let exe =
install_npm_with(&npm, pkg, &entry, &install_dir, MAC_ARM, &CancellationToken::new(), &|_| {}).unwrap();
let calls: Vec<String> = fs::read_to_string(&log).unwrap().lines().map(str::to_owned).collect();
assert_eq!(calls.len(), 2, "{calls:?}");
assert!(!calls[0].contains("--registry="), "{calls:?}");
assert!(calls[1].contains("--registry=https://registry.npmjs.org/"), "{calls:?}");
assert!(calls[1].contains("--@acme:registry=https://registry.npmjs.org/"), "{calls:?}");
assert_eq!(exe, install_dir.join("node_modules/.bin/agent-acp"));
assert!(exe.is_file());
}
#[test]
fn checksums_are_verified() {
let dir = tempfile::tempdir().unwrap();
@@ -1141,18 +969,11 @@ esac
assert_eq!(entries.len(), 1);
assert_eq!((entries[0].id.as_str(), entries[0].name.as_str()), ("copilot", "GitHub Copilot"));
// Copilot installs as a verified GitHub Release binary even without Node.js or npm.
let shown = visible(&p, &entries, MAC_ARM, &|_| false);
let shown = visible(&p, &entries, MAC_ARM, &|c| c == "npm" || c == "node");
assert_eq!(shown.len(), 1);
assert_eq!(
(
shown[0].id.as_str(),
shown[0].name.as_str(),
shown[0].installed.as_deref(),
shown[0].distribution,
shown[0].no_checksum,
),
("copilot", "GitHub Copilot", None, Some(RegistryDistribution::Binary), false)
(shown[0].id.as_str(), shown[0].name.as_str(), shown[0].installed.as_deref()),
("copilot", "GitHub Copilot", None)
);
CustomAgent {
@@ -1166,7 +987,7 @@ esac
.write(&p.agent_file("copilot"))
.unwrap();
let shown = visible(&p, &entries, MAC_ARM, &|_| false);
let shown = visible(&p, &entries, MAC_ARM, &|c| c == "npm" || c == "node");
assert_eq!((shown[0].installed.as_deref(), shown[0].update), (Some("1.0.104"), true));
write_atomic(&p.cache_file, index.as_bytes()).unwrap();
@@ -1186,82 +1007,4 @@ esac
let fallback = provider::load(Some(&p.agents_dir), None).into_iter().find(|s| s.id == "copilot").unwrap();
assert_eq!(fallback.source, AgentSource::Builtin);
}
#[cfg(unix)]
#[test]
fn installs_copilot_from_verified_release_archive_and_falls_back_to_npm_when_unavailable() {
let dir = tempfile::tempdir().unwrap();
let p = paths(dir.path());
let served = dir.path().join("releases/v1.0.114");
fs::create_dir_all(&served).unwrap();
let archive = served.join("copilot-darwin-arm64.tar.gz");
let stage = dir.path().join("archive-stage");
fs::create_dir_all(&stage).unwrap();
let staged_exe = stage.join("copilot");
fs::write(&staged_exe, "#!/bin/sh\necho 1.0.114\n").unwrap();
archive::make_executable(&staged_exe).unwrap();
assert!(
Command::new("tar")
.arg("-czf")
.arg(&archive)
.arg("-C")
.arg(&stage)
.arg("copilot")
.status()
.unwrap()
.success()
);
let sha = ide_tools::sources::sha256_file(&archive).unwrap();
let sums = served.join("SHA256SUMS.txt");
fs::write(&sums, format!("{sha} copilot-darwin-arm64.tar.gz\n")).unwrap();
let index = r#"{"agents":[
{"id":"github-copilot-cli","name":"Copilot","version":"1.0.114",
"distribution":{"npx":{"package":"@github/[email protected]","args":["--acp"]}}}
]}"#;
let mut entry = parse(index).unwrap().remove(0);
entry.distribution.binary.clear();
add_copilot_release_binaries(&mut entry, &format!("file://{}", dir.path().join("releases").display()));
let fake_npm = |_: &Package, _: &Entry, dest: &Path, _: Platform, _: &CancellationToken, _: Emit| {
let exe = dest.join("node_modules/.bin/copilot");
fs::create_dir_all(exe.parent().unwrap())?;
fs::write(&exe, "#!/bin/sh\necho npm-1.0.114\n")?;
archive::make_executable(&exe)?;
Ok(exe)
};
let node_on_path = |cmd: &str| matches!(cmd, "npm" | "node");
let cancel = CancellationToken::new();
let lines = std::sync::Mutex::new(Vec::new());
let emit = |e: InstallEvent| {
if let InstallEvent::Line { text } = e {
lines.lock().unwrap().push(text);
}
};
// 1. Verified GitHub Release archive installs directly without invoking npm.
install_entry_with(&p, &entry, MAC_ARM, &|_| false, &fake_npm, &cancel, &emit).unwrap();
assert!(lines.lock().unwrap().iter().any(|l| l == "SHA-256 checksum verified"));
let installed_bin = p.tools_dir.join("copilot/1.0.114/copilot");
assert!(installed_bin.is_file());
let saved = CustomAgent::read(&p.agent_file("copilot")).unwrap();
assert_eq!(saved.command, installed_bin.to_string_lossy());
assert_eq!(saved.args, ["--acp"]);
// 2. A tampered binary fails checksum verification and never falls back to npm.
fs::write(&sums, format!("{} copilot-darwin-arm64.tar.gz\n", "0".repeat(64))).unwrap();
let err = install_entry_with(&p, &entry, MAC_ARM, &node_on_path, &fake_npm, &cancel, &emit).unwrap_err();
assert!(err.message.contains("checksum mismatch"), "{err:?}");
assert!(!p.tools_dir.join("copilot/1.0.114").exists());
// 3. When the release download itself is unreachable, npm fallback installs it.
fs::remove_file(&archive).unwrap();
lines.lock().unwrap().clear();
install_entry_with(&p, &entry, MAC_ARM, &node_on_path, &fake_npm, &cancel, &emit).unwrap();
assert!(lines.lock().unwrap().iter().any(|l| l.contains("falling back to npm")));
let npm_bin = p.tools_dir.join("copilot/1.0.114/node_modules/.bin/copilot");
assert!(npm_bin.is_file());
assert_eq!(CustomAgent::read(&p.agent_file("copilot")).unwrap().command, npm_bin.to_string_lossy());
}
}
-160
Переглянути файл
@@ -1,160 +0,0 @@
//! `!` commands from the composer: run in the task's folder with the user's shell, outside
//! any turn, and handed to the agent with the next message as Claude Code's bash mode does.
use ide_core::CancellationToken;
use std::path::Path;
use std::process::Stdio;
use tokio::io::AsyncReadExt;
use tokio::process::Command;
/// Output kept from each stream; longer output keeps its tail.
const MAX_STREAM: usize = 32 * 1024;
#[derive(Debug, Default, PartialEq)]
pub(crate) struct Ran {
/// The exit code; `None` when it didn't start, was stopped or ended by a signal.
pub code: Option<i32>,
pub stdout: String,
pub stderr: String,
/// Why it didn't finish: it couldn't start, or it was stopped.
pub error: Option<String>,
}
impl Ran {
/// What the conversation shows: the output, then how it ended unless it succeeded.
pub fn shown(&self) -> String {
let mut text = [self.stdout.trim_end(), self.stderr.trim_end()]
.into_iter()
.filter(|t| !t.is_empty())
.collect::<Vec<_>>()
.join("\n");
let end = match (&self.error, self.code) {
(Some(error), _) => Some(error.clone()),
(None, Some(0)) => None,
(None, Some(code)) => Some(format!("Exit code {code}")),
(None, None) => Some("Terminated".into()),
};
if let Some(end) = end {
if !text.is_empty() {
text.push('\n');
}
text.push_str(&end);
}
text
}
/// The block that goes to the agent ahead of the next message.
pub fn context(&self, command: &str) -> String {
let mut stderr = self.stderr.trim_end().to_owned();
if let Some(error) = &self.error {
if !stderr.is_empty() {
stderr.push('\n');
}
stderr.push_str(error);
} else if let Some(code) = self.code.filter(|c| *c != 0) {
if !stderr.is_empty() {
stderr.push('\n');
}
stderr.push_str(&format!("Exit code {code}"));
}
format!(
"<bash-input>{command}</bash-input>\n<bash-stdout>{}</bash-stdout><bash-stderr>{stderr}</bash-stderr>",
self.stdout.trim_end()
)
}
}
/// Runs `command` with the user's shell in `cwd` until it ends or `cancel` stops it.
pub(crate) async fn run(command: &str, cwd: &Path, cancel: &CancellationToken) -> Ran {
let mut cmd = shell(command);
ide_core::process::prepare(cmd.as_std_mut());
cmd.current_dir(cwd).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true);
let mut child = match cmd.spawn() {
Ok(child) => child,
Err(e) => return Ran { error: Some(format!("Cannot run it: {e}")), ..Ran::default() },
};
let (Some(mut out), Some(mut err)) = (child.stdout.take(), child.stderr.take()) else {
return Ran { error: Some("Cannot read its output".into()), ..Ran::default() };
};
let finished = async move {
let (mut stdout, mut stderr) = (Vec::new(), Vec::new());
let _ = tokio::join!(out.read_to_end(&mut stdout), err.read_to_end(&mut stderr));
let code = child.wait().await.ok().and_then(|s| s.code());
Ran { code, stdout: tail(&stdout), stderr: tail(&stderr), error: None }
};
tokio::select! {
ran = finished => ran,
// Dropping the child kills it.
() = cancel.cancelled() => Ran { error: Some("Stopped".into()), ..Ran::default() },
}
}
#[cfg(not(windows))]
fn shell(command: &str) -> Command {
let shell = std::env::var("SHELL").ok().filter(|s| !s.trim().is_empty()).unwrap_or_else(|| "/bin/sh".into());
let mut cmd = Command::new(shell);
cmd.arg("-c").arg(command);
cmd
}
#[cfg(windows)]
fn shell(command: &str) -> Command {
let mut cmd = Command::new(std::env::var("COMSPEC").unwrap_or_else(|_| "cmd.exe".into()));
// `/S /C "…"` runs the line as typed: cmd strips only the outer quotes.
cmd.raw_arg("/D /S /C \"").raw_arg(command).raw_arg("\"");
cmd
}
fn tail(bytes: &[u8]) -> String {
let text = String::from_utf8_lossy(bytes);
if text.len() <= MAX_STREAM {
return text.into_owned();
}
let mut cut = text.len() - MAX_STREAM;
while !text.is_char_boundary(cut) {
cut += 1;
}
format!("…{}", &text[cut..])
}
#[cfg(all(test, not(windows)))]
mod tests {
use super::*;
#[tokio::test]
async fn runs_in_the_folder_and_reports_output_and_exit_code() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("marker.txt"), "").unwrap();
let ran = run("ls; echo oops >&2; exit 3", dir.path(), &CancellationToken::new()).await;
assert_eq!(ran.code, Some(3));
assert_eq!(ran.stdout.trim(), "marker.txt");
assert_eq!(ran.stderr.trim(), "oops");
assert_eq!(ran.shown(), "marker.txt\noops\nExit code 3");
assert_eq!(
ran.context("ls"),
"<bash-input>ls</bash-input>\n<bash-stdout>marker.txt</bash-stdout><bash-stderr>oops\nExit code 3</bash-stderr>"
);
}
#[tokio::test]
async fn a_stopped_command_is_killed() {
let dir = tempfile::tempdir().unwrap();
let cancel = CancellationToken::new();
let stop = cancel.clone();
tokio::spawn(async move {
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
stop.cancel();
});
let started = std::time::Instant::now();
let ran = run("sleep 30", dir.path(), &cancel).await;
assert!(started.elapsed() < std::time::Duration::from_secs(5));
assert_eq!(ran.shown(), "Stopped");
}
#[test]
fn long_output_keeps_its_tail() {
let long = "x".repeat(MAX_STREAM + 10) + "end";
let kept = tail(long.as_bytes());
assert!(kept.starts_with('…') && kept.ends_with("end"));
}
}
+4 -242
Переглянути файл
@@ -59,8 +59,6 @@ struct FakeAgent {
session_steering: bool,
/// Records the `mcpServers` array passed to `session/new`, `session/load`, and `session/fork`.
mcp_calls: Mutex<Vec<(String, Vec<String>)>>,
/// The content blocks of each `session/prompt`.
prompts: Mutex<Vec<Value>>,
}
impl FakeAgent {
@@ -249,17 +247,7 @@ impl Handler for FakeAgent {
Ok(json!({}))
}
"session/prompt" => {
self.prompts.lock().push(params.get("prompt").cloned().unwrap_or(Value::Null));
// `!` commands run since the last message come first; the message follows.
let first = match params.pointer("/prompt/0/text").and_then(Value::as_str) {
Some(t) if t.starts_with("<bash-input>") => 1,
_ => 0,
};
let text = params
.pointer(&format!("/prompt/{first}/text"))
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned();
let text = params.pointer("/prompt/0/text").and_then(Value::as_str).unwrap_or_default().to_owned();
if text.starts_with("<send_user_message_question_reply>") {
self.say(&session, "answer received");
return Ok(json!({"stopReason": "end_turn"}));
@@ -1373,53 +1361,6 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
}
#[cfg(not(windows))]
#[tokio::test(flavor = "multi_thread")]
async fn shell_commands_show_in_the_conversation_and_go_with_the_next_message() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let turns = agent.prompts.lock().len();
mgr.run_shell(&task.id, " echo shell-out ", ide_core::CancellationToken::new()).await.unwrap();
assert_eq!(agent.prompts.lock().len(), turns, "a `!` command starts no turn");
let entries = mgr.entries(&task.id, None).unwrap();
let Some(AgentEntry::Tool { title, kind, status, output, .. }) = entries.last() else {
panic!("no entry for the command: {entries:?}")
};
assert_eq!((title.as_str(), kind.as_str(), *status), ("! echo shell-out", "execute", AgentToolStatus::Completed));
assert_eq!(output.as_deref(), Some("shell-out"));
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let sent = agent.prompts.lock().last().cloned().unwrap();
assert_eq!(
sent.pointer("/0/text").and_then(Value::as_str),
Some(
"<bash-input>echo shell-out</bash-input>\n<bash-stdout>shell-out</bash-stdout><bash-stderr></bash-stderr>"
)
);
assert_eq!(sent.pointer("/1/text").and_then(Value::as_str), Some("again"));
// Only once.
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let sent = agent.prompts.lock().last().cloned().unwrap();
assert_eq!(sent.pointer("/0/text").and_then(Value::as_str), Some("again"));
}
#[tokio::test(flavor = "multi_thread")]
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
let tmp = tempfile::tempdir().unwrap();
@@ -2911,10 +2852,7 @@ async fn task_project_root_controls_local_and_worktree_repositories() {
let changes = mgr.changes(&task.id).await.unwrap();
assert_eq!(changes.len(), 1);
assert_eq!(changes[0].path.0, task.cwd.0.join("file.txt"));
assert_eq!(
mgr.base_text(&task.id, changes[0].path.0.clone(), AgentChangesView::SinceStart).await.unwrap().as_deref(),
Some("original\n")
);
assert_eq!(mgr.base_text(&task.id, changes[0].path.0.clone()).await.unwrap().as_deref(), Some("original\n"));
let saved = std::fs::read(root.join("store").join(format!("{}.json", task.id))).unwrap();
assert!(String::from_utf8(saved).unwrap().contains("projectRoot"));
let mut old = serde_json::to_value(&task).unwrap();
@@ -3698,178 +3636,6 @@ async fn changed(mgr: &AgentManager, id: &str) -> Vec<String> {
mgr.changes(id).await.unwrap().into_iter().map(|c| c.rel_path).collect()
}
/// Waits until the turn asks for permission, runs `work` (what the agent does), then stops it.
async fn one_turn(mgr: &AgentManager, id: &str, prompt: Option<&str>, work: impl FnOnce()) {
if let Some(prompt) = prompt {
mgr.prompt(id, text(prompt), false).await.unwrap();
}
wait_for(mgr, id, AgentStatus::NeedsInput).await;
work();
mgr.cancel(id, None).unwrap();
wait_for(mgr, id, AgentStatus::Ready).await;
}
async fn turn_changed(mgr: &AgentManager, id: &str) -> Vec<(String, ide_vcs::ChangeKind, u32, u32)> {
let changes = mgr.turn_changes(id).await.unwrap();
changes.into_iter().map(|c| (c.rel_path, c.kind, c.added, c.removed)).collect()
}
#[tokio::test(flavor = "multi_thread")]
async fn the_last_turn_lists_and_rolls_back_only_its_own_changes() {
use ide_vcs::ChangeKind::{Added, Deleted, Modified};
for isolation in [Isolation::Local, Isolation::Worktree] {
for eol in EOLS {
let repo = Checkout::new(eol);
repo.write("a.txt", "base\n");
repo.write("gone.txt", "base\n");
repo.write("mine.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("Hello"),
provider: "claude".into(),
isolation,
..Default::default()
})
.await
.unwrap();
let cwd = task.cwd.0.clone();
let write = |rel: &str, text: &str| {
let text = match eol {
Eol::Lf => text.to_owned(),
Eol::Crlf => text.replace('\n', "\r\n"),
};
std::fs::write(cwd.join(rel), text).unwrap();
};
let read = |rel: &str| std::fs::read_to_string(cwd.join(rel)).unwrap().replace("\r\n", "\n");
let case = format!("{isolation:?} {eol:?}");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}: no turn has ended yet");
one_turn(&mgr, &task.id, None, || {
write("a.txt", "base\nturn 1\n");
write("one.txt", "one\n");
})
.await;
// The user's own work between the turns belongs to neither.
write("mine.txt", "base\nmine\n");
one_turn(&mgr, &task.id, Some("more"), || {
write("a.txt", "base\nturn 1\nturn 2\n");
write("one.txt", "one\ntwo\n");
write("two.txt", "two\n");
std::fs::remove_file(cwd.join("gone.txt")).unwrap();
})
.await;
// And after the turn.
write("later.txt", "mine\n");
assert_eq!(
turn_changed(&mgr, &task.id).await,
[
("a.txt".into(), Modified, 1, 0),
("gone.txt".into(), Deleted, 0, 1),
("one.txt".into(), Modified, 1, 0),
("two.txt".into(), Added, 1, 0),
],
"{case}"
);
let turn_base = |rel: &str| {
let path = cwd.join(rel);
let mgr = &mgr;
let id = task.id.clone();
async move {
let text = mgr.base_text(&id, path, AgentChangesView::LastTurn).await.unwrap();
text.map(|t| t.replace("\r\n", "\n"))
}
};
assert_eq!(turn_base("a.txt").await.as_deref(), Some("base\nturn 1\n"), "{case}");
assert_eq!(turn_base("gone.txt").await.as_deref(), Some("base\n"), "{case}");
assert_eq!(turn_base("two.txt").await, None, "{case}");
let whole: Vec<String> = changed(&mgr, &task.id).await;
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
// One file, then the rest, after a restart: from the copies saved as the turn started.
mgr.rollback_changes(&task.id, Some(vec!["one.txt".into()]), AgentChangesView::LastTurn).await.unwrap();
assert_eq!(read("one.txt"), "one\n", "{case}");
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 3, "{case}");
mgr.shutdown();
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
assert_eq!(read("a.txt"), "base\nturn 1\n", "{case}");
assert_eq!(read("gone.txt"), "base\n", "{case}");
assert!(!cwd.join("two.txt").exists(), "{case}");
assert_eq!(read("mine.txt"), "base\nmine\n", "{case}: the user's edit between turns stays");
assert_eq!(read("later.txt"), "mine\n", "{case}: and the one after");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}");
// The task's own changes from its first turn stay.
let whole: Vec<String> = changed(&mgr, &task.id).await;
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
mgr.delete(&task.id, true).await.unwrap();
assert!(!repo.dir.join("store").join(format!("{}.turn", task.id)).exists(), "{case}");
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn rolling_back_the_whole_task_leaves_the_last_turn_nothing_to_list() {
let repo = Checkout::new(Eol::Lf);
repo.write("a.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask { prompt: text("Hello"), provider: "claude".into(), ..Default::default() })
.await
.unwrap();
one_turn(&mgr, &task.id, None, || repo.write("a.txt", "base\nturn 1\n")).await;
one_turn(&mgr, &task.id, Some("more"), || repo.write("a.txt", "base\nturn 1\nturn 2\n")).await;
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 1);
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert_eq!(repo.read("a.txt"), "base\n");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty());
}
#[tokio::test(flavor = "multi_thread")]
async fn a_commit_made_in_the_last_turn_is_among_its_changes() {
let repo = Checkout::new(Eol::Lf);
repo.write("a.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("Hello"),
provider: "claude".into(),
isolation: Isolation::Worktree,
..Default::default()
})
.await
.unwrap();
let cwd = task.cwd.0.clone();
let git = |args: &[&str]| {
let ok = std::process::Command::new("git")
.args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
.args(args)
.current_dir(&cwd)
.status()
.unwrap()
.success();
assert!(ok, "{args:?}");
};
one_turn(&mgr, &task.id, None, || {
std::fs::write(cwd.join("a.txt"), "base\nagent\n").unwrap();
std::fs::write(cwd.join("new.txt"), "new\n").unwrap();
git(&["add", "."]);
git(&["commit", "-q", "-m", "agent"]);
})
.await;
let rel: Vec<String> = mgr.turn_changes(&task.id).await.unwrap().into_iter().map(|c| c.rel_path).collect();
assert_eq!(rel, ["a.txt", "new.txt"]);
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
assert_eq!(std::fs::read_to_string(cwd.join("a.txt")).unwrap(), "base\n");
assert!(!cwd.join("new.txt").exists());
mgr.delete(&task.id, true).await.unwrap();
}
#[tokio::test(flavor = "multi_thread")]
async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
for eol in EOLS {
@@ -3886,7 +3652,7 @@ async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
repo.git(&["reset", "-q", "--soft", "HEAD~1"]);
assert_eq!(changed(&mgr, &task.id).await, ["a.txt"], "{eol:?}");
let base = mgr.base_text(&task.id, repo.dir.join("a.txt"), AgentChangesView::SinceStart).await.unwrap();
let base = mgr.base_text(&task.id, repo.dir.join("a.txt")).await.unwrap();
assert_eq!(base.map(|b| b.replace("\r\n", "\n")).as_deref(), Some("base\n"), "{eol:?}");
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert_eq!(repo.read("a.txt"), "base\n", "{eol:?}");
@@ -4026,11 +3792,7 @@ async fn a_local_task_in_a_repository_without_commits_lists_and_rolls_back_its_c
let (mgr, task) = repo.task().await;
repo.write("new.txt", "agent\n");
assert_eq!(changed(&mgr, &task.id).await, ["new.txt"], "{eol:?}");
assert_eq!(
mgr.base_text(&task.id, repo.dir.join("new.txt"), AgentChangesView::SinceStart).await.unwrap(),
None,
"{eol:?}"
);
assert_eq!(mgr.base_text(&task.id, repo.dir.join("new.txt")).await.unwrap(), None, "{eol:?}");
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert!(!repo.dir.join("new.txt").exists(), "{eol:?}");
+2 -249
Переглянути файл
@@ -3,7 +3,6 @@
use crate::model::{AgentChange, AgentChanges, AgentCommit};
use ide_core::{IdeError, IdeResult, IpcPath};
use ide_vcs::{ChangeKind, LogQuery, Repo};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use std::time::{Duration, UNIX_EPOCH};
@@ -611,6 +610,7 @@ pub(crate) fn restore(
before: &BTreeMap<String, Stamp>,
saved: Option<&Path>,
) -> IdeResult<()> {
let path = &change.path.0;
let content = match before.get(&change.rel_path) {
Some(None) => None,
Some(Some(_)) => {
@@ -626,16 +626,11 @@ pub(crate) fn restore(
None => match rev {
Some(rev) => {
let repo = Repo::discover(cwd)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
repo.file_bytes_at(&change.path.0, Some(rev))?
repo.file_bytes_at(path, Some(rev))?
}
None => None,
},
};
put(&change.path.0, content)
}
/// Writes `content` to `path`, or removes the file when there is none.
fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
match content {
Some(bytes) => {
if let Some(parent) = path.parent() {
@@ -651,187 +646,6 @@ fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
Ok(())
}
/// The bytes of the copy of `rel` saved in `dir`, if there is one.
pub(crate) fn saved_copy(dir: &Path, rel: &str) -> Option<Vec<u8>> {
std::fs::read(dir.join(saved_name(rel))).ok()
}
/// The checkout as the task's last turn started: what that turn's changes are compared with
/// and rolled back to. Recorded like the task's own start: `HEAD`, the files already changed,
/// and copies of those.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct TurnStart {
/// `HEAD` then (`None` outside a repository or before its first commit).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub head: Option<String>,
/// The files already changed then, stamped.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub before: BTreeMap<String, Stamp>,
/// The files among `before` with a copy in the task's turn folder.
#[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
pub saved: BTreeSet<String>,
/// The files that changed while the turn ran, recorded as it ended (`None` while it runs).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub changed: Option<BTreeSet<String>>,
}
/// Records the checkout at `cwd` as a turn starts, with copies of its changed files in `dir`.
/// The copies `previous` saved of files unchanged since are kept rather than made again, so
/// starting a turn copies little more than what the turn before it changed.
pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -> IdeResult<TurnStart> {
let Some(repo) = discover(cwd)? else { return Ok(TurnStart::default()) };
let head = repo.head()?.1;
// As the turn's end is read, so the two compare.
let before = snapshot(cwd)?;
let mut saved = BTreeSet::new();
match previous {
Some(previous) => {
for rel in &previous.saved {
let unchanged =
before.get(rel).is_some_and(|now| now.is_some() && previous.before.get(rel) == Some(now));
if unchanged {
saved.insert(rel.clone());
} else {
let _ = std::fs::remove_file(dir.join(saved_name(rel)));
}
}
}
None => {
let _ = std::fs::remove_dir_all(dir);
}
}
for (rel, stamp) in &before {
let path = repo.root().join(rel);
if stamp.is_none()
|| saved.contains(rel)
|| !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX)
{
continue;
}
std::fs::create_dir_all(dir)?;
// One that can't be copied is listed but can't be rolled back, as a large one.
if std::fs::copy(&path, dir.join(saved_name(rel))).is_ok() {
saved.insert(rel.clone());
}
}
Ok(TurnStart { head, before, saved, changed: None })
}
/// The files that changed in `cwd` since the turn `start` began: in the working tree (as
/// `changed_between` sees them), and in the commits made since.
pub(crate) fn changed_in_turn(cwd: &Path, start: &TurnStart) -> IdeResult<(Vec<String>, BTreeSet<String>)> {
let end = snapshot(cwd)?;
let worktree = changed_between(&start.before, &end);
let mut all: BTreeSet<String> = worktree.iter().cloned().collect();
if let Some(repo) = discover(cwd)?
&& let (Some(from), Some(to)) = (&start.head, repo.head()?.1)
&& *from != to
{
for f in repo.diff_revisions(from, &to)? {
all.extend(f.old_path);
all.insert(f.path);
}
}
Ok((worktree, all))
}
/// The content of `rel` as the turn `start` began (`None`: no file), its copies in `dir`.
fn at_turn_start(repo: &Repo, rel: &str, start: &TurnStart, dir: &Path) -> IdeResult<Option<Vec<u8>>> {
match start.before.get(rel) {
Some(None) => Ok(None),
Some(Some(_)) => match start.saved.contains(rel).then(|| saved_copy(dir, rel)).flatten() {
Some(bytes) => Ok(Some(bytes)),
None => Err(IdeError::invalid(format!(
"{rel} had changes when the turn started that weren't saved; roll it back in Git instead"
))),
},
None => match &start.head {
Some(head) => repo.file_bytes_at(&repo.root().join(rel), Some(head)),
None => Ok(None),
},
}
}
/// Added and removed lines from `old` to `new`; none for binary content.
fn line_stats(old: Option<&[u8]>, new: Option<&[u8]>) -> (u32, u32) {
if [old, new].iter().flatten().any(|b| b.contains(&0)) {
return (0, 0);
}
let text = |b: Option<&[u8]>| b.map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();
ide_vcs::diff_hunks(&text(old), &text(new))
.iter()
.fold((0, 0), |(added, removed), h| (added + h.lines, removed + h.old_lines))
}
/// The files among `changed` that differ from how they were as the turn `start` began.
pub(crate) fn turn_changes(
cwd: &Path,
start: &TurnStart,
dir: &Path,
changed: &BTreeSet<String>,
) -> IdeResult<Vec<AgentChange>> {
let Some(repo) = discover(cwd)? else { return Ok(Vec::new()) };
let mut out = Vec::new();
for rel in changed {
let path = repo.root().join(rel);
// A folder (a submodule, say) or a file that can't be read has nothing to compare.
let Some(now) = existing(&path) else { continue };
let (kind, (added, removed)) = match at_turn_start(&repo, rel, start, dir) {
Ok(then) if then == now => continue,
Ok(then) => {
let kind = match (&then, &now) {
(None, _) => ChangeKind::Added,
(_, None) => ChangeKind::Deleted,
_ => ChangeKind::Modified,
};
(kind, line_stats(then.as_deref(), now.as_deref()))
}
// Its start wasn't saved: listed, without counts.
Err(_) => (ChangeKind::Modified, (0, 0)),
};
out.push(AgentChange { path: IpcPath(path), rel_path: rel.clone(), kind, added, removed, old_path: None });
}
Ok(out)
}
/// The text of `path` as the turn `start` began, `None` when there was no file.
pub(crate) fn turn_text(cwd: &Path, path: &Path, start: &TurnStart, dir: &Path) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
let rel = rel_in(repo.root(), path)?;
if let (None, Some(head)) = (start.before.get(&rel), &start.head) {
return file_at(cwd, path, head);
}
let Some(bytes) = at_turn_start(&repo, &rel, start, dir)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
Ok(loaded) => encoding_rs::Encoding::for_label(loaded.encoding.as_bytes()).unwrap_or(encoding_rs::UTF_8),
Err(_) => ide_vfs::detect_encoding(&bytes, None),
};
Ok(Some(encoding.decode(&bytes).0.into_owned()))
}
/// `path` relative to the repository at `root`, with `/` separators.
fn rel_in(root: &Path, path: &Path) -> IdeResult<String> {
let rel = path
.strip_prefix(root)
.map(Path::to_path_buf)
.ok()
.or_else(|| {
// Another spelling of the same place (a link, `/var` and `/private/var`); the file may be gone.
let root = dunce::canonicalize(root).ok()?;
let parent = dunce::canonicalize(path.parent()?).ok()?;
Some(parent.strip_prefix(&root).ok()?.join(path.file_name()?))
})
.ok_or_else(|| IdeError::invalid(format!("{} is outside the repository", path.display())))?;
Ok(rel.components().map(|c| c.as_os_str().to_string_lossy()).collect::<Vec<_>>().join("/"))
}
/// Puts `change` back as it was when the turn `start` began.
pub(crate) fn restore_turn(cwd: &Path, start: &TurnStart, dir: &Path, change: &AgentChange) -> IdeResult<()> {
let repo = repo_at(cwd)?;
put(&change.path.0, at_turn_start(&repo, &change.rel_path, start, dir)?)
}
pub(crate) fn file_at(cwd: &Path, path: &Path, rev: &str) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
@@ -1001,67 +815,6 @@ mod tests {
assert!(!created.path.exists());
}
#[test]
fn a_turn_copies_only_what_changed_since_the_last_one() {
let tmp = tempfile::tempdir().unwrap();
let repo = tmp.path().join("repo");
std::fs::create_dir(&repo).unwrap();
git(&repo, &["init", "-q", "-b", "main"]);
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
git(&repo, &["add", "."]);
git(&repo, &["commit", "-q", "-m", "init"]);
let dir = tmp.path().join("turn");
let set = |names: &[&str]| names.iter().map(|n| (*n).to_owned()).collect::<BTreeSet<_>>();
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
std::fs::write(repo.join("b.txt"), "b\n").unwrap();
let first = start_turn(&repo, &dir, None).unwrap();
assert_eq!(first.saved, set(&["a.txt", "b.txt"]));
// A copy made again would replace this mark.
std::fs::write(dir.join(saved_name("b.txt")), "kept\n").unwrap();
std::thread::sleep(std::time::Duration::from_millis(10));
std::fs::write(repo.join("a.txt"), "turn two\n").unwrap();
let second = start_turn(&repo, &dir, Some(&first)).unwrap();
assert_eq!(second.saved, set(&["a.txt", "b.txt"]));
assert_eq!(saved_copy(&dir, "a.txt").as_deref(), Some(&b"turn two\n"[..]));
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"kept\n"[..]));
// Back as committed: nothing to keep a copy of.
git(&repo, &["checkout", "--", "a.txt"]);
let third = start_turn(&repo, &dir, Some(&second)).unwrap();
assert_eq!(third.saved, set(&["b.txt"]));
assert_eq!(saved_copy(&dir, "a.txt"), None);
// Without a record of the last turn (a task from before), every copy is made afresh.
let fresh = start_turn(&repo, &dir, None).unwrap();
assert_eq!(fresh.saved, set(&["b.txt"]));
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"b\n"[..]));
}
#[cfg(unix)]
#[test]
fn a_turns_start_is_found_through_another_spelling_of_the_checkout() {
let tmp = tempfile::tempdir().unwrap();
let repo = dunce::canonicalize(tmp.path()).unwrap().join("repo");
std::fs::create_dir(&repo).unwrap();
git(&repo, &["init", "-q", "-b", "main"]);
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
git(&repo, &["add", "."]);
git(&repo, &["commit", "-q", "-m", "init"]);
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
let dir = tmp.path().join("turn");
let start = start_turn(&repo, &dir, None).unwrap();
std::fs::write(repo.join("a.txt"), "turn 2\n").unwrap();
std::fs::write(repo.join("new.txt"), "new\n").unwrap();
let link = tmp.path().join("link");
std::os::unix::fs::symlink(&repo, &link).unwrap();
for at in [&repo, &link] {
assert_eq!(turn_text(&repo, &at.join("a.txt"), &start, &dir).unwrap().as_deref(), Some("turn 1\n"));
assert_eq!(turn_text(&repo, &at.join("new.txt"), &start, &dir).unwrap(), None);
}
assert!(turn_text(&repo, &tmp.path().join("elsewhere.txt"), &start, &dir).is_err());
}
#[test]
fn commits_since_the_base_are_listed_with_their_files() {
let tmp = tempfile::tempdir().unwrap();
+3 -20
Переглянути файл
@@ -182,7 +182,7 @@ fn collect(
}
/// Scans every input, storing project inputs relative to the project.
pub(super) fn scan_all(
fn scan_all(
root: &Path,
inputs: Vec<PathBuf>,
cancel: &CancellationToken,
@@ -210,7 +210,7 @@ pub fn launch_fingerprint(
if projects.is_empty() {
return Ok(None);
}
let plan = launch_plan(root, model, module, test, BuildKind::Build, cancel)?;
let plan = launch_plan(root, model, module, test, BuildKind::Build)?;
let Some(collected) = collect(root, &projects, &plan, local_repo)? else { return Ok(None) };
let Collected { inputs, environment, steps, inherited_hash } = collected;
let parameters = serde_json::to_string(&(root, module, test, steps, environment, inherited_hash, projects))
@@ -229,7 +229,7 @@ pub fn menu_fingerprint(
file: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<Option<LaunchFingerprint>> {
let plan = plan(root, model, BuildKind::Build, file, None, None, cancel)?;
let plan = plan(root, model, BuildKind::Build, file, None)?;
if plan.system != BuildSystem::Maven {
return Ok(None);
}
@@ -264,23 +264,6 @@ pub fn menu_fingerprint(
Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
}
/// Input fingerprint of one Maven module's menu build (#4078): its POM chain,
/// source and resource trees plus the launcher settings that shape the build.
/// `None` disables the module-scoped reuse (unresolved custom roots).
/// All filesystem work belongs on the caller's blocking thread.
pub(super) fn module_fingerprint(
root: &Path,
project: &maven::MavenProject,
cancel: &CancellationToken,
) -> IdeResult<Option<LaunchFingerprint>> {
let projects = [project];
let Some(inputs) = maven::launch_inputs(root, &projects, None) else { return Ok(None) };
let parameters =
serde_json::to_string(&("module-build", &project.dir, &project.command, &project.options, &project.env))
.map_err(|e| IdeError::internal(e.to_string()))?;
Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
}
impl LaunchFingerprint {
/// Folders (relative to the project) of the Maven projects whose POM is an input.
pub(super) fn project_dirs(&self) -> impl Iterator<Item = &Path> {
+43 -189
Переглянути файл
@@ -5,7 +5,6 @@
mod fingerprint;
mod launch_resources;
mod modules;
mod parse;
mod single;
mod structure;
@@ -13,7 +12,6 @@ mod up_to_date;
pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
pub use launch_resources::process_launch_resources;
pub use modules::record_module_build;
pub use single::{
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
single_file_target,
@@ -222,16 +220,12 @@ fn ancestors_within<'a>(root: &'a Path, file: &'a Path) -> impl Iterator<Item =
/// The build of `root`, or of the module containing `file` (Build Module / Recompile).
/// `cmake`: the CMake profiles of the settings (the first one is built), if any.
/// `cache` enables the module-scoped Maven narrowing of `Build` project builds;
/// `None` plans every build exactly as before.
pub fn plan(
root: &Path,
model: &BuildModel,
kind: BuildKind,
file: Option<&Path>,
cmake: Option<&[CMakeProfile]>,
cache: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<BuildPlan> {
let project_name = root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned());
let module_dir = match file {
@@ -268,7 +262,7 @@ pub fn plan(
None => project_name,
};
let steps = match system {
BuildSystem::Maven => maven_steps(root, model, kind, module_dir.as_deref(), cache, cancel)?,
BuildSystem::Maven => maven_steps(root, model, kind, module_dir.as_deref())?,
BuildSystem::Gradle => gradle_steps(root, model, kind, module_dir.as_deref())?,
BuildSystem::Cargo => cargo_steps(&dir, kind),
// Go builds the file's package (a module holds many).
@@ -287,8 +281,6 @@ pub(super) fn maven_steps(
model: &BuildModel,
kind: BuildKind,
module: Option<&Path>,
cache: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<Vec<BuildStep>> {
let fallback;
let m = match &model.maven {
@@ -328,15 +320,7 @@ pub(super) fn maven_steps(
s.env = p.env.clone();
s
};
let Some(module) = module else {
if kind == BuildKind::Build
&& let Some(cache) = cache
&& let Some(steps) = modules::narrowed_maven_steps(cache, root, m, &step, cancel)?
{
return Ok(steps);
}
return Ok(tops.iter().map(|p| step(p, &[])).collect());
};
let Some(module) = module else { return Ok(tops.iter().map(|p| step(p, &[])).collect()) };
// The reactor root containing the module builds it with what it depends on (`-pl … -am`).
let rel = rel_str(root, module);
if !m.projects.iter().any(|p| p.dir == rel) {
@@ -552,9 +536,7 @@ impl PathMap {
let abs = if p.is_absolute() {
p.to_path_buf()
} else {
// rustc prints workspace members' files relative to the workspace root, above
// the member's manifest directory (`base`) when a member is built on its own.
let in_base = base.and_then(|b| Path::new(b).ancestors().map(|a| a.join(p)).find(|c| c.exists()));
let in_base = base.map(|b| Path::new(b).join(p)).filter(|c| c.exists());
in_base.unwrap_or_else(|| cwd.join(p))
};
let abs = normalize(&abs);
@@ -731,7 +713,7 @@ pub fn run(
}
}
};
let out = process::run_bounded(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let parsed = parser.feed(line);
match parsed.console {
Some(text) if text.is_empty() => {}
@@ -773,7 +755,7 @@ pub fn run(
if !out.success {
success = false;
if !messages.iter().any(|m| m.severity == Severity::Error) {
let summary = crate::sync::error_summary(&out);
let summary = crate::sync::error_summary(&out.text);
let text = if summary.is_empty() { last_error_line.clone() } else { summary };
let m = BuildMessage { severity: Severity::Error, text, path: None, range: None, code: None };
on_event(BuildEvent::Message { message: m.clone() });
@@ -897,15 +879,8 @@ pub fn launch_has_non_java_sources(root: &Path, model: &BuildModel, module: &Pat
has_non_java_sources(module)
}
fn launch_plan(
root: &Path,
model: &BuildModel,
module: &Path,
test: bool,
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<BuildPlan> {
let mut plan = plan(root, model, kind, Some(module), None, None, cancel)?;
fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool, kind: BuildKind) -> IdeResult<BuildPlan> {
let mut plan = plan(root, model, kind, Some(module), None)?;
if plan.system == BuildSystem::Maven && !test {
for step in &mut plan.steps {
if let Some(goal) = step.args.last_mut() {
@@ -932,7 +907,7 @@ pub fn build_for_launch(
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<LaunchBuild> {
let plan = launch_plan(root, model, module, test, kind, cancel)?;
let plan = launch_plan(root, model, module, test, kind)?;
let result = run(root, &plan, cancel, &|_| {})?;
let failure = if !result.success {
let errors: Vec<String> = result
@@ -997,9 +972,7 @@ mod tests {
write(root, "../external/main.go", "package main\nimport \"example.com/lib\"\nfunc main(){_ = lib.Value()}\n");
// std canonicalization also exercises verbatim paths on Windows.
for root in [root.to_path_buf(), std::fs::canonicalize(root).unwrap()] {
let plan =
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new())
.unwrap();
let plan = plan(&root, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
for step in plan.steps {
let result = std::process::Command::new(&go)
.args(&step.args)
@@ -1025,7 +998,7 @@ mod tests {
let canonical = std::fs::canonicalize(&root).unwrap();
for root in [&root, &canonical, &canonical.join("..").join("workspace")] {
for kind in [BuildKind::Build, BuildKind::Rebuild, BuildKind::Artifacts] {
let p = plan(root, &BuildModel::default(), kind, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(root, &BuildModel::default(), kind, None, None).unwrap();
assert_eq!(p.system, BuildSystem::Go);
assert_eq!(p.steps.len(), 3);
for (step, module) in p.steps.iter().zip(["api", "lib with spaces", "../shared"]) {
@@ -1040,30 +1013,20 @@ mod tests {
}
}
}
let member = plan(
&root,
&BuildModel::default(),
BuildKind::Build,
Some(&root.join("api/pkg/a.go")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
let member =
plan(&root, &BuildModel::default(), BuildKind::Build, Some(&root.join("api/pkg/a.go")), None).unwrap();
assert_eq!(member.steps.len(), 1);
assert_eq!(member.steps[0].cwd, root.join("api"));
assert_eq!(member.steps[0].args, ["build", "./pkg/..."]);
write(&root, "go.work", "use ./missing\n");
assert!(
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new())
plan(&root, &BuildModel::default(), BuildKind::Build, None, None)
.unwrap_err()
.to_string()
.contains("go.mod")
);
write(&root, "go.work", "go 1.22\n");
assert!(
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).is_err()
);
assert!(plan(&root, &BuildModel::default(), BuildKind::Build, None, None).is_err());
}
#[test]
@@ -1084,21 +1047,11 @@ mod tests {
let mut model = crate::load_linked(root, &root.join("cache"), None, &Default::default(), &settings);
model.gradle[0].env.insert("JAVA_HOME".into(), "/jdk-a".into());
model.gradle[1].env.insert("JAVA_HOME".into(), "/jdk-b".into());
let all =
super::plan(root, &model, super::BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
let all = super::plan(root, &model, super::BuildKind::Build, None, None).unwrap();
assert_eq!(all.steps.len(), 2);
assert_eq!(all.steps[0].cwd, root.join("a"));
assert_eq!(all.steps[1].cwd, root.join("b"));
let module = super::plan(
root,
&model,
super::BuildKind::Rebuild,
Some(&root.join("b/app")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
let module = super::plan(root, &model, super::BuildKind::Rebuild, Some(&root.join("b/app")), None).unwrap();
assert_eq!(module.steps.len(), 1);
assert_eq!(module.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
assert_eq!(module.steps[0].cwd, root.join("b"));
@@ -1111,31 +1064,11 @@ mod tests {
let mut nested = model.gradle[1].projects[1].clone();
nested.path = ":b:app".into();
model.gradle[0].projects.push(nested);
let nested = super::plan(
root,
&model,
super::BuildKind::Build,
Some(&root.join("b/app")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
let nested = super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).unwrap();
assert_eq!(nested.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
assert_eq!(nested.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
model.gradle.clear();
assert!(
super::plan(
root,
&model,
super::BuildKind::Build,
Some(&root.join("b/app")),
None,
None,
&CancellationToken::new()
)
.is_err()
);
assert!(super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).is_err());
}
#[test]
@@ -1157,24 +1090,18 @@ mod tests {
};
let mut model = crate::load_linked(&root, &base.join("cache"), None, &Default::default(), &settings);
model.gradle[0].env.insert("JAVA_HOME".into(), "/external-jdk".into());
let all =
super::plan(&root, &model, super::BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
let all = super::plan(&root, &model, super::BuildKind::Build, None, None).unwrap();
assert_eq!(all.steps[0].cwd, external);
// Linked roots are saved with forward slashes, so on Windows the program mixes separators.
assert_eq!(std::path::Path::new(&all.steps[0].program), external.join(wrapper));
let module =
super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None, None, &CancellationToken::new())
.unwrap();
let module = super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None).unwrap();
assert_eq!(module.steps[0].cwd, external);
assert_eq!(module.steps[0].env["JAVA_HOME"], "/external-jdk");
assert_eq!(module.steps[0].args, ["--console=plain", ":app:clean", ":app:classes", ":app:testClasses"]);
let other = base.join("unlinked");
std::fs::create_dir(&other).unwrap();
std::fs::write(other.join("build.gradle"), "").unwrap();
assert!(
super::plan(&root, &model, super::BuildKind::Build, Some(&other), None, None, &CancellationToken::new())
.is_err()
);
assert!(super::plan(&root, &model, super::BuildKind::Build, Some(&other), None).is_err());
}
use super::*;
@@ -1215,7 +1142,7 @@ mod tests {
write(&root, "pom.xml", "<project><artifactId>demo</artifactId></project>");
let model = crate::load(&root, &tmp.path().join("cache"), None);
for (kind, expected) in [(BuildKind::Build, true), (BuildKind::Rebuild, true), (BuildKind::Artifacts, false)] {
let plan = plan(&root, &model, kind, None, None, None, &CancellationToken::new()).unwrap();
let plan = plan(&root, &model, kind, None, None).unwrap();
assert_eq!(
plan.steps[0].args.iter().any(|arg| arg == "-Djacoco.skip=true"),
expected,
@@ -1236,7 +1163,7 @@ mod tests {
write(&root, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
write(&root, "core/src/main/java/A.java", "class A {}");
let model = crate::load(&root, &tmp.path().join("cache"), None);
let p = plan(&root, &model, BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(&root, &model, BuildKind::Build, None, None).unwrap();
assert_eq!(p.system, BuildSystem::Maven);
assert_eq!(p.title, "demo");
assert_eq!(p.steps.len(), 1);
@@ -1244,16 +1171,7 @@ mod tests {
p.steps[0].args,
["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG, "-Djacoco.skip=true", "test-compile"]
);
let p = plan(
&root,
&model,
BuildKind::Rebuild,
Some(&root.join("core/src/main/java/A.java")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
let p = plan(&root, &model, BuildKind::Rebuild, Some(&root.join("core/src/main/java/A.java")), None).unwrap();
assert_eq!(
p.steps[0].args,
[
@@ -1275,36 +1193,24 @@ mod tests {
write(&g, "settings.gradle", "include 'app'");
write(&g, "app/build.gradle", "apply plugin: 'java'");
let model = crate::load(&g, &tmp.path().join("cache2"), None);
let p =
plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java")), None, None, &CancellationToken::new())
.unwrap();
let p = plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java")), None).unwrap();
assert_eq!(p.system, BuildSystem::Gradle);
assert_eq!(p.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
assert_eq!(
plan(&g, &model, BuildKind::Artifacts, None, None, None, &CancellationToken::new()).unwrap().steps[0].args,
plan(&g, &model, BuildKind::Artifacts, None, None).unwrap().steps[0].args,
["--console=plain", "assemble"]
);
let c = tmp.path().join("c");
write(&c, "Cargo.toml", "[package]\nname='c'");
let p =
plan(&c, &BuildModel::default(), BuildKind::Rebuild, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(&c, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
assert_eq!(p.system, BuildSystem::Cargo);
assert_eq!(p.steps.len(), 2);
assert_eq!(p.steps[0].args[0], "clean");
let go = tmp.path().join("go");
write(&go, "go.mod", "module x");
let p = plan(
&go,
&BuildModel::default(),
BuildKind::Build,
Some(&go.join("pkg/a/a.go")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
let p = plan(&go, &BuildModel::default(), BuildKind::Build, Some(&go.join("pkg/a/a.go")), None).unwrap();
assert_eq!(p.steps[0].args, ["build", "./pkg/a/..."]);
assert_eq!(p.steps[0].cwd, go);
@@ -1312,11 +1218,9 @@ mod tests {
write(&ts, "package.json", r#"{"scripts":{"build":"vite build"}}"#);
write(&ts, "tsconfig.json", "{}");
write(&ts, "pnpm-lock.yaml", "");
let p =
plan(&ts, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(&ts, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
assert_eq!(p.steps[0].args, ["--noEmit", "--pretty", "false", "-p", "."]);
let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None, None, &CancellationToken::new())
.unwrap();
let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
assert_eq!(
(p.steps[0].program.as_str(), p.steps[0].args.as_slice()),
("pnpm", &["run".to_owned(), "build".to_owned()][..])
@@ -1329,32 +1233,21 @@ mod tests {
write(&net, "src/Api/Api.csproj", "<Project/>");
write(&net, "src/Api/package.json", "{}");
write(&net, "src/Api/Program.cs", "");
let p =
plan(&net, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(&net, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
assert_eq!(p.system, BuildSystem::Dotnet);
assert_eq!(p.steps[0].args, ["build", "App.sln", "-nologo", "-clp:NoSummary"]);
assert_eq!(p.steps[0].env["MSBUILDTERMINALLOGGER"], "off");
let p = plan(
&net,
&BuildModel::default(),
BuildKind::Rebuild,
Some(&net.join("src/Api/Program.cs")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
let p = plan(&net, &BuildModel::default(), BuildKind::Rebuild, Some(&net.join("src/Api/Program.cs")), None)
.unwrap();
assert_eq!(p.steps[0].args, ["build", "Api.csproj", "-nologo", "-clp:NoSummary", "--no-incremental"]);
assert_eq!(p.steps[0].cwd, net.join("src/Api"));
let p = plan(&net, &BuildModel::default(), BuildKind::Artifacts, None, None, None, &CancellationToken::new())
.unwrap();
let p = plan(&net, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
assert_eq!(p.steps[0].args[0], "publish");
let cm = tmp.path().join("cm");
write(&cm, "CMakeLists.txt", "project(app)");
let args = |p: &BuildPlan| p.steps.iter().map(|s| s.args.join(" ")).collect::<Vec<_>>();
let p =
plan(&cm, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
assert_eq!(p.system, BuildSystem::CMake);
assert_eq!(
args(&p),
@@ -1365,8 +1258,7 @@ mod tests {
"an unconfigured project is configured first"
);
write(&cm, "cmake-build-release/CMakeCache.txt", "");
let p =
plan(&cm, &BuildModel::default(), BuildKind::Rebuild, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(&cm, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
assert_eq!(
args(&p),
["--build cmake-build-release --config Debug --clean-first"],
@@ -1378,34 +1270,17 @@ mod tests {
build_args: vec!["-j".into(), "8".into()],
..CMakeProfile::default()
};
let p = plan(
&cm,
&BuildModel::default(),
BuildKind::Build,
None,
Some(std::slice::from_ref(&profile)),
None,
&CancellationToken::new(),
)
.unwrap();
let p =
plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(std::slice::from_ref(&profile))).unwrap();
assert_eq!(args(&p), ["--build cmake-build-release --config Release -j 8"]);
let p = plan(
&cm,
&BuildModel::default(),
BuildKind::Build,
None,
Some(&[CMakeProfile::default()]),
None,
&CancellationToken::new(),
)
.unwrap();
let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(&[CMakeProfile::default()])).unwrap();
assert_eq!(p.steps[0].args[..4], ["-S", ".", "-B", "cmake-build-debug"]);
let siblings = tmp.path().join("siblings");
write(&siblings, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
write(&siblings, "system/pom.xml", "<project><artifactId>system</artifactId></project>");
let model = crate::load(&siblings, &tmp.path().join("cache3"), None);
let p = plan(&siblings, &model, BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
let p = plan(&siblings, &model, BuildKind::Build, None, None).unwrap();
assert_eq!(p.system, BuildSystem::Maven);
assert_eq!(
p.steps.iter().map(|s| s.cwd.clone()).collect::<Vec<_>>(),
@@ -1414,9 +1289,7 @@ mod tests {
let none = tmp.path().join("none");
std::fs::create_dir_all(&none).unwrap();
assert!(
plan(&none, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).is_err()
);
assert!(plan(&none, &BuildModel::default(), BuildKind::Build, None, None).is_err());
}
#[test]
@@ -1430,22 +1303,6 @@ mod tests {
assert_eq!(identifier_len("x é_1 c", 2), 3);
}
#[test]
fn resolves_a_member_build_s_workspace_relative_paths() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().to_path_buf();
write(&root, "client/src/main.rs", "fn main() {}\n");
write(&root, "client/src/lib.rs", "\n");
write(&root, "src/lib.rs", "\n");
let map = PathMap { root: root.clone(), canonical: None };
let member = root.join("client");
let base = member.to_str();
// Build Module runs in the member; rustc names its files from the workspace root.
assert_eq!(map.resolve("client/src/main.rs", &member, base), root.join("client/src/main.rs"));
// A crate built from its own directory names them from there.
assert_eq!(map.resolve("src/lib.rs", &member, base), member.join("src/lib.rs"));
}
// Uses Unix absolute paths for the canonical root.
#[cfg(unix)]
#[test]
@@ -1615,8 +1472,7 @@ mod tests {
let model = reactor_model();
for (test, goal) in [(false, "compile"), (true, "test-compile")] {
// A normal launch is incremental: no `clean` (IDEA's Make, not Rebuild).
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build, &CancellationToken::new())
.unwrap();
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build).unwrap();
let step = &plan.steps[0];
assert_eq!(step.cwd, root);
assert_eq!(step.program, "mvnw");
@@ -1637,9 +1493,7 @@ mod tests {
]
);
// Rebuild cleans first, as IDEA's Rebuild does.
let plan =
launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild, &CancellationToken::new())
.unwrap();
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild).unwrap();
assert_eq!(
plan.steps[0].args,
[
-408
Переглянути файл
@@ -1,408 +0,0 @@
//! Module-scoped Maven menu builds (`Build Project` on a multi-module reactor, #4078).
//!
//! A project build used to run every linked reactor from end to end; only the
//! all-or-nothing up-to-date check could skip it, so one edited file anywhere
//! paid a full reactor build. This module narrows the scope: per-module input
//! fingerprints recorded after the last successful build tell which modules'
//! sources, resources, POM chain or outputs changed, the module dependency graph
//! spreads that to the modules depending on them, and the reactor runs
//! `mvn -pl <modules> -am` over just that set. Maven still decides what
//! recompiles inside the selected modules; `-am` keeps the upstream modules a
//! changed module was built against. Reactors without a usable record, and any
//! analysis that cannot resolve its inputs, build everything as before.
use super::up_to_date::restamp;
use super::*;
use std::fs;
/// The per-module input fingerprints of one reactor's last successful build.
#[derive(serde::Serialize, serde::Deserialize)]
struct ReactorRecord {
/// Module directory (project-relative, `/`-separated) → its record.
modules: BTreeMap<String, ModuleRecord>,
}
#[derive(serde::Serialize, serde::Deserialize)]
struct ModuleRecord {
fingerprint: LaunchFingerprint,
/// Output folders of the module that existed after the build, relative to the
/// project. Deleting one outside the IDE (`mvn clean` in a terminal) leaves every
/// input unchanged, so the module is rebuilt only while they are gone.
outputs: Vec<PathBuf>,
}
fn record_path(cache: &Path, top_dir: &str) -> PathBuf {
let base = cache.join("menu-build").join("modules");
if top_dir.is_empty() { base.join("root.json") } else { base.join(format!("{top_dir}.json")) }
}
fn load_record(cache: &Path, top_dir: &str) -> Option<ReactorRecord> {
let bytes = fs::read(record_path(cache, top_dir)).ok()?;
serde_json::from_slice(&bytes).ok()
}
/// Projects of `reactor` that (transitively) depend on one of `changed`, through
/// dependencies whose version matches the provider. The reverse of the launch
/// upstream walk: a changed module's new classes force its consumers to recompile,
/// `test`-scoped ones included, since the project build compiles every module's tests.
fn affected_projects(reactor: &[&maven::MavenProject], changed: &HashSet<String>) -> HashSet<String> {
let mut affected = changed.clone();
let mut pending: Vec<&str> = changed.iter().map(String::as_str).collect();
while let Some(dir) = pending.pop() {
let Some(upstream) = reactor.iter().find(|p| p.dir == dir) else { continue };
for consumer in reactor {
if affected.contains(&consumer.dir) {
continue;
}
let depends = consumer.dependencies.iter().any(|d| {
d.resolved()
&& upstream.group_id == d.group_id
&& upstream.artifact_id == d.artifact_id
&& d.version.as_ref().is_none_or(|v| *v == upstream.version)
});
if depends {
affected.insert(consumer.dir.clone());
pending.push(consumer.dir.as_str());
}
}
}
affected
}
/// `-pl` entries of the affected modules, relative to the reactor root the step
/// runs in, sorted so the command line does not depend on the model's project
/// order (Maven reorders the selection into its own reactor order anyway).
fn selection(reactor: &[&maven::MavenProject], top_dir: &str, affected: &HashSet<String>) -> String {
let mut entries: Vec<String> = reactor
.iter()
.filter(|p| affected.contains(&p.dir))
.map(|p| {
Path::new(&p.dir).strip_prefix(top_dir).unwrap_or(Path::new(&p.dir)).to_string_lossy().replace('\\', "/")
})
.collect();
entries.sort();
entries.join(",")
}
/// Narrowed `Build Project` steps: per reactor, one full step when the reactor
/// or most of it is affected, one `-pl <modules> -am` step for the affected
/// subset, or no step at all when nothing changed since the last successful
/// build. `None` = some module's inputs cannot be fingerprinted, so the caller
/// falls back to the unscoped build. The `step` closure builds a reactor step
/// with the caller's goals and options.
pub(super) fn narrowed_maven_steps(
cache: &Path,
root: &Path,
m: &maven::MavenModel,
step: &impl Fn(&maven::MavenProject, &[String]) -> BuildStep,
cancel: &CancellationToken,
) -> IdeResult<Option<Vec<BuildStep>>> {
let mut steps = Vec::new();
for top in m.projects.iter().filter(|p| !p.aggregated) {
let Some(record) = load_record(cache, &top.dir) else {
steps.push(step(top, &[]));
continue;
};
let reactor = reactor_projects(m, top);
let mut changed = HashSet::new();
let mut lying: Vec<PathBuf> = Vec::new();
for project in &reactor {
let Some(current) = fingerprint::module_fingerprint(root, project, cancel)? else {
return Ok(None);
};
let Some(recorded) = record.modules.get(&project.dir) else {
changed.insert(project.dir.clone());
continue;
};
if recorded.fingerprint != current {
changed.insert(project.dir.clone());
lying.extend(recorded.fingerprint.mtime_preserved_edits(&current));
}
if !recorded.outputs.iter().all(|out| root.join(out).is_dir()) {
changed.insert(project.dir.clone());
}
}
if changed.is_empty() {
continue;
}
let affected = affected_projects(&reactor, &changed);
restamp(root, &lying);
if affected.len() >= reactor.len() || affected.contains(&top.dir) {
steps.push(step(top, &[]));
} else {
let pl = selection(&reactor, &top.dir, &affected);
steps.push(step(top, &["-pl".into(), pl, "-am".into()]));
}
}
Ok(Some(steps))
}
/// Records the per-module inputs of every linked reactor as the baseline of the
/// next narrowed build. Failures are swallowed: a missing record only costs one
/// unscoped Maven run. Called after a successful project build.
pub fn record_module_build(cache: &Path, root: &Path, model: &BuildModel, cancel: &CancellationToken) {
let Some(m) = &model.maven else { return };
for top in m.projects.iter().filter(|p| !p.aggregated) {
let mut modules = BTreeMap::new();
for project in reactor_projects(m, top) {
let Ok(Some(fingerprint)) = fingerprint::module_fingerprint(root, project, cancel) else { continue };
let outputs = ["target/classes", "target/test-classes"]
.iter()
.map(|out| Path::new(&project.dir).join(out))
.filter(|rel| root.join(rel).is_dir())
.collect();
modules.insert(project.dir.clone(), ModuleRecord { fingerprint, outputs });
}
let path = record_path(cache, &top.dir);
if path.parent().is_some_and(|p| fs::create_dir_all(p).is_err()) {
continue;
}
let Ok(bytes) = serde_json::to_vec(&ReactorRecord { modules }) else { continue };
let _ = fs::write(&path, bytes);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn write(root: &Path, rel: &str, value: &str) {
let path = root.join(rel);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, value).unwrap();
}
/// `other` ← nothing, `app` ← `mid` ← `lib`, all under one reactor root.
fn fixture(root: &Path) -> BuildModel {
write(
root,
"pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>root</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>mid</module><module>app</module><module>other</module></modules></project>"#,
);
for (dir, class, deps) in [
("lib", "L", ""),
(
"mid",
"M",
"<dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>",
),
(
"app",
"A",
"<dependencies><dependency><groupId>t</groupId><artifactId>mid</artifactId><version>1</version></dependency></dependencies>",
),
("other", "O", ""),
] {
write(
root,
&format!("{dir}/pom.xml"),
&format!(
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>{dir}</artifactId>{deps}</project>"#
),
);
write(
root,
&format!("{dir}/src/main/java/t/{class}.java"),
&format!("package t; public class {class} {{}}"),
);
}
BuildModel { maven: Some(maven::load(root)), ..Default::default() }
}
fn steps(cache: &Path, root: &Path, model: &BuildModel) -> Option<Vec<BuildStep>> {
narrowed_maven_steps(
cache,
root,
model.maven.as_ref().unwrap(),
&|p, extra| {
let mut s = BuildStep::new(&p.command, &["-B"], &subdir(root, &p.dir), Format::Maven);
s.args.extend(extra.iter().cloned());
s.args.push("test-compile".into());
s
},
&CancellationToken::new(),
)
.unwrap()
}
fn pl_arg(step: &BuildStep) -> String {
let i = step.args.iter().position(|a| a == "-pl").unwrap();
step.args[i + 1].clone()
}
#[test]
fn changed_module_selects_itself_and_transitive_dependents() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, "lib/src/main/java/t/L.java", "package t; public class L { int x; }");
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(steps.len(), 1);
assert_eq!(pl_arg(&steps[0]), "app,lib,mid");
assert!(steps[0].args.contains(&"-am".into()));
}
#[test]
fn unchanged_reactor_runs_nothing() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
assert!(steps(&cache, root, &model).unwrap().is_empty());
}
#[test]
fn missing_or_corrupt_record_builds_everything() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
assert_eq!(steps(&cache, root, &model).unwrap().len(), 1);
record_module_build(&cache, root, &model, &CancellationToken::new());
fs::create_dir_all(cache.join("menu-build").join("modules")).unwrap();
fs::write(cache.join("menu-build").join("modules").join("root.json"), b"{not json").unwrap();
assert_eq!(steps(&cache, root, &model).unwrap().len(), 1);
}
#[test]
fn deleted_output_rebuilds_the_module_without_spreading() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
for out in ["mid/target/classes/t", "other/target/classes"] {
fs::create_dir_all(root.join(out)).unwrap();
}
record_module_build(&cache, root, &model, &CancellationToken::new());
fs::remove_dir_all(root.join("mid/target")).unwrap();
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(pl_arg(&steps[0]), "app,mid");
}
#[test]
fn mtime_preserved_edit_is_restamped_before_the_build() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
let rel = "lib/src/main/java/t/L.java";
write(root, rel, "package t; public class L { int x; }");
let mtime = fs::metadata(root.join(rel)).unwrap().modified().unwrap();
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, rel, "package t; public class L { int z; }");
fs::File::options().write(true).open(root.join(rel)).unwrap().set_modified(mtime).unwrap();
assert!(!steps(&cache, root, &model).unwrap().is_empty());
assert!(fs::metadata(root.join(rel)).unwrap().modified().unwrap() > mtime);
}
#[test]
fn test_scoped_consumers_are_rebuilt_and_version_mismatch_does_not_spread() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
write(
root,
"pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>root</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>tester</module><module>v2</module></modules></project>"#,
);
write(
root,
"lib/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>lib</artifactId></project>"#,
);
write(
root,
"tester/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>tester</artifactId><dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version><scope>test</scope></dependency></dependencies></project>"#,
);
write(
root,
"v2/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>v2</artifactId><dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>2</version></dependency></dependencies></project>"#,
);
for module in ["lib", "tester", "v2"] {
write(root, &format!("{module}/src/main/java/t/{module}.java"), "package t;");
}
let model = BuildModel { maven: Some(maven::load(root)), ..Default::default() };
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, "lib/src/main/java/t/L.java", "package t; public class L {}");
let steps = steps(&cache, root, &model).unwrap();
// `tester`'s tests compile against `lib`.
assert_eq!(pl_arg(&steps[0]), "lib,tester");
}
#[test]
fn root_pom_change_selects_the_whole_reactor() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(
root,
"pom.xml",
fs::read_to_string(root.join("pom.xml")).unwrap().replace("<modules>", "<!-- x --><modules>").as_str(),
);
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(steps.len(), 1);
assert!(!steps[0].args.contains(&"-pl".into()));
}
/// A folder of two sibling reactors: `chain` (lib ← mid ← app) and `solo`.
fn two_reactors(root: &Path) -> BuildModel {
write(
root,
"chain/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>chain</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>mid</module><module>app</module></modules></project>"#,
);
for (dir, class, deps) in [
("lib", "L", ""),
(
"mid",
"M",
"<dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>",
),
(
"app",
"A",
"<dependencies><dependency><groupId>t</groupId><artifactId>mid</artifactId><version>1</version></dependency></dependencies>",
),
] {
write(
root,
&format!("chain/{dir}/pom.xml"),
&format!(
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>chain</artifactId><version>1</version></parent><artifactId>{dir}</artifactId>{deps}</project>"#
),
);
write(
root,
&format!("chain/{dir}/src/main/java/t/{class}.java"),
&format!("package t; public class {class} {{}}"),
);
}
write(
root,
"solo/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>solo</artifactId><version>1</version></project>"#,
);
write(root, "solo/src/main/java/t/S.java", "package t;");
BuildModel { maven: Some(maven::load(root)), ..Default::default() }
}
#[test]
fn unrelated_reactors_are_judged_separately() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = two_reactors(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, "solo/src/main/java/t/S.java", "package t; public class S {}");
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(steps.len(), 1);
assert_eq!(steps[0].cwd, subdir(root, "solo"));
}
}
+1 -1
Переглянути файл
@@ -41,7 +41,7 @@ fn record_path(cache: &Path, root: &Path, file: Option<&Path>) -> PathBuf {
/// Re-stamps files whose content changed without advancing mtime (git
/// checkout, external sync): timestamp-incremental Maven would otherwise skip
/// them as "unchanged" and the rebuild would compile nothing.
pub(super) fn restamp(root: &Path, edits: &[PathBuf]) {
fn restamp(root: &Path, edits: &[PathBuf]) {
let now = std::time::SystemTime::now();
for rel in edits {
let path = root.join(rel);
-1
Переглянути файл
@@ -30,7 +30,6 @@ def processedResources = { Project p, s ->
def describe = { Project p ->
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
if (p.gradle.parent != null) m.build = identity(p.rootProject)
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
// Gradle 4.x has it as a convention property, not an extension.
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
if (sets != null) {
-19
Переглянути файл
@@ -41,10 +41,6 @@ pub struct GradleProject {
/// Project-relative build script, if any.
pub build_file: Option<String>,
pub tasks: Vec<GradleTask>,
/// Configurations Gradle can resolve, or null before Gradle reports the project.
#[serde(default)]
#[specta(optional)]
pub resolvable_configurations: Option<Vec<String>>,
/// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
/// `:buildSrc`); null for the opened build.
#[serde(default)]
@@ -305,7 +301,6 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
path,
name,
tasks,
resolvable_configurations: None,
build: None,
}
}
@@ -322,8 +317,6 @@ pub struct ReportedProject {
pub build_dir: Option<String>,
#[serde(default)]
pub source_sets: Vec<ReportedSourceSet>,
#[serde(default)]
pub resolvable_configurations: Option<Vec<String>>,
/// Toolchain language version, else target compatibility.
#[serde(default)]
pub java: Option<u32>,
@@ -419,7 +412,6 @@ pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &
if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
project.tasks.clear();
}
project.resolvable_configurations = p.resolvable_configurations.clone();
project.build = p.build.clone();
project
})
@@ -1638,11 +1630,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
path: path.into(),
dir: ws.join(d).to_string_lossy().into_owned(),
build: build.map(Into::into),
resolvable_configurations: match path {
":" => Some(vec!["reviewTools".into(), "runtimeClasspath".into()]),
":lib:core" => Some(Vec::new()),
_ => None,
},
..ReportedProject::default()
};
format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
@@ -1671,12 +1658,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
);
let build_src = &model.projects[2];
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
assert_eq!(
model.projects[0].resolvable_configurations,
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
);
assert_eq!(model.projects[1].resolvable_configurations, None);
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
assert!(!model.projects[4].tasks.is_empty());
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
}
+5 -8
Переглянути файл
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
configuration: &str,
cancel: &CancellationToken,
) -> IdeResult<Vec<GradleDependency>> {
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
}
if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
@@ -143,7 +143,7 @@ pub fn gradle_dependencies(
}
let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
let mut args: Vec<String> =
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
if options.offline {
args.push("--offline".into());
}
@@ -156,10 +156,7 @@ pub fn gradle_dependencies(
|_, _| {},
)?;
if !out.success {
return Err(IdeError::unavailable(error_summary(&out)));
}
if let Some(note) = sync::truncation_note(&out) {
return Err(IdeError::unavailable(note));
return Err(IdeError::unavailable(error_summary(&out.text)));
}
Ok(parse_report(&out.text))
}
@@ -340,14 +337,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
&gradle::load(root).unwrap(),
&options,
":app",
"review.tools",
"testRuntimeClasspath",
&CancellationToken::new(),
)
.unwrap();
assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
assert_eq!(
std::fs::read_to_string(root.join("args")).unwrap().trim(),
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
"--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
);
}
}
+5 -5
Переглянути файл
@@ -78,14 +78,14 @@ fn has_kotlin_sources(root: &Path) -> bool {
})
}
fn plan(root: &Path, model: &BuildModel, cancel: &CancellationToken) -> IdeResult<compile::BuildPlan> {
fn plan(root: &Path, model: &BuildModel) -> IdeResult<compile::BuildPlan> {
if model.maven.as_ref().is_none_or(|m| m.projects.is_empty()) {
return Err(IdeError::invalid("Kotlin bridge requires a Maven build root"));
}
Ok(compile::BuildPlan {
system: compile::BuildSystem::Maven,
title: root.file_name().unwrap_or_default().to_string_lossy().into_owned(),
steps: compile::maven_steps(root, model, BuildKind::Build, None, None, cancel)?,
steps: compile::maven_steps(root, model, BuildKind::Build, None)?,
})
}
@@ -99,7 +99,7 @@ pub fn build(
cancel: &CancellationToken,
) -> IdeResult<Outcome> {
std::fs::create_dir_all(generation)?;
let mut plan = plan(root, model, cancel)?;
let mut plan = plan(root, model)?;
let mut manifests = Vec::new();
for (index, step) in plan.steps.iter_mut().enumerate() {
step.args.push("--fail-at-end".into());
@@ -522,7 +522,7 @@ mod tests {
}
std::fs::write(root.join("kotlin/App.kt"), "class App").unwrap();
assert!(has_kotlin(root, &model), "{marker}");
let plan = plan(root, &model, &CancellationToken::new()).unwrap();
let plan = plan(root, &model).unwrap();
assert_eq!(plan.system, compile::BuildSystem::Maven);
assert_eq!(plan.steps.len(), 2);
for (step, name) in plan.steps.iter().zip(["java", "kotlin"]) {
@@ -562,7 +562,7 @@ mod tests {
..Default::default()
};
assert!(has_kotlin(workspace.path(), &model));
assert_eq!(plan(workspace.path(), &model, &CancellationToken::new()).unwrap().steps[0].cwd, external.path());
assert_eq!(plan(workspace.path(), &model).unwrap().steps[0].cwd, external.path());
}
#[test]
-2
Переглянути файл
@@ -13,8 +13,6 @@ pub mod kotlin_bridge;
pub mod maven;
pub mod pom_edit;
mod process;
#[cfg(test)]
mod process_numbers;
pub mod sbt;
mod sync;
pub mod web;
-8
Переглянути файл
@@ -1875,14 +1875,6 @@ pub fn goto_declaration(text: &str, path: &Path, pos: Pos, local_repo: Option<Pa
goto_declaration_in(text, path, pos, local_repo, Vec::new)
}
/// The declaration of the property `name` in the pom at `path`, for files it configures
/// outside the pom itself (a YAML resource's `@name@`): the first `<properties>` entry
/// along the parent chain declaring it, `project.*` built-ins included.
pub fn property_declaration(pom: &Path, name: &str, local_repo: Option<PathBuf>) -> Option<PomGoto> {
let text = xml::read_text(pom)?;
property_target(&text, pom, name, local_repo)
}
/// [`goto_declaration`], where a `<parent>` and a dependency or plugin whose version no
/// management entry provides (or a management entry itself) go to the artifact's own
/// POM: the project module among `modules` with its coordinates, else the local
+19 -337
Переглянути файл
@@ -17,72 +17,10 @@ pub(crate) enum Stream {
Stderr,
}
/// A single line longer than this without a newline is delivered as several lines: the pump
/// buffer stays bounded whatever the child prints (progress bars, minified bundles, binary
/// output), and every byte still arrives.
pub(crate) const MAX_LINE_BYTES: usize = 1024 * 1024;
/// `Output::text` stops growing past this while the pipes keep draining: a chatty build can
/// print far more than is ever parsed back out of the retained copy.
pub(crate) const MAX_TEXT_BYTES: usize = 32 * 1024 * 1024;
pub(crate) struct Output {
pub success: bool,
/// Every line, stdout and stderr interleaved as received, up to [`MAX_TEXT_BYTES`].
/// Every line, stdout and stderr interleaved as received.
pub text: String,
/// More output followed the retained `text`; the lines were still fed to `on_line`.
pub truncated: bool,
}
/// Bounded pump for callers that stream every line and only summarize errors: reads fixed
/// 64 KiB chunks, splits newline-free runs at a UTF-8 char boundary at the line cap, and
/// never grows one line buffer without bound.
fn pump_bounded(stream: Box<dyn Read + Send>, kind: Stream, tx: &mpsc::Sender<(Stream, String)>) {
let mut reader = BufReader::new(stream);
// `terminated`: the buffer ends in the stream's newline. A segment cut from a
// newline-free run at the line cap must keep a trailing `\r` — it is data.
let send = |buf: &mut Vec<u8>, terminated: bool, tx: &mpsc::Sender<(Stream, String)>| {
let line = ide_core::output_encoding::decode_tool_output(buf);
let line = if terminated { line.trim_end_matches(['\n', '\r']).to_owned() } else { line };
buf.clear();
tx.send((kind, line)).is_ok()
};
let mut chunk = vec![0u8; 64 * 1024];
let mut line: Vec<u8> = Vec::with_capacity(256);
'read: loop {
let n = match reader.read(&mut chunk) {
Ok(0) | Err(_) => break,
Ok(n) => n,
};
let mut start = 0;
for (i, &b) in chunk[..n].iter().enumerate() {
if b == b'\n' {
line.extend_from_slice(&chunk[start..=i]);
if !send(&mut line, true, tx) {
break 'read;
}
start = i + 1;
}
}
line.extend_from_slice(&chunk[start..n]);
while line.len() > MAX_LINE_BYTES {
let mut at = MAX_LINE_BYTES;
while at > 0 && line[at] & 0xC0 == 0x80 {
at -= 1;
}
// Malformed input with no boundary at all: split raw and let decoding say so.
if at == 0 {
at = MAX_LINE_BYTES;
}
let rest = line.split_off(at);
if !send(&mut line, false, tx) {
break 'read;
}
line = rest;
}
}
if !line.is_empty() {
send(&mut line, true, tx);
}
}
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
@@ -103,8 +41,7 @@ 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. `Output.text`
/// keeps every line: callers that parse a complete model from it use this.
/// the process group and returns `cancelled` when `cancel` fires.
pub(crate) fn run(
program: &str,
args: &[String],
@@ -116,20 +53,6 @@ pub(crate) fn run(
run_with_env(program, args, cwd, env, false, cancel, on_line)
}
/// Like [`run`], but bounds both the per-line buffer and the retained copy. For callers
/// that stream every line to `on_line` and use `Output.text` only for error summaries:
/// sync/model listings must be kept whole and use [`run`] instead.
pub(crate) fn run_bounded(
program: &str,
args: &[String],
cwd: &Path,
env: &BTreeMap<String, String>,
cancel: &CancellationToken,
on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
run_with_env_capture(program, args, cwd, env, RunOptions { bounded: true, ..Default::default() }, cancel, on_line)
}
pub(crate) fn run_with_env(
program: &str,
args: &[String],
@@ -137,27 +60,8 @@ 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 =
@@ -176,22 +80,17 @@ fn run_with_env_capture(
let (tx, rx) = mpsc::channel::<(Stream, String)>();
let pump = |stream: Box<dyn Read + Send>, kind: Stream, tx: mpsc::Sender<(Stream, String)>| {
std::thread::spawn(move || {
if bounded {
pump_bounded(stream, kind, &tx);
} else {
// Model listings are parsed from Output.text: keep every line whole, however long.
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
}
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
}
}
}
@@ -203,17 +102,7 @@ fn run_with_env_capture(
child.stderr.take().map(|s| pump(Box::new(s), Stream::Stderr, tx.clone())),
];
drop(tx);
// Retained copy of the output: the first half of the cap, then — once output overflows —
// a rolling tail instead of the middle. Error summaries read the end of the output, while
// listings parsed out of a successful run read from the start. The pipes keep draining
// either way: `on_line` still sees every line, so the child never blocks on a full pipe.
let cap = MAX_TEXT_BYTES / 2;
let mut head = String::new();
let mut tail: std::collections::VecDeque<Vec<u8>> = Default::default();
let mut chunk: Vec<u8> = Vec::new();
let mut tail_bytes = 0usize;
let mut total = 0usize;
let mut truncated = false;
let mut text = String::new();
loop {
if cancel.is_cancelled() {
kill_tree(&mut child);
@@ -223,34 +112,8 @@ fn run_with_env_capture(
Ok((_, line)) if encoding.notice.as_ref() == Some(&line) => {}
Ok((stream, line)) => {
on_line(stream, &line);
if !bounded {
// The caller parses a complete model from `text`, so keep every line.
head.push_str(&line);
head.push('\n');
continue;
}
total += line.len() + 1;
if !truncated {
if head.len() + line.len() < cap {
head.push_str(&line);
head.push('\n');
continue;
}
truncated = true;
}
// Fixed-size chunks, not per-line buffers: a chatty build pushes millions of
// lines past the cap, and the tail must add no allocation per line.
chunk.extend_from_slice(line.as_bytes());
chunk.push(b'\n');
if chunk.len() >= 64 * 1024 {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
chunk.reserve_exact(64 * 1024);
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
}
text.push_str(&line);
text.push('\n');
}
Err(mpsc::RecvTimeoutError::Timeout) => {}
Err(mpsc::RecvTimeoutError::Disconnected) => break,
@@ -260,85 +123,13 @@ fn run_with_env_capture(
let _ = r.join();
}
let status = child.wait()?;
let mut text = head;
if truncated {
if !chunk.is_empty() {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
}
// The last partial chunk may sit past the cap; drop whole front chunks back under it.
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
// Tail chunks are flushed only right after a completed line, so the tail always begins
// at a line boundary — no leading fragment to drop.
let tail = ide_core::output_encoding::decode_tool_output(&tail.into_iter().flatten().collect::<Vec<u8>>());
let omitted = total.saturating_sub(text.len() + tail.len());
if omitted == 0 {
// Everything that overflowed the head still fits in the tail: nothing was lost.
truncated = false;
} else {
text.push_str(&format!("[{omitted} bytes of build output between these lines were not retained]\n"));
}
text.push_str(&tail);
}
Ok(Output { success: status.success(), text, truncated })
Ok(Output { success: status.success(), text })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_model_line_over_one_mebibyte_is_kept_whole_for_the_parsers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// A Gradle MODEL_LINE JSON line longer than the bounded pump's 1 MiB line cap,
// surrounded by ordinary output.
let script = "echo start; head -c 1048576 /dev/zero | tr '\\0' a; printf '\\n{\"id\":\"big\"}\\n'; echo end";
let mut lines = Vec::new();
let out = run(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// The long line is one line, not segments that a JSON-line parser would skip.
assert_eq!(lines.len(), 4);
assert_eq!(lines[1].len(), 1_048_576);
assert!(out.text.contains("{\"id\":\"big\"}"));
let models: Vec<serde_json::Value> = out.text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
assert_eq!(models.len(), 1, "the model line must survive full retention");
}
#[test]
fn a_successful_report_over_the_text_cap_is_retained_in_full() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let out = run("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Every line of a large successful dependency/model report is still there.
assert_eq!(out.text.len(), fed);
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
}
#[test]
fn runs_and_cancels_processes() {
if cfg!(windows) {
@@ -357,11 +148,10 @@ mod tests {
)
.unwrap();
assert!(!out.success);
assert!(!out.truncated);
lines.sort_by(|a, b| a.1.cmp(&b.1));
assert_eq!(lines, [(Stream::Stdout, "one".to_owned()), (Stream::Stderr, "two".to_owned())]);
cancel.cancel();
let err = run_bounded("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
let err = run("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
.err()
.unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
@@ -381,117 +171,9 @@ mod tests {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
let err =
run_bounded("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
let err = run("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
std::thread::sleep(Duration::from_millis(1300));
assert!(!marker.exists(), "the background child must be killed with the group");
}
#[test]
fn output_past_the_text_cap_keeps_head_and_tail_and_drains() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// Numbered lines 1..=6,000,000 ≈ 45 MB: past the 32 MiB retained cap.
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let mut last_seen = String::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
last_seen = line.to_owned();
})
.unwrap();
assert!(out.success);
assert!(out.truncated);
// The pipes drained to the end: the callback saw the last line.
assert_eq!(last_seen, "6000000");
assert_eq!(fed, out_success_bytes());
// The retained copy is bounded, keeps the head and the tail, and says what was dropped.
assert!(out.text.len() <= MAX_TEXT_BYTES + 128, "{}", out.text.len());
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
assert!(out.text.contains("were not retained]"));
assert!(!out.text.contains("\n3000000\n"), "a middle line must be the dropped part");
}
/// Lines `1..=6_000_000` emit exactly this many bytes (digit count + newline each).
fn out_success_bytes() -> usize {
(1..=6_000_000u64).map(|n| n.checked_ilog10().unwrap() as usize + 2).sum()
}
#[test]
fn a_newline_free_run_longer_than_the_line_cap_arrives_as_split_lines() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 2.5 MiB of `x` without a single newline.
let args = ["-c".into(), "head -c 2621440 /dev/zero | tr '\\0' x".into()];
let mut lines = Vec::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines.push(line.to_owned())
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Split at the cap, not dropped: the segments carry every byte and none is unbounded.
assert!(lines.len() >= 3, "{}", lines.len());
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 2_621_440);
assert!(lines.iter().all(|l| l.len() <= MAX_LINE_BYTES));
}
#[test]
fn a_line_split_never_cuts_a_multibyte_character() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// `x` up to one byte before the 1 MiB cap, then `é` (two bytes) straddling it, then more `x`.
let script =
"head -c 1048575 /dev/zero | tr '\\0' x; printf '\\303\\251'; head -c 1048575 /dev/zero | tr '\\0' x";
let mut lines = Vec::new();
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
// The é straddles the 1 MiB split point: segments shift to keep it whole.
assert!(lines.len() >= 2, "{}", lines.len());
// The character survived the split: present whole, never as U+FFFD halves.
assert!(lines.iter().any(|l| l.contains('é')));
assert!(lines.iter().all(|l| !l.contains('\u{FFFD}')));
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 1_048_575 + 2 + 1_048_575);
}
#[test]
fn output_just_past_the_head_cap_loses_nothing() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 4-byte `pad` lines up to just past the 16 MiB head cap, then the real last line:
// the overflow fits the tail whole, so nothing is dropped and nothing is marked.
let script = "yes pad | head -c 16777213; echo 'FATAL: the real error'";
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, _| {},
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
assert!(!out.text.contains("were not retained]"));
assert!(out.text.starts_with("pad\n"));
assert!(out.text.ends_with("FATAL: the real error\n"));
}
}
-36
Переглянути файл
@@ -1,36 +0,0 @@
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
//! run it on both revisions of `process.rs` and compare the printed numbers.
//!
//! ```text
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
//! ```
use crate::process;
use ide_core::CancellationToken;
use std::collections::BTreeMap;
use std::time::Instant;
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
#[test]
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
fn high_output_process_numbers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
let start = Instant::now();
let mut lines = 0u64;
let mut fed = 0usize;
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines += 1;
fed += line.len() + 1;
})
.unwrap();
println!(
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
start.elapsed(),
out.success,
out.text.len()
);
}
+8 -40
Переглянути файл
@@ -268,20 +268,8 @@ fn run(
process::run(program, args, cwd, env, cancel, |_, line| on_line(line))
}
/// What a sync records when a *successful* child run's output was truncated: parsing a
/// truncated listing would silently produce an incomplete model, so it is surfaced, not hidden.
pub(crate) fn truncation_note(out: &Output) -> Option<String> {
out.truncated.then(|| {
format!(
"the build printed more than the retained {} MiB of output; the model may be incomplete",
crate::process::MAX_TEXT_BYTES / (1024 * 1024)
)
})
}
/// The first error lines of a failed build, for the tool window.
pub(crate) fn error_summary(output: &Output) -> String {
let text = &output.text;
pub(crate) fn error_summary(text: &str) -> String {
// The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
if text.contains("org.gradle.wrapper.GradleWrapperMain") {
return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
@@ -301,15 +289,11 @@ pub(crate) fn error_summary(output: &Output) -> String {
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
.take(4)
.collect();
let mut summary = if lines.is_empty() {
if lines.is_empty() {
text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("the build failed").trim().to_owned()
} else {
lines.join("\n")
};
if output.truncated {
summary.push_str("\n[the build printed more than the retained output; this summary may miss lines]");
}
summary
}
/// `[INFO] Building core 1.0-SNAPSHOT [2/3]` → ("core 1.0-SNAPSHOT", 2, 3).
@@ -413,9 +397,7 @@ pub fn sync_maven(
}
}
if !out.success {
errors.push(error_summary(&out));
} else if let Some(note) = truncation_note(&out) {
errors.push(note);
errors.push(error_summary(&out.text));
}
}
cache.at_ms = now_ms();
@@ -455,8 +437,6 @@ pub fn sync_gradle_model(
let mut args: Vec<String> = vec![
"--console=plain".into(),
"-q".into(),
// The init script reports the evaluated projects, even when a build enables the configuration cache.
"-Dorg.gradle.configuration-cache=false".into(),
"--init-script".into(),
init_script.to_string_lossy().into_owned(),
"tasks".into(),
@@ -477,7 +457,7 @@ pub fn sync_gradle_model(
Ok(out) => out,
Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
Output { success: false, text: error.message, truncated: false }
Output { success: false, text: error.message }
}
Err(error) => return Err(error),
};
@@ -490,7 +470,7 @@ pub fn sync_gradle_model(
let cache = GradleCache {
hash: hash_gradle_files(&gradle::build_files(root, &model)),
at_ms: now_ms(),
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
error: (!out.success).then(|| error_summary(&out.text)),
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
projects,
resources: true,
@@ -934,22 +914,10 @@ mod tests {
);
assert_eq!(maven_building("[INFO] Building jar: x.jar"), None);
let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
let out = |text: &str, truncated| crate::process::Output { success: false, text: text.to_owned(), truncated };
assert_eq!(error_summary(&out(text, false)), "Failed to execute goal");
assert_eq!(error_summary(&out("one\nlast line\n\n", false)), "last line");
assert_eq!(error_summary(text), "Failed to execute goal");
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
assert!(error_summary(&out(missing_jar, false)).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
// A truncated capture says so instead of hiding that lines are missing.
assert!(error_summary(&out(text, true)).ends_with("this summary may miss lines]"));
}
#[test]
fn a_truncated_successful_run_is_surfaced_not_silent() {
let out = |truncated| crate::process::Output { success: true, text: String::new(), truncated };
assert!(truncation_note(&out(false)).is_none());
let note = truncation_note(&out(true)).unwrap();
assert!(note.starts_with("the build printed more than the retained 32 MiB"), "{note}");
assert!(note.ends_with("the model may be incomplete"));
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
}
#[test]
-6
Переглянути файл
@@ -446,12 +446,6 @@ pub struct LanguageCodeStyle {
/// Comment Code › Add a space at line comment start.
#[serde(skip_serializing_if = "Option::is_none")]
pub line_comment_add_space: Option<bool>,
/// PHP: align `=>` in multi-line arrays after formatting (other languages ignore it).
#[serde(skip_serializing_if = "Option::is_none")]
pub align_key_value_pairs: Option<bool>,
/// PHP: align `=` of consecutive assignment statements after formatting.
#[serde(skip_serializing_if = "Option::is_none")]
pub align_consecutive_assignments: Option<bool>,
}
/// Editor › Code Style (General tab + per-language overrides).
-47
Переглянути файл
@@ -53,10 +53,6 @@ pub enum IdeEvent {
root: crate::IpcPath,
status: DirenvStatus,
},
/// The project's `flutter daemon` changed state, or a device came or went.
FlutterDevices {
list: FlutterDeviceList,
},
/// Files or directories changed on disk (after debouncing, ignore rules applied).
FsChanged {
created: Vec<crate::IpcPath>,
@@ -238,46 +234,6 @@ pub enum AskpassKind {
Confirm,
}
/// A target `flutter run -d <id>` can name, or an Android device adb sees but Flutter can't use yet.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FlutterDevice {
pub id: String,
pub name: String,
/// `android`, `ios`, `macos`, `web`, …
pub platform_type: Option<String>,
/// `mobile`, `desktop` or `web`.
pub category: Option<String>,
pub emulator: bool,
/// The adb state keeping it from being used (`unauthorized`, `offline`, …).
pub unavailable: Option<String>,
}
/// See [`FlutterDeviceList`].
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum FlutterDaemonStatus {
#[default]
Stopped,
/// Started; the first device discovery has not finished.
Starting,
Ready,
/// No `flutter` executable on the search path.
NotInstalled,
/// The daemon could not start or exited: what it printed last. It is not restarted on its own.
Failed {
message: String,
},
}
/// The project's Flutter devices, best default first.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FlutterDeviceList {
pub status: FlutterDaemonStatus,
pub devices: Vec<FlutterDevice>,
}
/// See [`IdeEvent::Direnv`].
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
@@ -367,9 +323,6 @@ pub enum DebugEvent {
change_type: String,
message: String,
},
/// `flutter debug_adapter`'s `flutter.appStarted` event (launch and attach): the session is
/// a Flutter app that can take a hot reload now. The plain Dart adapter never sends it.
FlutterAppStarted,
/// The session's capabilities changed after it started: fetch them again.
Capabilities,
/// The adapter's `invalidated` event: what it shows for `areas` (`all`, `stacks`, `threads`,
+4 -79
Переглянути файл
@@ -16,55 +16,18 @@ 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. Batch files also need a PATH small enough for cmd.
/// console child flashes a `cmd` window.
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
///
/// Explicit variables take precedence over the host environment. Call after setting
/// `current_dir` and any explicit `PATH`, and before `env_clear`.
/// Variables the call site has already set are kept; call it before `env_clear` and after
/// `current_dir`, which picks the project environment.
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);
#[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);
}
host_env(cmd)
}
/// Starts the child as the leader of its own process group on Unix, so [`kill_tree`] and
@@ -922,44 +885,6 @@ 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() {
-41
Переглянути файл
@@ -50,8 +50,6 @@ pub struct Settings {
/// Per language server, by name (`rust-analyzer`): launch and protocol
/// options on top of the language definition, or a server defined here.
pub language_servers: BTreeMap<String, LanguageServerSettings>,
/// Tools › Download sources: a mirror prefix for the release archives the installer fetches.
pub tool_downloads: ToolDownloadSettings,
/// Editor › Inspections profiles.
pub inspections: InspectionSettings,
/// Editor › Natural Languages › Spelling.
@@ -363,22 +361,6 @@ impl Default for McpServerSettings {
}
}
/// Tools › Download sources: a mirror the installer tries when `github.com` is slow or
/// unreachable.
///
/// The mirror is a proxy prefix: the official URL is appended to it unchanged
/// (`https://mirror.example/https://github.com/o/r/releases/download/…`), which is what the
/// public GitHub proxies speak. Only `github.com` downloads are affected — those proxies
/// hard-code that host, so Eclipse JDT LS and Open VSX keep their official addresses. Empty by
/// default, so every download stays on its official host until the user opts in.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct ToolDownloadSettings {
/// Proxy prefix prepended to `https://github.com/…` archive addresses only; empty keeps
/// every download on its official host.
pub github_mirror: String,
}
/// Absent profiles retain automatic discovery for existing projects.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -517,7 +499,6 @@ impl Default for Settings {
external_tools: Vec::new(),
tools: BTreeMap::new(),
language_servers: BTreeMap::new(),
tool_downloads: ToolDownloadSettings::default(),
inspections: InspectionSettings::default(),
spelling: SpellingSettings::default(),
ssh: SshSettings::default(),
@@ -771,8 +752,6 @@ 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,
@@ -791,8 +770,6 @@ 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,
@@ -908,7 +885,6 @@ 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,
@@ -922,7 +898,6 @@ 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,
@@ -1403,8 +1378,6 @@ pub struct GoSettings {
pub goroot: String,
/// Empty = `go env GOPATH`.
pub gopath: String,
/// Format with gofumpt, a stricter gofmt (gopls `gofumpt`).
pub gofumpt: bool,
pub build_tags: GoBuildTags,
pub modules: GoModules,
}
@@ -1531,10 +1504,6 @@ pub struct MavenSettings {
pub active_profiles: String,
/// Delegate IDE build/run actions to Maven: launches build with Maven (`javac`) instead of jdtls (ECJ).
pub delegate_build: bool,
/// Download `-sources.jar` of dependencies when the Java language server imports the
/// project (jdtls `java.maven.downloadSources`). Off: sources are fetched on demand
/// from a library class's Download Sources banner.
pub download_sources: bool,
}
impl MavenSettings {
@@ -1779,16 +1748,6 @@ 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}}"#] {
-39
Переглянути файл
@@ -20,34 +20,6 @@ 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 {
@@ -62,7 +34,6 @@ impl Default for VcsSettings {
confirmation: VcsConfirmationSettings::default(),
shelf: ShelfSettings::default(),
issue_navigation: Vec::new(),
mappings: VcsMappings::default(),
}
}
}
@@ -106,9 +77,6 @@ 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 {
@@ -133,7 +101,6 @@ impl Default for GitSettings {
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
cli_status: false,
}
}
}
@@ -367,8 +334,6 @@ pub struct DebuggerSettings {
pub skip_library_code: bool,
/// JavaScript: debugging a dev server (`vite`, `next dev`) also opens its page in a browser session.
pub debug_server_page: bool,
/// Flutter: saving a Dart file of a running debug session hot reloads the app.
pub flutter_hot_reload_on_save: bool,
pub python: PythonDebuggerSettings,
}
@@ -389,7 +354,6 @@ impl Default for DebuggerSettings {
value_tooltip_delay: 700,
skip_library_code: true,
debug_server_page: false,
flutter_hot_reload_on_save: true,
python: PythonDebuggerSettings::default(),
}
}
@@ -463,8 +427,6 @@ pub struct TerminalSettings {
/// `block` | `underline` | `bar`.
pub cursor_shape: String,
pub cursor_blink: bool,
/// Cap PTY→xterm paint rate: `unlimited` | `60` | `30` | `15` | `10`.
pub max_fps: String,
pub use_editor_font: bool,
pub font_family: String,
pub font_size: f32,
@@ -496,7 +458,6 @@ impl Default for TerminalSettings {
escape_to_editor: false,
cursor_shape: "block".into(),
cursor_blink: true,
max_fps: "unlimited".into(),
use_editor_font: true,
font_family: "JetBrains Mono".into(),
font_size: 13.0,
-17
Переглянути файл
@@ -22,8 +22,6 @@ use tokio::process::{Child, Command};
pub const PORT_PLACEHOLDER: &str = "${port}";
/// Replaced by the session's working directory (the project) in adapter arguments.
pub const ROOT_PLACEHOLDER: &str = "${root}";
/// java-analyzer's debug adapter (`java-analyzer dap`), a separate process over stdio.
pub const JAVA_ANALYZER: &str = "java-analyzer";
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Transport {
@@ -136,14 +134,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
),
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
// runs the executable of the java-analyzer serving the module.
JAVA_ANALYZER => cfg(
"java-analyzer",
&["dap"],
"stdio",
"Configure java-analyzer as a Java language server (Settings › Languages & Frameworks › Language Servers)",
),
"bun-dap" => cfg(
"bun-dap",
&["${port}", "127.0.0.1"],
@@ -930,13 +920,6 @@ mod tests {
}
let delve = resolve(&builtin("delve").unwrap(), PathBuf::from("/"));
assert_eq!(delve.transport, Transport::Tcp);
// java-analyzer debugs over stdio with its `dap` subcommand.
let java_analyzer = resolve(&builtin(JAVA_ANALYZER).unwrap(), PathBuf::from("/"));
assert_eq!(
(java_analyzer.command.as_str(), java_analyzer.args.as_slice()),
("java-analyzer", &["dap".to_owned()][..])
);
assert_eq!(java_analyzer.transport, Transport::Stdio);
// GDB's own DAP interpreter over stdio, with the required version in its hint.
let gdb = builtin("gdb").unwrap();
assert_eq!(gdb.command, "gdb");
+4 -27
Переглянути файл
@@ -280,14 +280,6 @@ pub struct SessionExceptionFilters {
pub filters: Vec<ExceptionFilter>,
}
/// What triggered a hot reload; `flutter debug_adapter` takes it as `reason`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum HotReloadReason {
Manual,
Save,
}
/// A live session, as listed by [`DebugManager::sessions`].
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -412,14 +404,6 @@ fn is_flutter_project(dir: &Path, program: Option<&Path>) -> bool {
.any(|s| s.contains("sdk: flutter"))
}
/// `flutter debug_adapter` passes `toolArgs` on to `flutter run` / `flutter attach`.
fn add_flutter_device(arguments: &mut Value, device: Value) {
let args = arguments.as_object_mut().map(|o| o.entry("toolArgs").or_insert_with(|| json!([])));
if let Some(args) = args.and_then(Value::as_array_mut) {
args.extend([json!("-d"), device]);
}
}
fn no_session(s: DebugSessionId) -> IdeError {
IdeError::not_found(format!("no debug session {}", s.0))
}
@@ -784,8 +768,6 @@ impl DebugManager {
// one regardless of what the working directory holds.
let force_flutter =
arguments.as_object_mut().and_then(|o| o.remove("__flutter")).and_then(|v| v.as_bool()).unwrap_or(false);
// Also IDE-side: the device to run on, should this turn out to be a Flutter session.
let flutter_device = arguments.as_object_mut().and_then(|o| o.remove("__flutterDevice"));
let cwd = config
.cwd
.clone()
@@ -830,15 +812,10 @@ impl DebugManager {
// Flutter: a project depending on the Flutter SDK needs `flutter debug_adapter`
// (the Dart adapter cannot start a program importing `dart:ui`, and hot reload
// is Flutter-only). Plain Dart projects keep the configured `dart`.
if config.adapter == "dart" {
if config.adapter == "dart" && spec.command == "dart" {
let program = arguments.get("program").and_then(Value::as_str).map(Path::new);
if force_flutter || is_flutter_project(&cwd, program) {
if spec.command == "dart" {
spec.command = "flutter".into();
}
if let Some(device) = flutter_device {
add_flutter_device(&mut arguments, device);
}
spec.command = "flutter".into();
}
}
let id = DebugSessionId::next();
@@ -1669,8 +1646,8 @@ impl DebugManager {
/// Flutter's DAP adapter: injects the changed sources into the running app.
/// Not part of the DAP standard; adapters that do not know the request reject it.
pub async fn hot_reload(&self, s: DebugSessionId, reason: HotReloadReason) -> IdeResult<()> {
self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": reason }), REQUEST_TIMEOUT).await?;
pub async fn hot_reload(&self, s: DebugSessionId) -> IdeResult<()> {
self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": "manual" }), REQUEST_TIMEOUT).await?;
Ok(())
}
+8 -58
Переглянути файл
@@ -504,9 +504,6 @@ impl Session {
/// How long Stop waits for a launched program to exit before reporting the session ended.
pub(crate) const DEBUGGEE_EXIT_WAIT: Duration = Duration::from_secs(10);
/// How long a stop waits for a killed program to be gone (Windows ends processes asynchronously).
#[cfg(windows)]
const DEBUGGEE_KILL_WAIT: Duration = Duration::from_secs(5);
pub(crate) async fn remember_debuggee(s: &Arc<Session>) {
#[cfg(windows)]
@@ -646,24 +643,14 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
}
#[cfg(windows)]
{
use std::time::Instant;
remember_debuggee(s).await;
let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;
let mut killed: Option<Instant> = None;
let deadline = std::time::Instant::now() + DEBUGGEE_EXIT_WAIT;
// The captured tree is the oracle when it was captured; otherwise the job (every
// process the launch started) is, so a failed capture can no longer end the wait
// while the program still holds its port.
while launch_running(s) {
let now = Instant::now();
if s.stop_force.swap(false, Ordering::AcqRel) || (killed.is_none() && now >= deadline) {
if s.stop_force.swap(false, Ordering::AcqRel) || std::time::Instant::now() >= deadline {
signal_debuggee(s, true).await;
killed.get_or_insert(now);
}
// Termination is asynchronous, and a process TerminateProcess can't end (stuck in
// the kernel) would hold the stop forever: give up on it, as on Unix.
if killed.is_some_and(|at| now.duration_since(at) >= DEBUGGEE_KILL_WAIT) {
tracing::warn!(session = s.id.0, pid, "stop: the debugged program did not exit after it was killed");
break;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
@@ -879,7 +866,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
change_type: crate::hot_code_replace_type(body.get("changeType")),
message: str_("message").unwrap_or_default(),
}),
"flutter.appStarted" => s.emit(DebugEvent::FlutterAppStarted),
// Sent only by adapters told `supportsInvalidatedEvent` (kotlin-lsp).
"invalidated" => s.emit(DebugEvent::Invalidated {
areas: body
@@ -926,7 +912,7 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
/// A `runInTerminal` program and the pseudo-terminal it runs in.
pub(crate) struct ProgramTerminal {
writer: Arc<ide_core::input::InputWriter>,
writer: ide_core::input::InputWriter,
killer: Box<dyn portable_pty::ChildKiller + Send + Sync>,
#[cfg_attr(not(unix), allow(dead_code))]
pid: Option<u32>,
@@ -1039,12 +1025,10 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
let _ = child.wait();
})
.map_err(|e| format!("terminal input worker: {e}"))?;
let writer = Arc::new(writer);
let pid = child.process_id();
forward_terminal_output(
s,
reader,
writer.clone(),
#[cfg(unix)]
wait_readable,
);
@@ -1059,35 +1043,10 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
Ok(json!({ "processId": pid }))
}
/// A terminal's cursor position query (DSR). ConPTY sends one when it starts and runs the program
/// only once the terminal answers; programs that lay out a prompt ask it too.
const CURSOR_QUERY: &[u8] = b"\x1b[6n";
/// `chunk` without its cursor position queries, and how many there were.
pub(crate) fn take_cursor_queries(chunk: &[u8]) -> (Vec<u8>, usize) {
let mut out = Vec::with_capacity(chunk.len());
let mut queries = 0;
let mut rest = chunk;
while let Some(at) = rest.windows(CURSOR_QUERY.len()).position(|w| w == CURSOR_QUERY) {
out.extend_from_slice(&rest[..at]);
rest = &rest[at + CURSOR_QUERY.len()..];
queries += 1;
}
out.extend_from_slice(rest);
(out, queries)
}
/// Length of the end of `pending` that may begin a cursor position query the next read completes.
pub(crate) fn partial_cursor_query(pending: &[u8]) -> usize {
(1..CURSOR_QUERY.len()).rev().find(|&n| pending.ends_with(&CURSOR_QUERY[..n])).unwrap_or(0)
}
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept). The debug
/// console is no terminal, so cursor position queries are answered here (top-left corner).
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).
fn forward_terminal_output(
s: &Session,
mut reader: Box<dyn std::io::Read + Send>,
answer: Arc<ide_core::input::InputWriter>,
#[cfg(unix)] mut wait_readable: impl FnMut() -> std::io::Result<()> + Send + 'static,
) {
let session = s.id;
@@ -1119,20 +1078,11 @@ fn forward_terminal_output(
break;
}
}
let (rest, queries) = take_cursor_queries(&pending);
pending = rest;
for _ in 0..queries {
if let Err(e) = answer.write(b"\x1b[1;1R") {
tracing::warn!(%session, "debug terminal cursor position: {e}");
}
}
// Keep incomplete UTF-8 sequences, a `\r` that may start a `\r\n`, and the start of
// a cursor position query for the next chunk.
let keep = partial_cursor_query(&pending);
let mut valid = match std::str::from_utf8(&pending[..pending.len() - keep]) {
Ok(_) => pending.len() - keep,
// Keep incomplete UTF-8 sequences, and a `\r` that may start a `\r\n`, for the next chunk.
let mut valid = match std::str::from_utf8(&pending) {
Ok(_) => pending.len(),
Err(e) if e.error_len().is_none() => e.valid_up_to(),
Err(_) => pending.len() - keep,
Err(_) => pending.len(),
};
if valid > 0 && pending[valid - 1] == b'\r' {
valid -= 1;
-63
Переглянути файл
@@ -559,10 +559,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
}
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
"hotReload" => {
ok!(msg, Value::Null);
send!(json!({"type": "event", "event": "flutter.appStarted", "body": {}}));
}
"redefineClasses" => {
send!(
json!({"type": "event", "event": "hotcodereplace", "body": {"changeType": "STARTING", "message": "Start hot code replacement procedure..."}})
@@ -1014,44 +1010,6 @@ async fn run_in_terminal_spawns_debuggee() {
assert!(response["body"]["processId"].as_u64().unwrap() > 0);
}
/// The debug console answers a terminal's cursor position query: ConPTY asks one before it runs
/// the program at all (Windows debuggees never started), and programs that lay out a prompt ask too.
#[tokio::test]
async fn run_in_terminal_answers_cursor_position_queries() {
#[cfg(unix)]
let program = vec![
"sh".into(),
"-c".into(),
r"stty -echo -icanon min 6; printf '\033[6n'; reply=$(dd bs=6 count=1 2>/dev/null); stty sane; case $reply in *'[1;1R') echo answered;; esac".into(),
];
#[cfg(windows)]
let program = vec!["cmd".into(), "/c".into(), "echo answered".into()];
let h = harness(Script { run_in_terminal: Some(program), ..Script::default() });
h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("answered"))).await;
let output: String = h
.events
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } => Some(output.clone()),
_ => None,
})
.collect();
assert!(!output.contains("\x1b[6n"), "{output:?}");
}
#[test]
fn cursor_position_queries_are_taken_out_of_the_output() {
use crate::session::{partial_cursor_query, take_cursor_queries};
assert_eq!(take_cursor_queries(b"a\x1b[6nb\x1b[6n"), (b"ab".to_vec(), 2));
assert_eq!(take_cursor_queries(b"\x1b[0mtext"), (b"\x1b[0mtext".to_vec(), 0));
assert_eq!(partial_cursor_query(b"text\x1b["), 2);
assert_eq!(partial_cursor_query(b"text\x1b[6"), 3);
assert_eq!(partial_cursor_query(b"text\x1b[0m"), 0);
assert_eq!(partial_cursor_query(b"text"), 0);
}
#[cfg(unix)]
#[tokio::test]
async fn run_in_terminal_program_reads_typed_input() {
@@ -1895,17 +1853,6 @@ async fn startup_sends_every_file_at_once_and_skips_files_with_nothing_enabled()
);
}
#[tokio::test]
async fn hot_reload_sends_its_reason_and_reports_the_flutter_app() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.manager.hot_reload(id, HotReloadReason::Manual).await.unwrap();
h.manager.hot_reload(id, HotReloadReason::Save).await.unwrap();
let reasons: Vec<_> = requests(&h, "hotReload").iter().map(|args| args["reason"].clone()).collect();
assert_eq!(reasons, [json!("manual"), json!("save")]);
h.wait_event(|e| matches!(e, DebugEvent::FlutterAppStarted)).await;
}
#[tokio::test]
async fn hot_swap_only_for_java_debug() {
let h = harness(Script::default());
@@ -2295,16 +2242,6 @@ fn flutter_projects_are_found_from_the_program_or_the_working_directory() {
std::fs::remove_dir_all(&root).unwrap();
}
#[test]
fn the_flutter_device_follows_the_tool_arguments() {
let mut arguments = json!({ "toolArgs": ["--flavor", "dev"] });
add_flutter_device(&mut arguments, json!("macos"));
assert_eq!(arguments["toolArgs"], json!(["--flavor", "dev", "-d", "macos"]));
let mut arguments = json!({});
add_flutter_device(&mut arguments, json!("chrome"));
assert_eq!(arguments["toolArgs"], json!(["-d", "chrome"]));
}
#[test]
fn rdbg_runs_the_debuggee_after_its_options_with_the_configuration_environment() {
let dir = tempfile::tempdir().unwrap();
+1 -3
Переглянути файл
@@ -7,9 +7,6 @@ license.workspace = true
[dependencies]
ide-core.workspace = true
ide-sdk.workspace = true
tempfile.workspace = true
zip.workspace = true
dunce.workspace = true
serde.workspace = true
serde_json = { workspace = true, features = ["raw_value"] }
@@ -41,4 +38,5 @@ open = "5"
[dev-dependencies]
tokio = { workspace = true, features = ["rt-multi-thread", "macros", "net"] }
tempfile.workspace = true
ide-ssh = { workspace = true, features = ["testing"] }
+32 -351
Переглянути файл
@@ -18,21 +18,14 @@ struct State {
database: String,
settings: Vec<(String, String)>,
read_only: bool,
session: Mutex<Session>,
session_id: String,
session: Mutex<bool>,
closed: CancellationToken,
}
#[derive(Default)]
struct Session {
id: Option<String>,
initialized: bool,
strict_read_only: bool,
}
/// The response format: a names line, a types line, then one JSON array per row, so rows past
/// the grid's limit are skipped without being parsed.
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
const SESSION_LOST: &str = "ClickHouse HTTP session 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")
@@ -43,32 +36,11 @@ impl ClickhousePool {
if source.options.transaction == DbTxMode::Manual {
return Err(transaction_error());
}
let mut use_http_session = None;
let mut settings = Vec::with_capacity(setup.params.len());
for (name, value) in setup.params {
if name.eq_ignore_ascii_case("use_http_session") {
if use_http_session.is_some() {
return Err(IdeError::invalid("ClickHouse use_http_session must be specified only once"));
}
use_http_session = Some(if value.eq_ignore_ascii_case("true") {
true
} else if value.eq_ignore_ascii_case("false") {
false
} else {
return Err(IdeError::invalid("ClickHouse use_http_session must be true or false"));
});
} else if reserved_setting(&name) {
for (name, _) in &setup.params {
if reserved_setting(name) {
return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
} else {
settings.push((name, value));
}
}
let use_http_session = use_http_session.unwrap_or(true);
if !use_http_session && (!setup.statements.is_empty() || !source.options.startup_script.trim().is_empty()) {
return Err(IdeError::invalid(
"ClickHouse use_http_session=false does not support startup scripts; configure database and settings on the data source for each request",
));
}
let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
@@ -133,50 +105,16 @@ impl ClickhousePool {
endpoint,
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
password: password.unwrap_or_default().to_owned(),
database: database.into(),
settings,
database: if database.is_empty() { "default".into() } else { database.into() },
settings: setup.params,
read_only: source.read_only,
session: Mutex::new(Session {
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
..Session::default()
}),
session_id: uuid::Uuid::new_v4().to_string(),
session: Mutex::new(false),
closed: CancellationToken::new(),
}));
let cancel = CancellationToken::new();
let initialize = async {
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
if !rejects_driver_setting(&error) {
return Err(error);
}
if !use_http_session {
return Err(IdeError::new(
error.kind,
format!(
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
error.message
),
));
}
// Retry only the connection probe. Keep relying on the server for write protection
// only after verifying strict read-only mode in this same session.
{
let mut session = pool.0.session.lock().await;
// Start the proof in a fresh session: the rejected probe may have left
// its id on another replica without applying the configured database.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
}
}
// The HTTP database parameter applies to one request. A named session needs
// USE once so later queries inherit the selection (and may change it).
if use_http_session && !database.is_empty() {
let name = crate::sql::quote_ident(crate::DbDriver::Clickhouse, database);
pool.execute(&format!("USE {name}"), 0, &cancel).await?;
}
pool.execute("SELECT 1", 1, &cancel).await?;
for sql in setup.statements {
pool.execute(&sql, 0, &cancel).await?;
}
@@ -213,30 +151,27 @@ impl ClickhousePool {
}
/// `max_rows`: the rows the server may send (the skipped ones included).
fn request(&self, client: &Client, query_id: &str, max_rows: usize, session: &Session) -> RequestBuilder {
fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
let mut request = client
.post(self.0.endpoint.clone())
.basic_auth(&self.0.user, Some(&self.0.password))
.header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
.query(&self.0.settings)
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
if !session.strict_read_only {
request = request.query(&[
.query(&[
("session_id", self.0.session_id.clone()),
("session_timeout", "3600".into()),
("query_id", query_id.to_owned()),
("default_format", FORMAT.into()),
("output_format_json_quote_denormals", "1".into()),
("max_result_rows", max_rows.saturating_add(1).to_string()),
("result_overflow_mode", "break".into()),
]);
}
if let Some(session_id) = &session.id {
request = request.query(&[("session_id", session_id.as_str()), ("session_timeout", "3600")]);
if session.initialized {
request = request.query(&[("session_check", "1")]);
}
}
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
if initialized {
request = request.query(&[("session_check", "1")]);
} else {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only && !session.strict_read_only {
if self.0.read_only {
request = request.query(&[("readonly", "1")]);
}
request
@@ -265,7 +200,7 @@ impl ClickhousePool {
};
let client = self.client()?;
let query_id = uuid::Uuid::new_v4().to_string();
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), &session).body(sql.to_owned());
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), *session).body(sql.to_owned());
let started = Instant::now();
let fetch = async {
let mut response = request.send().await.map_err(http_error)?;
@@ -319,7 +254,7 @@ impl ClickhousePool {
match result {
Some(result) => {
if result.is_ok() {
session.initialized = true;
*session = true;
}
result
}
@@ -372,7 +307,11 @@ impl ClickhousePool {
let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
|| matches!(code, Some("193" | "194" | "195" | "516" | "497"));
let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
"ClickHouse HTTP session expired; reconnect to restore session settings"
} else {
detail
};
self.redact_error(IdeError::new(
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
@@ -384,9 +323,9 @@ type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);
/// Decodes a streamed [`FORMAT`] body. Reads past the first `skip` rows unparsed (a later
/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
/// unparsed, so a grid limit bounds memory even if a strict read-only server does not allow
/// per-query result limits. A line that is not a JSON array starts the exception ClickHouse
/// writes when a query fails mid-stream.
/// unparsed, so a grid limit bounds memory however large the block
/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
/// starts the exception ClickHouse writes when a query fails mid-stream.
struct RowReader {
skip: usize,
max_rows: usize,
@@ -494,11 +433,7 @@ impl RowReader {
let rest = std::mem::take(&mut self.pending);
self.line(&rest)?;
if let Some(exception) = self.exception {
let detail = exception_text(&exception);
return Err(IdeError::invalid(format!(
"ClickHouse: {}",
if session_not_found(detail) { SESSION_LOST } else { detail }
)));
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
}
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
let types = self.types.unwrap_or_default();
@@ -510,13 +445,6 @@ impl RowReader {
}
}
/// Whether a server message reports a named HTTP session this node doesn't have.
fn session_not_found(detail: &str) -> bool {
detail.starts_with("Code: 372.")
|| detail.starts_with("Session not found")
|| detail.starts_with("SESSION_NOT_FOUND")
}
/// The server's message in a failed response: rows already streamed and the
/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
fn exception_text(body: &str) -> &str {
@@ -551,20 +479,6 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
}
fn rejects_driver_setting(error: &IdeError) -> bool {
error
.message
.split_once(": ")
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
.and_then(|detail| detail.split_once("' setting in readonly mode"))
.is_some_and(|(name, _)| {
matches!(
name,
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
)
})
}
fn reserved_setting(name: &str) -> bool {
let name = name.to_ascii_lowercase();
name.starts_with("output_format_json_")
@@ -661,19 +575,6 @@ mod tests {
DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
}
fn property(name: &str, value: &str) -> DbProperty {
DbProperty { name: name.into(), value: value.into() }
}
fn request_url(request: &str) -> Url {
let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap();
Url::parse(&format!("http://localhost{target}")).unwrap()
}
fn query_value(url: &Url, key: &str) -> Option<String> {
url.query_pairs().find(|(name, _)| name == key).map(|(_, value)| value.into_owned())
}
fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
decode_from(body, 0, max_rows, chunk)
}
@@ -752,7 +653,6 @@ mod tests {
let (port, requests) = server(vec![
("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
("200 OK", "", ""),
("200 OK", "", ""),
(
"200 OK",
"X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
@@ -764,7 +664,7 @@ mod tests {
user: "reader".into(),
read_only: true,
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
..source(port)
};
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
@@ -787,7 +687,7 @@ mod tests {
assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
assert_eq!(value(&urls[3], "max_result_rows").as_deref(), Some("2"));
assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
for (request, url) in requests.iter().zip(&urls) {
assert!(request.starts_with("POST /?"));
assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
@@ -795,10 +695,8 @@ mod tests {
assert_eq!(value(url, "readonly").as_deref(), Some("1"));
assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
assert_eq!(value(url, "use_http_session"), None);
}
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with("USE `analytics`"));
assert!(pool.transaction(&[]).await.is_err());
let cancel = CancellationToken::new();
cancel.cancel();
@@ -808,85 +706,6 @@ 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();
@@ -907,144 +726,6 @@ mod tests {
task.await.unwrap();
}
#[tokio::test]
async fn connects_when_server_forbids_settings_in_readonly_mode() {
let (port, requests) = server(vec![
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'output_format_json_quote_denormals' setting in readonly mode. (READONLY)",
),
("200 OK", "", ONE),
("200 OK", "", ""),
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[1]\n[2]\n"),
])
.await;
let source = DataSource {
database: "system".into(),
read_only: true,
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let result = pool.execute("SELECT number FROM numbers(2)", 1, &CancellationToken::new()).await.unwrap();
assert_eq!(result.rows, vec![vec![Some("1".into())]]);
assert!(result.has_more);
let requests = requests.await.unwrap();
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[0].contains("output_format_json_quote_denormals=1"));
assert!(requests[1].ends_with("SELECT getSetting('readonly')"));
assert!(!requests[1].contains("session_check="));
assert_eq!(query_value(&request_url(&requests[1]), "database").as_deref(), Some("system"));
assert!(requests[2].contains("session_check=1"));
let session_id = query_value(&request_url(&requests[1]), "session_id").unwrap();
assert_ne!(query_value(&request_url(&requests[0]), "session_id").as_deref(), Some(session_id.as_str()));
for request in &requests[1..] {
assert_eq!(query_value(&request_url(request), "session_id").as_deref(), Some(session_id.as_str()));
assert!(request.contains("default_format=JSONCompactEachRowWithNamesAndTypes"));
assert!(request.contains("max_threads=2"));
for setting in
["output_format_json_quote_denormals=", "max_result_rows=", "result_overflow_mode=", "readonly="]
{
assert!(!request.contains(setting), "{setting} is not allowed in a strict read-only session");
}
}
}
#[tokio::test]
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
for read_only in [false, true] {
let (port, requests) = server(vec![(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
)])
.await;
let source =
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(error.message.contains("use_http_session=false requires per-request"));
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].ends_with("SELECT 1"));
let url = request_url(&requests[0]);
assert_eq!(query_value(&url, "max_result_rows").as_deref(), Some("2"));
assert_eq!(query_value(&url, "readonly").as_deref(), read_only.then_some("1"));
assert_eq!(query_value(&url, "session_id"), None);
}
}
#[tokio::test]
async fn incompatible_stateless_options_are_rejected_before_connecting() {
for (properties, startup_script, expected) in [
(vec![property("use_http_session", "false")], "SET max_threads = 2", "does not support startup scripts"),
(vec![property("use_http_session", "invalid")], "", "must be true or false"),
(
vec![property("use_http_session", "false"), property("USE_HTTP_SESSION", "true")],
"",
"must be specified only once",
),
(
vec![property("use_http_session", "false"), property("session_id", "custom")],
"",
"manages the session_id",
),
(
vec![property("use_http_session", "false"), property("session_check", "0")],
"",
"manages the session_check",
),
(
vec![property("use_http_session", "false"), property("session_timeout", "60")],
"",
"manages the session_timeout",
),
] {
let source = DataSource {
properties,
options: DbOptions { startup_script: startup_script.into(), ..Default::default() },
..source(1)
};
let error = Pool::connect(&source, None, None).await.err().expect("incompatible options must fail");
assert!(error.message.contains(expected), "{}", error.message);
}
}
#[tokio::test]
async fn readonly_probe_does_not_disable_settings_on_a_writable_session() {
let (port, requests) = server(vec![
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
),
("200 OK", "", "[\"readonly\"]\n[\"UInt64\"]\n[0]\n"),
])
.await;
let source = DataSource { read_only: true, ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("writable session must stay rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(requests.await.unwrap()[1].ends_with("SELECT getSetting('readonly')"));
}
#[test]
fn readonly_probe_matches_only_the_driver_settings() {
for (code, setting, expected) in [
(164, "max_result_rows", true),
(164, "result_overflow_mode", true),
(164, "readonly", true),
(164, "max_threads", false),
(516, "max_result_rows", false),
] {
let error = IdeError::invalid(format!(
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
));
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
}
}
#[tokio::test]
async fn server_errors_keep_details_and_hide_passwords() {
let (port, requests) = server(vec![(
+1 -14
Переглянути файл
@@ -237,7 +237,6 @@ pub enum Pool {
Mysql(ServerPool<MysqlManager>),
SqlServer(Bb8Pool<MssqlConnectionManager>),
Clickhouse(crate::clickhouse::ClickhousePool),
Jdbc(Box<crate::jdbc::JdbcPool>),
Oracle(crate::oracle::OraclePool),
Snowflake(crate::snowflake::SnowflakePool),
}
@@ -730,7 +729,6 @@ impl Pool {
Pool::Mysql(_) => DbDriver::Mysql,
Pool::SqlServer(_) => DbDriver::SqlServer,
Pool::Clickhouse(_) => DbDriver::Clickhouse,
Pool::Jdbc(_) => DbDriver::Jdbc,
Pool::Oracle(_) => DbDriver::Oracle,
Pool::Snowflake(_) => DbDriver::Snowflake,
}
@@ -921,7 +919,6 @@ impl Pool {
conn.query("SELECT 1", &[]).await.map_err(mssql_err)?.into_results().await.map_err(mssql_err)?;
Ok(Pool::SqlServer(pool))
}
DbDriver::Jdbc => Err(IdeError::invalid("An installed JDBC driver profile is required")),
DbDriver::Clickhouse => unreachable!(),
DbDriver::Oracle | DbDriver::Snowflake => unreachable!(),
}
@@ -931,7 +928,6 @@ impl Pool {
match self {
Pool::SqlServer(_) | Pool::Oracle(_) => {}
Pool::Clickhouse(p) => p.close(),
Pool::Jdbc(p) => p.close().await,
Pool::Snowflake(p) => p.close().await,
Pool::Sqlite(p) => p.close().await,
Pool::Postgres(p) => p.closed.store(true, Ordering::Relaxed),
@@ -944,7 +940,6 @@ impl Pool {
Pool::SqlServer(_) => false,
Pool::Oracle(p) => p.is_closed(),
Pool::Clickhouse(p) => p.is_closed(),
Pool::Jdbc(p) => p.is_closed(),
Pool::Snowflake(p) => p.is_closed(),
Pool::Sqlite(p) => p.is_closed(),
Pool::Postgres(p) => p.closed.load(Ordering::Relaxed),
@@ -954,9 +949,6 @@ impl Pool {
/// Runs `sql` (no row limit beyond `max`), for introspection: cells are text (see [`Cells::Text`]).
pub async fn rows(&self, sql: &str, max: usize) -> IdeResult<Vec<Vec<Option<String>>>> {
if let Pool::Jdbc(p) = self {
return Ok(p.query(sql, 0, max, &CancellationToken::new()).await?.rows);
}
if let Pool::Clickhouse(p) = self {
return Ok(p.execute(sql, max, &CancellationToken::new()).await?.rows);
}
@@ -984,9 +976,6 @@ impl Pool {
max_rows: usize,
cancel: &CancellationToken,
) -> IdeResult<QueryResult> {
if let Pool::Jdbc(p) = self {
return p.query(sql, skip, max_rows, cancel).await;
}
if let Pool::Clickhouse(p) = self {
return p.execute_from(sql, skip, max_rows, cancel).await;
}
@@ -1009,7 +998,6 @@ impl Pool {
/// row when flagged (table editor submits).
pub async fn transaction(&self, statements: &[(String, bool)]) -> IdeResult<u64> {
match self {
Pool::Jdbc(_) => Err(IdeError::invalid("Custom JDBC table editing is unsupported")),
Pool::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),
Pool::Snowflake(p) => p.transaction(statements).await,
Pool::SqlServer(_) => {
@@ -1100,7 +1088,6 @@ pub enum Held {
impl Held {
pub async fn acquire(pool: &Pool) -> IdeResult<Self> {
Ok(match pool {
Pool::Jdbc(_) => return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported")),
Pool::Sqlite(p) => Held::Sqlite(p.acquire().await.map_err(db_err)?),
Pool::Postgres(p) => Held::Postgres(Box::new(p.get().await?)),
Pool::Mysql(p) => Held::Mysql(Box::new(p.get().await?)),
@@ -1390,7 +1377,7 @@ pub fn begin_statement(driver: DbDriver) -> &'static str {
DbDriver::Mysql => "START TRANSACTION",
DbDriver::SqlServer => "BEGIN TRAN",
DbDriver::Oracle => "", // opens implicitly with autocommit off
DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse | DbDriver::Snowflake | DbDriver::Jdbc => "BEGIN",
DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse | DbDriver::Snowflake => "BEGIN",
}
}
-678
Переглянути файл
@@ -1,678 +0,0 @@
//! A trusted local driver profile is shared by data sources. JDBC URLs and properties
//! can run driver-specific initialization. A project source may connect only with the
//! settings its user last accepted in the dialog; the approval lives outside the project.
use crate::{DataSource, DbManager, QueryResult, ResultColumn};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::io::{Cursor, Read};
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::{Duration, Instant};
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
use tokio::process::{ChildStdin, ChildStdout, Command};
use tokio::sync::Mutex;
use tokio::time::{Instant as Deadline, timeout_at};
const LIMIT: usize = 16 * 1024 * 1024;
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbJdbcDriver {
pub id: String,
pub name: String,
pub jars: Vec<String>,
pub class_name: String,
pub url_template: String,
}
fn persist_local(path: &Path, data: &[u8]) -> IdeResult<()> {
let dir = path.parent().expect("registry paths have a parent");
std::fs::create_dir_all(dir)?;
let mut tmp = tempfile::NamedTempFile::new_in(dir)?;
std::io::Write::write_all(&mut tmp, data)?;
tmp.persist(path).map_err(|e| IdeError::from(e.error))?;
Ok(())
}
fn local_jar(jar: &str) -> IdeResult<&Path> {
if jar.contains(if cfg!(windows) { ';' } else { ':' }) {
return Err(IdeError::invalid("A JDBC JAR path contains the system classpath separator"));
}
let path = Path::new(jar);
if !path.is_absolute() || !path.is_file() || !path.extension().is_some_and(|ext| ext.eq_ignore_ascii_case("jar")) {
return Err(IdeError::invalid("Choose an existing local .jar file for each JDBC driver file"));
}
Ok(path)
}
/// Read the standard JDBC service descriptors without executing any driver code.
pub fn jdbc_driver_classes(jars: &[String]) -> IdeResult<Vec<String>> {
let mut classes = Vec::new();
if jars.len() > 128 {
return Err(IdeError::invalid("Choose at most 128 JDBC driver files"));
}
for jar in jars {
let file = std::fs::File::open(local_jar(jar)?)?;
let mut archive = zip::ZipArchive::new(file).map_err(|_| IdeError::invalid("Invalid JDBC JAR archive"))?;
let descriptor = match archive.by_name("META-INF/services/java.sql.Driver") {
Ok(entry) => entry,
Err(zip::result::ZipError::FileNotFound) => continue,
Err(_) => return Err(IdeError::invalid("Cannot read the JDBC driver descriptor")),
};
let mut text = String::new();
descriptor.take(65537).read_to_string(&mut text)?;
if text.len() > 65536 {
return Err(IdeError::invalid("JDBC driver descriptor is too large"));
}
for line in text.lines() {
let name = line.split('#').next().unwrap_or_default().trim();
if !name.is_empty()
&& name.split('.').all(|part| {
let mut chars = part.chars();
chars.next().is_some_and(|c| c.is_alphabetic() || matches!(c, '_' | '$'))
&& chars.all(|c| c.is_alphanumeric() || matches!(c, '_' | '$'))
})
&& !classes.iter().any(|s| s == name)
{
classes.push(name.to_owned());
}
}
}
Ok(classes)
}
impl DbJdbcDriver {
fn validate(&self) -> IdeResult<()> {
if self.id.is_empty()
|| self.name.trim().is_empty()
|| self.jars.is_empty()
|| self.class_name.trim().is_empty()
{
return Err(IdeError::invalid("A JDBC driver needs a name, a driver class and at least one JAR"));
}
if !self.url_template.is_empty() && !self.url_template.starts_with("jdbc:") {
return Err(IdeError::invalid("The JDBC URL template must start with jdbc:"));
}
for jar in &self.jars {
local_jar(jar)?;
}
Ok(())
}
}
impl DbManager {
fn jdbc_registry(&self) -> IdeResult<PathBuf> {
self.global
.as_ref()
.map(|(dir, _)| dir.join("jdbc-drivers.json"))
.ok_or_else(|| IdeError::invalid("Global JDBC driver profiles are unavailable here"))
}
pub fn jdbc_drivers(&self) -> IdeResult<Vec<DbJdbcDriver>> {
let path = self.jdbc_registry()?;
match std::fs::File::open(path) {
Ok(file) => {
serde_json::from_reader(file).map_err(|e| IdeError::invalid(format!("JDBC driver profiles: {e}")))
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(vec![]),
Err(e) => Err(e.into()),
}
}
fn update_jdbc_driver(&self, id: &str, driver: Option<DbJdbcDriver>) -> IdeResult<()> {
let _guard = crate::plugin::EDIT.lock();
let path = self.jdbc_registry()?;
let mut list = self.jdbc_drivers()?;
list.retain(|d| d.id != id);
list.extend(driver);
let data = serde_json::to_vec_pretty(&list).map_err(|e| IdeError::internal(e.to_string()))?;
persist_local(&path, &data)
}
pub fn save_jdbc_driver(&self, driver: DbJdbcDriver) -> IdeResult<()> {
driver.validate()?;
self.update_jdbc_driver(&driver.id.clone(), Some(driver))
}
pub fn remove_jdbc_driver(&self, id: &str) -> IdeResult<()> {
if self.global_sources().iter().any(|s| s.driver == crate::DbDriver::Jdbc && s.jdbc_driver == id) {
return Err(IdeError::invalid("This JDBC driver is in use by a data source"));
}
self.update_jdbc_driver(id, None)
}
fn jdbc_approval(&self, source: &DataSource) -> IdeResult<(PathBuf, String)> {
let registry = self.jdbc_registry()?;
let key = serde_json::to_vec(&(&self.root, &source.id)).map_err(|e| IdeError::internal(e.to_string()))?;
let settings = serde_json::to_vec(&(
&source.jdbc_driver,
&source.url,
&source.user,
source.read_only,
&source.properties,
&source.options,
))
.map_err(|e| IdeError::internal(e.to_string()))?;
Ok((
registry.with_file_name("jdbc-approvals").join(blake3::hash(&key).to_hex().as_str()),
blake3::hash(&settings).to_hex().to_string(),
))
}
/// Called only for the source the user explicitly saved in the connection dialog.
pub fn approve_jdbc_source(&self, source: &DataSource) -> IdeResult<()> {
if source.driver != crate::DbDriver::Jdbc || source.plugin_owner.is_some() {
return Err(IdeError::invalid("Expected a user-managed JDBC data source"));
}
let (path, fingerprint) = self.jdbc_approval(source)?;
persist_local(&path, fingerprint.as_bytes())
}
pub(crate) async fn open_pool(
&self,
source: &DataSource,
password: Option<&str>,
testing: bool,
) -> IdeResult<crate::Pool> {
if source.driver != crate::DbDriver::Jdbc {
return crate::Pool::connect(source, password, Some(&self.root)).await;
}
if source.plugin_owner.is_some() {
return Err(IdeError::invalid("Plugins cannot start custom JDBC drivers"));
}
if !testing && !source.global {
let (path, expected) = self.jdbc_approval(source)?;
if std::fs::read_to_string(path).ok().as_deref() != Some(&expected) {
return Err(IdeError::invalid(
"Review this project's JDBC URL and properties, then save the data source before connecting",
));
}
}
let driver = self
.jdbc_drivers()?
.into_iter()
.find(|d| d.id == source.jdbc_driver)
.ok_or_else(|| IdeError::invalid("Select an installed JDBC driver profile"))?;
JdbcPool::connect(source, password, driver, self.jdbc_registry()?.with_file_name("jdbc"))
.await
.map(Box::new)
.map(crate::Pool::Jdbc)
}
}
struct Bridge {
stop: tokio::sync::oneshot::Sender<()>,
exited: tokio::task::JoinHandle<()>,
sequence: u64,
input: ChildStdin,
output: ChildStdout,
}
pub struct JdbcPool {
bridge: Mutex<Option<Bridge>>,
closed: CancellationToken,
pub(crate) version: String,
pub(crate) identifier_quote: String,
}
impl Bridge {
fn start(cache: &Path, jars: &[String]) -> IdeResult<Self> {
let jdks = ide_sdk::java::installed_jdks();
let java = ide_sdk::java::java_runtime(&jdks, 17)
.ok_or_else(|| IdeError::invalid("Install a Java 17 or newer runtime to use custom JDBC drivers"))?;
let jar = ide_sdk::java::jdbc_bridge_jar(cache)
.ok_or_else(|| IdeError::invalid("Cannot install the JDBC bridge in the application data directory"))?;
let classpath = std::env::join_paths(std::iter::once(jar.as_path()).chain(jars.iter().map(Path::new)))
.map_err(|_| IdeError::invalid("A JDBC JAR path contains the system classpath separator"))?;
// Embedded databases can resolve file URLs against the JVM's working directory.
let files = cache.join("files");
std::fs::create_dir_all(&files)?;
let mut command = Command::new(ide_sdk::java::java_executable(&java.home));
command.current_dir(files);
ide_core::process::prepare(command.as_std_mut());
let mut child = command
.args(["-Xms8m", "-Xmx192m", "--enable-native-access=ALL-UNNAMED", "-cp"])
.arg(classpath)
.arg("ai.openidea.jdbc.OpenIdeaJdbc")
.env_remove("CLASSPATH")
.env_remove("JDK_JAVA_OPTIONS")
.env_remove("JAVA_TOOL_OPTIONS")
.env_remove("_JAVA_OPTIONS")
.kill_on_drop(true)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.spawn()?;
let input = child.stdin.take().expect("piped");
let output = child.stdout.take().expect("piped");
let (stop, stopped) = tokio::sync::oneshot::channel();
let exited = tokio::spawn(async move {
tokio::select! {
stop = stopped => {
// Disconnect closes stdin so a file-backed driver can flush. A dropped
// request or an unresponsive driver must be reaped without waiting.
if stop.is_err() || tokio::time::timeout(Duration::from_secs(2), child.wait()).await.is_err() {
let _ = child.kill().await;
}
}
_ = child.wait() => {}
}
});
Ok(Self { input, output, stop, exited, sequence: 0 })
}
async fn close(self) {
drop(self.input);
let _ = self.stop.send(());
let _ = self.exited.await;
}
}
// Request: u64 request id, u32 field count, then length-prefixed UTF-8 fields.
// Zero fields cancels that id. Replies have a u32 length; zero acknowledges Cancel.
fn encode(id: u64, fields: &[&str]) -> IdeResult<Vec<u8>> {
if fields.is_empty() || fields.len() > 8192 {
return Err(IdeError::invalid("Invalid JDBC field count"));
}
let size = fields
.iter()
.try_fold(12usize, |n, s| n.checked_add(4)?.checked_add(s.len()).filter(|n| *n <= LIMIT))
.ok_or_else(|| IdeError::invalid("JDBC request exceeds 16 MiB"))?;
let mut data = Vec::with_capacity(size);
data.extend_from_slice(&id.to_be_bytes());
data.extend_from_slice(&(fields.len() as u32).to_be_bytes());
for field in fields {
data.extend_from_slice(&(field.len() as u32).to_be_bytes());
data.extend_from_slice(field.as_bytes());
}
Ok(data)
}
async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>> {
let n = output.read_u32().await? as usize;
if n > LIMIT {
return Err(IdeError::invalid("JDBC response exceeds 16 MiB"));
}
let mut data = vec![0; n];
output.read_exact(&mut data).await?;
Ok(data)
}
const CANCEL_GRACE: Duration = Duration::from_secs(3);
fn cancel_timeout() -> IdeError {
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
}
async fn exchange(
input: &mut (impl AsyncWrite + Unpin),
output: &mut (impl AsyncRead + Unpin),
frame: Vec<u8>,
cancel: &CancellationToken,
) -> IdeResult<Option<Vec<u8>>> {
let mut stop = [0; 12];
stop[..8].copy_from_slice(&frame[..8]);
let early_deadline = {
let send = input.write_all(&frame);
tokio::pin!(send);
tokio::select! {
result = &mut send => { result?; None },
() = cancel.cancelled() => {
let end = Deadline::now() + CANCEL_GRACE;
timeout_at(end, send).await.map_err(|_| cancel_timeout())??;
Some(end)
}
}
};
drop(frame);
let (first, deadline) = {
let reply = read_frame(output);
tokio::pin!(reply);
let end = tokio::select! {
biased;
() = cancel.cancelled() => early_deadline.unwrap_or_else(|| Deadline::now() + CANCEL_GRACE),
data = &mut reply => {
let data = data?;
if data.is_empty() { return Err(IdeError::invalid("Unexpected JDBC cancellation acknowledgement")); }
return Ok(Some(data));
}
};
let first = timeout_at(end, async {
input.write_all(&stop).await?;
reply.await
})
.await
.map_err(|_| cancel_timeout())??;
(first, end)
};
// Drain both frames before the next statement can use this session. The driver
// may complete the statement before or after the control thread acknowledges it.
let data = if first.is_empty() {
timeout_at(deadline, read_frame(output)).await.map_err(|_| cancel_timeout())??
} else {
if timeout_at(deadline, output.read_u32()).await.map_err(|_| cancel_timeout())?? != 0 {
return Err(IdeError::invalid("Invalid JDBC cancellation acknowledgement"));
}
first
};
match data.first() {
// A committed statement may have finished before the control thread received Cancel.
Some(1) => Ok(Some(data)),
Some(0) => Ok(None),
_ => Err(IdeError::invalid("Invalid JDBC cancellation response")),
}
}
impl JdbcPool {
async fn connect(
source: &DataSource,
password: Option<&str>,
driver: DbJdbcDriver,
cache: PathBuf,
) -> IdeResult<Self> {
driver.validate()?;
let mut fields = vec![
"open".to_string(),
driver.class_name,
source.url.clone(),
source.user.clone(),
password.unwrap_or_default().to_owned(),
source.read_only.to_string(),
];
for p in &source.properties {
if p.name.eq_ignore_ascii_case("password") {
return Err(IdeError::invalid("Enter the JDBC password in the password field"));
}
fields.extend([p.name.clone(), p.value.clone()]);
}
let bridge = tokio::task::spawn_blocking(move || Bridge::start(&cache, &driver.jars))
.await
.map_err(|e| IdeError::internal(e.to_string()))??;
let mut pool = Self {
bridge: Mutex::new(Some(bridge)),
closed: CancellationToken::new(),
version: String::new(),
identifier_quote: String::new(),
};
let args: Vec<_> = fields.iter().map(String::as_str).collect();
let cancel = CancellationToken::new();
let result = tokio::time::timeout(Duration::from_secs(30), pool.request(&args, "", &cancel))
.await
.map_err(|_| IdeError::new(ide_core::error::ErrorKind::TimedOut, "JDBC connection timed out"))??;
let mut metadata = result.rows.into_iter().next().unwrap_or_default().into_iter();
pool.version = metadata.next().flatten().unwrap_or_else(|| "Connected".into());
pool.identifier_quote = metadata.next().flatten().unwrap_or_default().trim().into();
Ok(pool)
}
pub(crate) async fn close(&self) {
self.closed.cancel();
if let Some(bridge) = self.bridge.lock().await.take() {
bridge.close().await;
}
}
pub(crate) fn is_closed(&self) -> bool {
self.closed.is_cancelled()
}
pub(crate) async fn query(
&self,
sql: &str,
skip: usize,
max: usize,
cancel: &CancellationToken,
) -> IdeResult<QueryResult> {
self.query_in_schema(sql, skip, max, cancel, None).await
}
pub(crate) async fn query_in_schema(
&self,
sql: &str,
skip: usize,
max: usize,
cancel: &CancellationToken,
schema: Option<&str>,
) -> IdeResult<QueryResult> {
self.request(
&["query", sql, &skip.to_string(), &max.min(i32::MAX as usize).to_string(), schema.unwrap_or_default()],
sql,
cancel,
)
.await
}
pub(crate) async fn page(
&self,
sql: &str,
offset: u64,
limit: u64,
cancel: &CancellationToken,
) -> IdeResult<QueryResult> {
self.request(&["page", sql, &offset.to_string(), &limit.min(i32::MAX as u64).to_string()], sql, cancel).await
}
pub(crate) async fn metadata(&self, fields: &[&str]) -> IdeResult<Vec<Vec<Option<String>>>> {
Ok(self.request(fields, "", &CancellationToken::new()).await?.rows)
}
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
let mut slot = tokio::select! {
biased;
() = cancel.cancelled() => return Err(IdeError::cancelled()),
() = self.closed.cancelled() => return Err(IdeError::invalid("JDBC connection is closed")),
slot = self.bridge.lock() => slot,
};
let bridge = slot
.as_mut()
.ok_or_else(|| IdeError::invalid("JDBC connection is closed; reconnect to start a new session"))?;
bridge.sequence = bridge.sequence.wrapping_add(1);
let frame = encode(bridge.sequence, fields)?;
let mut bridge = slot.take().expect("checked above");
// Dropping an in-flight request must discard its process and partially consumed frame.
let interrupted = self.closed.clone().drop_guard();
let start = Instant::now();
let response = tokio::select! {
biased;
() = self.closed.cancelled() => Err(IdeError::cancelled()),
response = exchange(&mut bridge.input, &mut bridge.output, frame, cancel) => response,
};
let data = match response {
Ok(data) => {
*slot = Some(bridge);
interrupted.disarm();
data
}
Err(e) => {
drop(bridge.stop);
let _ = bridge.exited.await;
return Err(e);
}
};
decode(&data.ok_or_else(IdeError::cancelled)?, sql, start.elapsed().as_secs_f64() * 1000.0)
}
}
fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
let mut input = Cursor::new(data);
fn bytes<const N: usize>(input: &mut Cursor<&[u8]>) -> IdeResult<[u8; N]> {
let mut buf = [0; N];
Read::read_exact(input, &mut buf)?;
Ok(buf)
}
fn flag(input: &mut Cursor<&[u8]>) -> IdeResult<bool> {
match bytes::<1>(input)? {
[0] => Ok(false),
[1] => Ok(true),
_ => Err(IdeError::invalid("Invalid JDBC flag")),
}
}
fn field(input: &mut Cursor<&[u8]>) -> IdeResult<Option<String>> {
let n = i32::from_be_bytes(bytes(input)?);
if n == -1 {
return Ok(None);
}
let start = input.position() as usize;
let end = start
.checked_add(n as usize)
.filter(|end| *end <= input.get_ref().len())
.ok_or_else(|| IdeError::invalid("Invalid JDBC field length"))?;
let value = String::from_utf8_lossy(&input.get_ref()[start..end]).into_owned();
input.set_position(end as u64);
Ok(Some(value))
}
if !flag(&mut input)? {
return Err(IdeError::invalid(field(&mut input)?.unwrap_or_else(|| "JDBC request failed".into())));
}
let count = u32::from_be_bytes(bytes(&mut input)?) as usize;
if count > data.len() / 8 {
return Err(IdeError::invalid("Invalid JDBC column count"));
}
let mut columns = Vec::new();
for _ in 0..count {
columns.push(ResultColumn {
name: field(&mut input)?.unwrap_or_default(),
type_name: field(&mut input)?.unwrap_or_default(),
});
}
let mut rows = vec![];
while flag(&mut input)? {
if count == 0 {
return Err(IdeError::invalid("JDBC returned a row with no columns"));
}
rows.push((0..count).map(|_| field(&mut input)).collect::<IdeResult<_>>()?);
}
let has_more = flag(&mut input)?;
let affected = i64::from_be_bytes(bytes(&mut input)?);
if input.position() != data.len() as u64 {
return Err(IdeError::invalid("Invalid trailing JDBC response data"));
}
Ok(QueryResult {
statement: sql.into(),
columns,
rows,
has_more,
affected: (affected >= 0).then_some(affected as f64),
elapsed_ms,
execution_ms: elapsed_ms,
})
}
impl DbManager {
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
let mut tables = vec![];
let schemas = self.schemas(id).await?;
for schema in &schemas {
for table in self.tables(id, schema).await? {
tables.push(crate::CompletionTable {
schema: schema.clone(),
name: table.name,
kind: table.kind,
columns: vec![],
});
if tables.len() >= crate::MAX_META_ROWS {
break;
}
}
if tables.len() >= crate::MAX_META_ROWS {
break;
}
}
Ok(crate::CompletionModel {
default_schema: pool
.metadata(&["namespace"])
.await?
.into_iter()
.flatten()
.flatten()
.next()
.unwrap_or_default(),
tables,
foreign_keys: vec![],
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn frame_codec_checks_both_16_mib_boundaries() {
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
let mut field = "x".repeat(LIMIT - 16);
assert_eq!(encode(1, &[&field]).unwrap().len(), LIMIT);
field.push('x');
assert!(encode(1, &[&field]).is_err());
let mut framed = vec![0u8; LIMIT + 4];
framed[..4].copy_from_slice(&(LIMIT as u32).to_be_bytes());
assert_eq!(read_frame(&mut framed.as_slice()).await.unwrap().len(), LIMIT);
assert!(read_frame(&mut &((LIMIT + 1) as u32).to_be_bytes()[..]).await.is_err());
assert!(read_frame(&mut &[0, 0, 0, 2, 1u8][..]).await.is_err());
}
#[tokio::test]
async fn cancel_drains_partial_replies_in_either_order() {
for ack_first in [true, false] {
let (mut input, mut peer_input) = tokio::io::duplex(1);
let (mut output, mut peer_output) = tokio::io::duplex(1);
let cancel = CancellationToken::new();
let frame = encode(42, &["query"]).unwrap();
let peer = async {
let mut request = vec![0; frame.len()];
peer_input.read_exact(&mut request).await.unwrap();
assert_eq!(request, frame);
// The one-byte pipe forces the reader to consume part of the header before Cancel.
peer_output.write_all(&[0, 0]).await.unwrap();
cancel.cancel();
let mut stop = [0; 12];
peer_input.read_exact(&mut stop).await.unwrap();
assert_eq!(&stop[..8], &42u64.to_be_bytes());
assert_eq!(&stop[8..], &[0; 4]);
let frames = if ack_first { [0, 0, 0, 0, 0, 1, 0] } else { [0, 1, 1, 0, 0, 0, 0] };
peer_output.write_all(&frames).await.unwrap();
};
let (result, ()) = tokio::join!(exchange(&mut input, &mut output, frame.clone(), &cancel), peer);
assert_eq!(result.unwrap(), (!ack_first).then(|| vec![1]));
}
}
#[tokio::test]
async fn exchange_rejects_unexpected_acknowledgements() {
let cancel = CancellationToken::new();
let mut sink = tokio::io::sink();
let mut reply = &[0, 0, 0, 1, 1u8][..];
assert_eq!(
exchange(&mut sink, &mut reply, encode(1, &["query"]).unwrap(), &cancel).await.unwrap(),
Some(vec![1])
);
for cancelled in [false, true] {
if cancelled {
cancel.cancel();
}
let mut duplicate_ack = &[0u8; 8][..];
assert!(exchange(&mut sink, &mut duplicate_ack, encode(1, &["query"]).unwrap(), &cancel).await.is_err());
}
let (mut peer, mut output) = tokio::io::duplex(4);
peer.write_u32(0).await.unwrap();
let error = exchange(&mut sink, &mut output, encode(1, &["query"]).unwrap(), &cancel).await.unwrap_err();
assert_eq!(error.message, cancel_timeout().message);
}
#[test]
fn result_codec_preserves_null_and_rejects_incomplete_frames() {
let mut frame =
vec![1, 0, 0, 0, 1, 0, 0, 0, 1, b'n', 0, 0, 0, 3, b'i', b'n', b't', 1, 255, 255, 255, 255, 0, 0];
frame.extend_from_slice(&(-1i64).to_be_bytes());
let result = decode(&frame, "select", 0.).unwrap();
assert_eq!(result.columns[0].name, "n");
assert_eq!(result.rows, [vec![None]]);
for end in 0..frame.len() {
assert!(decode(&frame[..end], "", 0.).is_err());
}
frame.push(0);
assert!(decode(&frame, "", 0.).is_err());
assert!(decode(&[2], "", 0.).is_err());
}
}
+11 -93
Переглянути файл
@@ -4,8 +4,6 @@
pub mod catalog;
mod clickhouse;
mod jdbc;
pub use jdbc::{DbJdbcDriver, jdbc_driver_classes};
pub mod conn;
pub mod history;
mod oracle;
@@ -341,7 +339,7 @@ fn group_foreign_keys(rows: Vec<Vec<Option<String>>>, tables: &[CompletionTable]
/// never contain `:`.
/// Snowflake is HTTPS to a named host: a tunnel's local end cannot pass its certificate check.
fn tunneled(driver: DbDriver) -> bool {
!matches!(driver, DbDriver::Sqlite | DbDriver::Snowflake | DbDriver::Jdbc)
!matches!(driver, DbDriver::Sqlite | DbDriver::Snowflake)
}
/// The database host and port the SSH host forwards to.
@@ -761,7 +759,7 @@ impl DbManager {
};
let (target, tunnel) = self.endpoint(source, ssh_secret, false).await?;
self.restore_sso(source).await;
let connected = self.open_pool(&target, password.as_deref(), true).await;
let connected = Pool::connect(&target, password.as_deref(), Some(&self.root)).await;
self.keep_sso(source).await;
let pool = connected.map_err(|e| {
through_tunnel(
@@ -770,13 +768,7 @@ impl DbManager {
tunnel.is_some().then(|| self.ssh_label(source.ssh.as_ref().expect("tunneled"))).as_deref(),
)
})?;
if let Pool::Jdbc(p) = &pool {
let version = p.version.clone();
pool.close().await;
return Ok(version);
}
let version = match source.driver {
DbDriver::Jdbc => unreachable!("JDBC uses driver metadata"),
DbDriver::Sqlite => "SELECT 'SQLite ' || sqlite_version()",
DbDriver::Postgres | DbDriver::Clickhouse => "SELECT version()",
DbDriver::Mysql => "SELECT CONCAT(@@version_comment, ' ', VERSION())",
@@ -869,7 +861,7 @@ impl DbManager {
let password = self.password(&source).await;
let (target, tunnel) = self.endpoint(&source, None, true).await?;
self.restore_sso(&source).await;
let connected = self.open_pool(&target, password.as_deref(), false).await;
let connected = Pool::connect(&target, password.as_deref(), Some(&self.root)).await;
self.keep_sso(&source).await;
let pool = match connected {
Ok(p) => Arc::new(p),
@@ -924,37 +916,6 @@ impl DbManager {
self.tunnels.lock().remove(id);
}
/// Creates a database on the server of data source `id` by running `statement` on the data
/// source's own database, after closing the IDE's connections to `template`, the database
/// the server copies (PostgreSQL and SQL Server refuse to copy one that has sessions).
pub async fn create_database(&self, id: &str, template: &str, statement: &str) -> IdeResult<()> {
let id = split_target(id).0;
if self.source(id)?.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
self.disconnect(&format!("{id}:{template}")).await;
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
self.remember_statement(id, statement);
Ok(())
}
/// Drops `database` of the server of data source `id` by running `statement` on the data
/// source's own database, after closing the IDE's connections to `database`.
/// Refuses the database the data source connects to and read-only data sources.
pub async fn drop_database(&self, id: &str, database: &str, statement: &str) -> IdeResult<()> {
let id = split_target(id).0;
if self.source(id)?.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
if self.databases(id).await?.current == database {
return Err(IdeError::invalid(format!("the data source connects to {database}; it cannot drop it")));
}
self.disconnect(&format!("{id}:{database}")).await;
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
self.remember_statement(id, statement);
Ok(())
}
/// The databases of the server of data source `id` (PostgreSQL), the connected one first.
pub async fn databases(&self, id: &str) -> IdeResult<Databases> {
let id = split_target(id).0;
@@ -1079,10 +1040,7 @@ impl DbManager {
if let Pool::Snowflake(p) = &*pool {
return snowflake::meta::schemas(p, system).await;
}
let rows = match &*pool {
Pool::Jdbc(p) => p.metadata(&["schemas"]).await?,
_ => pool.rows(sql::schemas(pool.driver(), system), MAX_META_ROWS).await?,
};
let rows = pool.rows(sql::schemas(pool.driver(), system), MAX_META_ROWS).await?;
Ok(rows.into_iter().filter_map(|r| r.into_iter().next().flatten()).collect())
}
@@ -1091,10 +1049,7 @@ impl DbManager {
if let Pool::Snowflake(p) = &*pool {
return snowflake::meta::tables(p, schema).await;
}
let rows = match &*pool {
Pool::Jdbc(p) => p.metadata(&["tables", schema]).await?,
_ => pool.rows(&sql::tables(pool.driver(), schema), MAX_META_ROWS).await?,
};
let rows = pool.rows(&sql::tables(pool.driver(), schema), MAX_META_ROWS).await?;
Ok(rows
.into_iter()
.filter_map(|r| {
@@ -1111,11 +1066,9 @@ impl DbManager {
return snowflake::meta::table_details(p, schema, table).await;
}
let driver = pool.driver();
let rows = match &*pool {
Pool::Jdbc(p) => p.metadata(&["columns", schema, table]).await?,
_ => pool.rows(&sql::columns(driver, schema, table), MAX_META_ROWS).await?,
};
let columns = rows
let columns = pool
.rows(&sql::columns(driver, schema, table), MAX_META_ROWS)
.await?
.into_iter()
.filter_map(|r| {
let mut it = r.into_iter();
@@ -1127,9 +1080,6 @@ impl DbManager {
Some(ColumnInfo { name, data_type, nullable, default, primary_key })
})
.collect();
if driver == DbDriver::Jdbc {
return Ok(TableDetails { columns, indexes: vec![], foreign_keys: vec![], triggers: vec![] });
}
let mut indexes: Vec<IndexInfo> = Vec::new();
for r in pool.rows(&sql::indexes(driver, schema, table), MAX_META_ROWS).await? {
let mut it = r.into_iter();
@@ -1290,7 +1240,6 @@ impl DbManager {
rows.into_iter().filter_map(|r| r.into_iter().nth(i).flatten()).collect()
};
match driver {
DbDriver::Jdbc => Err(IdeError::invalid("Custom JDBC sources do not provide vendor-specific DDL")),
DbDriver::Sqlite => {
let stmts = cells(pool.rows(&sql::sqlite_ddl(schema, name), MAX_META_ROWS).await?, 0);
if stmts.is_empty() {
@@ -1415,7 +1364,6 @@ impl DbManager {
let driver = pool.driver();
let mut tables: Vec<CompletionTable> = Vec::new();
let rows = match &*pool {
Pool::Jdbc(p) => return self.jdbc_completion(id, p).await,
Pool::Snowflake(p) => {
tables = snowflake::meta::completion(p).await?;
Vec::new()
@@ -1536,9 +1484,6 @@ impl DbManager {
schema: Option<&str>,
) -> IdeResult<Vec<PlanNode>> {
let driver = self.pool(id).await?.driver();
if driver == DbDriver::Jdbc {
return Err(IdeError::invalid("Custom JDBC execution plans are unsupported"));
}
if driver == DbDriver::Oracle {
// EXPLAIN PLAN writes PLAN_TABLE; the plan is read (and cleaned up) separately.
let plan_id = format!(
@@ -1578,9 +1523,6 @@ impl DbManager {
schema: Option<&str>,
) -> IdeResult<QueryResult> {
let pool = self.pool(id).await?;
if let Pool::Jdbc(p) = &*pool {
return p.query_in_schema(statement, skip, max_rows, cancel, schema).await;
}
let session = self.sessions.lock().get(id).cloned();
let Some(session) = session else {
if schema.is_none() {
@@ -1622,9 +1564,6 @@ impl DbManager {
/// Switches `id` between auto-commit and manual commit. Leaving manual
/// mode rolls back what was not committed.
pub async fn set_manual_commit(&self, id: &str, manual: bool) -> IdeResult<()> {
if manual && self.source(id)?.driver == DbDriver::Jdbc {
return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported"));
}
if manual {
if self.source(id)?.driver == DbDriver::Clickhouse {
return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
@@ -1644,9 +1583,6 @@ impl DbManager {
if self.source(id).is_ok_and(|s| s.driver == DbDriver::Clickhouse) {
return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
}
if self.source(id).is_ok_and(|s| s.driver == DbDriver::Jdbc) {
return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported"));
}
let session = self.sessions.lock().get(id).cloned();
let Some(session) = session else { return Ok(()) };
let mut held = session.lock().await;
@@ -1682,22 +1618,8 @@ impl DbManager {
) -> IdeResult<TablePage> {
let details = self.table_details(id, schema, table).await?;
let pool = self.pool(id).await?;
let mut result = if let Pool::Jdbc(p) = &*pool {
let q = &p.identifier_quote;
let names = [schema, table].into_iter().chain(sort.iter().map(|k| k.column.as_str()));
if q.is_empty()
&& names.into_iter().any(|name| !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'))
{
return Err(IdeError::invalid("This JDBC driver cannot quote the selected identifier"));
}
let quote = |s: &str| format!("{q}{}{q}", s.replace(q, &format!("{q}{q}")));
let name = if schema.is_empty() { quote(table) } else { format!("{}.{}", quote(schema), quote(table)) };
let sql = sql::table_select(&name, filter, sort, quote);
p.page(&sql, offset, limit, cancel).await?
} else {
let sql = sql::table_page(pool.driver(), schema, table, filter, sort, offset, limit);
pool.execute(&sql, limit as usize, cancel).await?
};
let sql = sql::table_page(pool.driver(), schema, table, filter, sort, offset, limit);
let mut result = pool.execute(&sql, limit as usize, cancel).await?;
if result.columns.is_empty() {
result.columns = details
.columns
@@ -1710,11 +1632,7 @@ impl DbManager {
/// Applies the table editor's pending changes in one transaction.
pub async fn apply_edits(&self, id: &str, schema: &str, table: &str, edits: &[DbRowEdit]) -> IdeResult<u64> {
let source = self.source(id)?;
if source.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
if source.driver == DbDriver::Clickhouse {
if self.source(id)?.driver == DbDriver::Clickhouse {
return Err(IdeError::invalid("ClickHouse table editing is unsupported"));
}
let pool = self.pool(id).await?;
+1 -2
Переглянути файл
@@ -36,7 +36,7 @@ pub fn explain_statement(driver: DbDriver, statement: &str) -> String {
DbDriver::Sqlite => format!("EXPLAIN QUERY PLAN {s}"),
DbDriver::Postgres => format!("EXPLAIN (FORMAT JSON) {s}"),
DbDriver::Clickhouse => format!("EXPLAIN json = 1 {s}"),
DbDriver::Mysql | DbDriver::Jdbc => format!("EXPLAIN {s}"),
DbDriver::Mysql => format!("EXPLAIN {s}"),
DbDriver::SqlServer => format!("SET SHOWPLAN_TEXT ON; {s}"),
DbDriver::Oracle => format!("EXPLAIN PLAN FOR {s}"),
DbDriver::Snowflake => format!("EXPLAIN USING TABULAR {s}"),
@@ -77,7 +77,6 @@ pub fn parse(driver: DbDriver, result: &QueryResult) -> IdeResult<Vec<PlanNode>>
let names: Vec<&str> = result.columns.iter().map(|c| c.name.as_str()).collect();
Ok(mysql(&names, &result.rows))
}
DbDriver::Jdbc => Err(IdeError::invalid("Custom JDBC execution plans are unsupported")),
DbDriver::SqlServer => Ok(Vec::new()),
DbDriver::Snowflake => {
let names: Vec<&str> = result.columns.iter().map(|c| c.name.as_str()).collect();
+3 -18
Переглянути файл
@@ -23,13 +23,12 @@ pub enum DbDriver {
/// Oracle Database (pure-Rust thin driver, no client library).
Oracle,
Snowflake,
Jdbc,
}
impl DbDriver {
pub fn default_port(self) -> Option<u16> {
match self {
DbDriver::Sqlite | DbDriver::Jdbc => None,
DbDriver::Sqlite => None,
DbDriver::Postgres => Some(5432),
DbDriver::Mysql => Some(3306),
DbDriver::SqlServer => Some(1433),
@@ -192,9 +191,6 @@ pub struct DataSource {
pub id: String,
pub name: String,
pub driver: DbDriver,
/// An app-wide driver profile id; classpaths never come from a project.
#[serde(skip_serializing_if = "String::is_empty")]
pub jdbc_driver: String,
pub host: String,
pub port: Option<u16>,
pub database: String,
@@ -241,7 +237,6 @@ impl Default for DataSource {
id: String::new(),
name: String::new(),
driver: DbDriver::Sqlite,
jdbc_driver: String::new(),
host: "localhost".into(),
port: None,
database: String::new(),
@@ -395,12 +390,6 @@ impl DataSource {
/// database, user, SSL and driver properties come from the URL (properties
/// of the Advanced tab still apply after the URL's).
pub fn resolved(&self) -> IdeResult<DataSource> {
if self.driver == DbDriver::Jdbc {
if !self.url.starts_with("jdbc:") {
return Err(IdeError::invalid("Enter a JDBC URL starting with jdbc:"));
}
return Ok(self.clone());
}
if !self.url_only {
return Ok(self.clone());
}
@@ -487,7 +476,7 @@ impl DataSource {
/// The password written in the URL of a [`DataSource::url_only`] data source.
pub fn url_password(&self) -> Option<String> {
if self.driver == DbDriver::Jdbc || !self.url_only {
if !self.url_only {
return None;
}
parse_url(&self.url).ok()?.password
@@ -502,11 +491,7 @@ struct SourcesFile {
/// The project's data sources.
pub fn load(root: &Path) -> IdeResult<Vec<DataSource>> {
let mut sources = read(&project_dir::path(root, FILE))?;
for source in &mut sources {
source.global = false;
}
Ok(sources)
read(&project_dir::path(root, FILE))
}
/// Saves the project's data sources.
+15 -34
Переглянути файл
@@ -70,7 +70,6 @@ pub fn sqlserver_databases() -> &'static str {
pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Sqlite => "SELECT name FROM pragma_database_list WHERE name <> 'temp' ORDER BY seq",
DbDriver::Clickhouse if system => "SELECT name FROM system.databases ORDER BY name",
DbDriver::Clickhouse => {
@@ -115,7 +114,6 @@ pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
/// Rows: `name, kind` where kind is `table`, `view` or `materialized view`.
pub fn tables(driver: DbDriver, schema: &str) -> String {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => format!(
"SELECT name, CASE engine WHEN 'View' THEN 'view' WHEN 'MaterializedView' THEN 'materialized view' \
WHEN 'WindowView' THEN 'view' ELSE 'table' END FROM system.tables \
@@ -166,7 +164,6 @@ const SNOWFLAKE_TYPE: &str = "CASE WHEN data_type = 'NUMBER' THEN 'NUMBER(' || n
pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => format!(
"SELECT name, type, CASE WHEN startsWith(type, 'Nullable(') \
OR startsWith(type, 'LowCardinality(Nullable(') THEN 'YES' ELSE 'NO' END, \
@@ -228,7 +225,6 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => format!(
"SELECT * FROM (SELECT 'PRIMARY KEY' AS index_name, 0 AS is_unique, primary_key AS expression \
FROM system.tables WHERE database = {s} AND name = {t} AND primary_key != '' \
@@ -273,7 +269,6 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
/// for SQL completion, grouped by table in column order.
pub fn completion_columns(driver: DbDriver) -> &'static str {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => {
"SELECT c.database, c.table, CASE t.engine WHEN 'View' THEN 'view' \
WHEN 'MaterializedView' THEN 'materialized view' WHEN 'WindowView' THEN 'view' ELSE 'table' END, \
@@ -362,7 +357,6 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
/// when the key references the primary key implicitly.
pub fn foreign_keys(driver: DbDriver) -> &'static str {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => "SELECT '', '', '', '', '', '', '' WHERE 0",
DbDriver::Snowflake => "SELECT '', '', '', '', '', '', '' WHERE 1 = 0",
DbDriver::Sqlite => {
@@ -415,7 +409,6 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse | DbDriver::Snowflake => foreign_keys(driver).to_owned(),
DbDriver::Sqlite => format!(
"SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
@@ -439,7 +432,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
match driver {
DbDriver::Clickhouse => Some("SELECT currentDatabase()"),
DbDriver::Sqlite | DbDriver::Jdbc => None,
DbDriver::Sqlite => None,
DbDriver::Postgres => Some("SELECT current_schema()"),
DbDriver::Mysql => Some("SELECT DATABASE()"),
DbDriver::SqlServer => Some("SELECT DB_NAME()"),
@@ -453,7 +446,7 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
match driver {
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
DbDriver::Sqlite | DbDriver::Clickhouse => None,
DbDriver::Postgres => Some(format!("SET search_path TO {}", quote_ident(driver, schema))),
DbDriver::Mysql | DbDriver::SqlServer => Some(format!("USE {}", quote_ident(driver, schema))),
DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
@@ -469,13 +462,17 @@ pub struct SortKey {
pub descending: bool,
}
pub(crate) fn table_select(
qualified_name: &str,
/// One page of a table: `limit + 1` rows so the caller knows whether more exist.
pub fn table_page(
driver: DbDriver,
schema: &str,
table: &str,
filter: Option<&str>,
sort: &[SortKey],
quote: impl Fn(&str) -> String,
offset: u64,
limit: u64,
) -> String {
let mut sql = format!("SELECT * FROM {}", qualified_name);
let mut sql = format!("SELECT * FROM {}", qualified(driver, schema, table));
if let Some(f) = filter.map(str::trim).filter(|f| !f.is_empty()) {
let mut f = f.strip_prefix("WHERE ").or_else(|| f.strip_prefix("where ")).unwrap_or(f);
if let Some(i) = f.find(';') {
@@ -487,24 +484,12 @@ pub(crate) fn table_select(
}
}
if !sort.is_empty() {
let keys: Vec<String> =
sort.iter().map(|k| format!("{}{}", quote(&k.column), if k.descending { " DESC" } else { "" })).collect();
let keys: Vec<String> = sort
.iter()
.map(|k| format!("{}{}", quote_ident(driver, &k.column), if k.descending { " DESC" } else { "" }))
.collect();
sql.push_str(&format!(" ORDER BY {}", keys.join(", ")));
}
sql
}
/// One page of a table: `limit + 1` rows so the caller knows whether more exist.
pub fn table_page(
driver: DbDriver,
schema: &str,
table: &str,
filter: Option<&str>,
sort: &[SortKey],
offset: u64,
limit: u64,
) -> String {
let mut sql = table_select(&qualified(driver, schema, table), filter, sort, |name| quote_ident(driver, name));
if driver == DbDriver::SqlServer {
if sort.is_empty() {
sql.push_str(" ORDER BY (SELECT 1)");
@@ -550,9 +535,6 @@ fn where_key(driver: DbDriver, key: &[CellValue]) -> String {
/// The DML statement for `edit`. Values are written as quoted literals, which
/// every supported database coerces to the column type.
pub fn edit_statement(driver: DbDriver, schema: &str, table: &str, edit: &DbRowEdit) -> Result<String, String> {
if driver == DbDriver::Jdbc {
return Err("Custom JDBC table editing is unsupported".into());
}
if driver == DbDriver::Clickhouse {
return Err("ClickHouse table editing is unsupported: primary keys do not uniquely identify rows and edits require transactions".into());
}
@@ -649,7 +631,6 @@ pub fn postgres_ddl_indexes(oid: u32) -> String {
pub fn triggers(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => "SELECT '', '', '' WHERE 0".to_owned(),
DbDriver::Snowflake => "SELECT '', '', '' WHERE 1 = 0".to_owned(),
DbDriver::Sqlite => format!(
@@ -710,7 +691,7 @@ pub fn postgres_legacy(sql: &str) -> Option<String> {
pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
let s = quote_literal(driver, schema);
match driver {
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
DbDriver::Sqlite | DbDriver::Clickhouse => None,
// Functions of extensions are left out, as in IDEA.
DbDriver::Postgres => Some(format!(
"SELECT p.proname, CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END, \
-215
Переглянути файл
@@ -1,215 +0,0 @@
use ide_core::{CancellationToken, IdeResult};
use ide_db::{DataSource, DbDriver, DbJdbcDriver, DbManager, SortKey};
use std::{path::Path, sync::Arc};
fn manager(dir: &Path) -> DbManager {
let ssh = Arc::new(ide_ssh::SshManager::new(dir.join("ssh.json")));
DbManager::new(dir.join("project"), dir.join("passwords.json"), dir.join("history.json"), ssh)
.with_global_sources(dir.join("global"))
}
#[tokio::test]
async fn jdbc_profiles_persist_and_project_files_cannot_start_drivers() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let jar = tmp.path().join("fixture.jar");
std::fs::write(&jar, [])?;
let db = manager(tmp.path());
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Test".into(),
jars: vec![jar.display().to_string()],
class_name: "test.Driver".into(),
url_template: "jdbc:test:".into(),
})?;
let reopened = manager(tmp.path());
assert_eq!(reopened.jdbc_drivers()?[0].class_name, "test.Driver");
let source = DataSource {
id: "local".into(),
name: "local".into(),
driver: DbDriver::Jdbc,
jdbc_driver: "fixture".into(),
url: "jdbc:test:".into(),
..Default::default()
};
reopened.save_sources(vec![source.clone()]).await?;
let denied = reopened.pool("local").await.err().expect("project JDBC requires explicit approval");
assert!(denied.message.contains("Review this project"));
let readonly = DataSource { read_only: true, ..source.clone() };
reopened.save_sources(vec![readonly]).await?;
let err = reopened.apply_edits("local", "main", "sample", &[]).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::PermissionDenied);
reopened.approve_jdbc_source(&source)?;
let mut changed = source.clone();
changed.url.push_str("changed");
reopened.save_sources(vec![changed]).await?;
assert!(reopened.pool("local").await.err().unwrap().message.contains("Review this project"));
let mut global = source;
global.global = true;
reopened.save_sources(vec![global]).await?;
assert!(reopened.remove_jdbc_driver("fixture").is_err());
reopened.save_sources(vec![]).await?;
reopened.remove_jdbc_driver("fixture")?;
assert!(manager(tmp.path()).jdbc_drivers()?.is_empty());
Ok(())
}
#[tokio::test]
#[ignore = "requires DUCKDB_JDBC_JAR and a local Java 17+ runtime"]
async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let jar = std::env::var("DUCKDB_JDBC_JAR").expect("DUCKDB_JDBC_JAR");
assert_eq!(ide_db::jdbc_driver_classes(std::slice::from_ref(&jar))?, ["org.duckdb.DuckDBDriver"]);
db.save_jdbc_driver(DbJdbcDriver {
id: "duck".into(),
name: "DuckDB".into(),
jars: vec![jar],
class_name: "org.duckdb.DuckDBDriver".into(),
url_template: "jdbc:duckdb:".into(),
})?;
let source = DataSource {
id: "test".into(),
name: "DuckDB".into(),
driver: DbDriver::Jdbc,
global: true,
jdbc_driver: "duck".into(),
url: "jdbc:duckdb:local.duckdb".into(),
..Default::default()
};
assert!(db.test(&source, None, None).await?.to_lowercase().contains("duckdb"));
db.save_sources(vec![source]).await?;
let db = manager(tmp.path());
let c = CancellationToken::new();
db.execute("test", "create table items(id int primary key, label varchar)", 1, &c).await?;
db.execute("test", "insert into items values (1, NULL), (2, 'row')", 1, &c).await?;
assert!(db.schemas("test").await?.iter().any(|v| v == "main"));
assert!(db.tables("test", "main").await?.iter().any(|v| v.name == "items"));
let details = db.table_details("test", "main", "items").await?;
assert_eq!(details.columns.len(), 2);
let result = db.execute("test", "select id, label from items order by id", 1, &c).await?;
assert!(result.has_more);
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
assert_eq!(result.columns[1].name, "label");
assert_eq!(db.completion("test").await?.default_schema, "main");
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
let stop = CancellationToken::new();
let (cancelled, ()) =
tokio::join!(db.execute("test", "select sum(sin(i)) from range(1000000000) t(i)", 1, &stop), async {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
stop.cancel();
},);
assert_eq!(cancelled.unwrap_err().kind, ide_core::error::ErrorKind::Cancelled);
let marker = db.execute("test", "select id from session_marker", 1, &c).await?;
assert_eq!(marker.rows, [vec![Some("42".into())]]);
let sort = [SortKey { column: "id".into(), descending: false }];
let first = db.table_page("test", "main", "items", None, &sort, 0, 1, &c).await?.result;
assert_eq!(first.rows, result.rows);
assert!(first.has_more);
let last = db.table_page("test", "main", "items", None, &sort, 1, 1, &c).await?.result;
assert_eq!(last.rows, vec![vec![Some("2".into()), Some("row".into())]]);
assert!(!last.has_more);
let past = db.table_page("test", "main", "items", None, &sort, 2, 1, &c).await?.result;
assert!(past.rows.is_empty() && !past.has_more);
db.disconnect("test").await;
let reopened = manager(tmp.path());
assert_eq!(reopened.execute("test", "select count(*) from items", 1, &c).await?.rows, [vec![Some("2".into())]]);
reopened.disconnect("test").await;
Ok(())
}
#[tokio::test]
#[ignore = "requires CLICKHOUSE_JDBC_CLASSPATH and a loopback ClickHouse fixture on CLICKHOUSE_JDBC_TEST_PORT"]
async fn clickhouse_vendor_driver_reads_catalog_and_results() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let jars: Vec<String> =
std::env::split_paths(&std::env::var_os("CLICKHOUSE_JDBC_CLASSPATH").expect("CLICKHOUSE_JDBC_CLASSPATH"))
.map(|p| p.display().to_string())
.collect();
let classes = ide_db::jdbc_driver_classes(&jars)?;
assert_eq!(classes.first().map(String::as_str), Some("com.clickhouse.jdbc.ClickHouseDriver"));
let port: u16 = std::env::var("CLICKHOUSE_JDBC_TEST_PORT").unwrap().parse().unwrap();
db.save_jdbc_driver(DbJdbcDriver {
id: "clickhouse".into(),
name: "ClickHouse JDBC".into(),
jars,
class_name: "com.clickhouse.jdbc.ClickHouseDriver".into(),
url_template: "jdbc:clickhouse://".into(),
})?;
let source = DataSource {
id: "test".into(),
name: "ClickHouse JDBC".into(),
driver: DbDriver::Jdbc,
jdbc_driver: "clickhouse".into(),
url: format!("jdbc:clickhouse://127.0.0.1:{port}/default"),
user: "fixture".into(),
read_only: true,
..Default::default()
};
let password = "local-fixture";
assert!(db.test(&source, Some(password.into()), None).await?.contains("ClickHouse"));
db.approve_jdbc_source(&source)?;
db.save_sources(vec![source]).await?;
db.set_password("test", Some(password.into()), false).await?;
assert!(db.schemas("test").await?.iter().any(|v| v == "system"));
assert!(db.tables("test", "system").await?.iter().any(|v| v.name == "one"));
let cols = db.table_details("test", "system", "one").await?.columns;
assert!(cols.iter().any(|col| col.name == "dummy"));
let r = db.execute("test", "SELECT number FROM numbers(3) ORDER BY number", 2, &CancellationToken::new()).await?;
assert_eq!(r.rows.len(), 2);
assert!(r.has_more);
let c = CancellationToken::new();
let page = db.table_page("test", "system", "one", None, &[], 0, 1, &c).await?.result;
assert_eq!(page.rows.len(), 1);
assert!(!page.has_more);
let past = db.table_page("test", "system", "one", None, &[], 1, 1, &c).await?.result;
assert!(past.rows.is_empty() && !past.has_more);
db.disconnect("test").await;
Ok(())
}
#[tokio::test]
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
use std::time::Duration;
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let started = tmp.path().join("started");
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Fixture".into(),
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
url_template: String::new(),
})?;
let source = DataSource {
id: "test".into(),
name: "Fixture".into(),
driver: DbDriver::Jdbc,
global: true,
read_only: true,
jdbc_driver: "fixture".into(),
url: format!("jdbc:fixture:{}", started.display()),
..Default::default()
};
db.test(&source, None, None).await?;
db.save_sources(vec![source]).await?;
let normal = CancellationToken::new();
assert!(db.execute("test", "write", 1, &normal).await.unwrap_err().message.contains("read-only"));
let stop = CancellationToken::new();
let (result, ()) = tokio::time::timeout(Duration::from_secs(12), async {
tokio::join!(db.execute("test", "ignore cancel", 1, &stop), async {
while !started.is_file() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
stop.cancel();
})
})
.await
.expect("driver cancellation must be bounded");
assert!(result.unwrap_err().message.contains("Reconnect"));
db.disconnect("test").await;
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
db.disconnect("test").await;
Ok(())
}
-38
Переглянути файл
@@ -230,44 +230,6 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
}
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
#[tokio::test]
async fn drops_a_database_the_ide_holds_connections_to() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_drop_me", 0, &c).await?;
db.execute("p", "CREATE DATABASE oi_drop_me TEMPLATE template0", 0, &c).await?;
// What the tree and a manual-commit console leave open on the database.
db.schemas("p:oi_drop_me").await?;
db.set_manual_commit("p:oi_drop_me", true).await?;
db.execute("p:oi_drop_me", "SELECT 1", 1, &c).await?;
db.drop_database("p", "oi_drop_me", "drop database oi_drop_me").await?;
assert!(!db.is_connected("p:oi_drop_me"));
assert!(!db.databases("p").await?.names.iter().any(|n| n == "oi_drop_me"));
let current = db.databases("p").await?.current;
let refused = db.drop_database("p", &current, &format!("drop database \"{current}\"")).await;
assert!(refused.is_err());
Ok(())
}
#[tokio::test]
async fn creates_a_database_from_a_template_the_ide_holds_connections_to() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_from_template", 0, &c).await?;
db.schemas("p:template1").await?;
db.create_database("p", "template1", "create database oi_from_template").await?;
assert!(!db.is_connected("p:template1"));
assert!(db.databases("p").await?.names.iter().any(|n| n == "oi_from_template"));
db.execute("p", "DROP DATABASE oi_from_template", 0, &c).await?;
Ok(())
}
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
let mut lines = Vec::new();
-41
Переглянути файл
@@ -95,44 +95,3 @@ async fn sqlserver_values_paging_transactions_and_cancellation() {
task.await.unwrap();
assert_eq!(pool.rows("SELECT 1", 1).await.unwrap()[0][0].as_deref(), Some("1"));
}
#[tokio::test]
async fn sqlserver_creates_from_a_held_model_and_force_drops_a_held_database() {
let Ok(server) = std::env::var("OPENIDEA_TEST_SQLSERVER") else { return };
let mut parts = server.splitn(4, ':');
let (host, port, user, password) = (
parts.next().unwrap(),
parts.next().unwrap().parse().unwrap(),
parts.next().unwrap(),
parts.next().unwrap_or(""),
);
let source = |database: &str| DataSource {
id: "s".into(),
name: "sqlserver".into(),
driver: DbDriver::SqlServer,
host: host.into(),
port: Some(port),
user: user.into(),
database: database.into(),
ssl: DbSslMode::Disable,
..Default::default()
};
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().to_path_buf();
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
let db = ide_db::DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);
db.save_sources(vec![source("master")]).await.unwrap();
db.set_password("s", Some(password.into()), false).await.unwrap();
let name = format!("oi_force_drop_{}", std::process::id());
// The tree's connection to `model` would keep SQL Server from copying it.
db.schemas("s:model").await.unwrap();
db.create_database("s", "model", &format!("create database {name};")).await.unwrap();
assert!(!db.is_connected("s:model"));
let other = Pool::connect(&source(&name), Some(password), None).await.unwrap();
let held = Held::acquire(&other).await.unwrap();
let force = format!("alter database {name} set single_user with rollback immediate;\ndrop database {name};");
db.drop_database("s", &name, &force).await.unwrap();
assert!(!db.databases("s").await.unwrap().names.contains(&name));
drop(held);
}
File diff suppressed because it is too large. Load diff
-26
Переглянути файл
@@ -5,7 +5,6 @@
//! Every function blocks; callers run them off the UI / command threads.
mod connection;
mod engine;
mod model;
mod process;
@@ -115,11 +114,6 @@ fn failure(args: &[&str], stderr: &str, stdout: &str) -> IdeError {
/// Whether docker can be used right now.
pub fn availability(ep: &DockerEndpoint) -> DockerAvailability {
if docker_executable().is_none()
&& let Some(available) = engine::availability(ep, Duration::from_secs(15))
{
return available;
}
let Ok(cmd) = command(ep, &["version", "--format", "{{json .}}"]) else {
return DockerAvailability::NotInstalled;
};
@@ -131,11 +125,6 @@ pub fn availability(ep: &DockerEndpoint) -> DockerAvailability {
/// Availability plus containers, images, volumes and networks (listed in parallel).
pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
if docker_executable().is_none()
&& let Some(listed) = engine::snapshot(ep, QUICK)
{
return listed;
}
let availability = availability(ep);
let executable = docker_executable().map(|p| ide_core::ipc_path::to_ipc(&p));
let mut snap = DockerSnapshot {
@@ -213,11 +202,6 @@ pub fn container_op(ep: &DockerEndpoint, ids: &[String], op: ContainerOp) -> Ide
if ids.is_empty() {
return Ok(());
}
if docker_executable().is_none()
&& let Some(ran) = engine::container_op(ep, ids, op, LIFECYCLE)
{
return ran;
}
let mut args = vec!["container", op.verb()];
args.extend(ids.iter().map(String::as_str));
run(ep, &args, LIFECYCLE).map(drop)
@@ -248,11 +232,6 @@ pub fn remove(ep: &DockerEndpoint, object: DockerObject, ids: &[String], force:
if ids.is_empty() {
return Ok(());
}
if docker_executable().is_none()
&& let Some(ran) = engine::remove(ep, object, ids, force, LIFECYCLE)
{
return ran;
}
let mut args = vec![object.noun(), "rm"];
if force && matches!(object, DockerObject::Container | DockerObject::Image | DockerObject::Volume) {
args.push("--force");
@@ -263,11 +242,6 @@ pub fn remove(ep: &DockerEndpoint, object: DockerObject, ids: &[String], force:
/// `docker inspect` of one object, pretty-printed.
pub fn inspect(ep: &DockerEndpoint, object: DockerObject, id: &str) -> IdeResult<String> {
if docker_executable().is_none()
&& let Some(inspected) = engine::inspect(ep, object, id, QUICK)
{
return inspected;
}
let out = run(ep, &["inspect", "--type", object.noun(), id], QUICK)?;
match serde_json::from_str::<serde_json::Value>(&out) {
// A one-element array for a single id: show the object itself.
+5 -5
Переглянути файл
@@ -211,10 +211,10 @@ pub fn parse_labels(raw: &str) -> BTreeMap<String, String> {
out
}
pub(crate) const COMPOSE_PROJECT: &str = "com.docker.compose.project";
pub(crate) const COMPOSE_SERVICE: &str = "com.docker.compose.service";
pub(crate) const COMPOSE_DIR: &str = "com.docker.compose.project.working_dir";
pub(crate) const COMPOSE_FILES: &str = "com.docker.compose.project.config_files";
const COMPOSE_PROJECT: &str = "com.docker.compose.project";
const COMPOSE_SERVICE: &str = "com.docker.compose.service";
const COMPOSE_DIR: &str = "com.docker.compose.project.working_dir";
const COMPOSE_FILES: &str = "com.docker.compose.project.config_files";
fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> + '_ {
text.lines().filter(|l| l.trim_start().starts_with('{')).filter_map(|l| match serde_json::from_str::<T>(l) {
@@ -253,7 +253,7 @@ struct RawContainer {
networks: String,
}
pub(crate) fn split_csv(raw: &str) -> Vec<String> {
fn split_csv(raw: &str) -> Vec<String> {
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
}
+1 -1
Переглянути файл
@@ -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.13.0";
pub const ENGINE_VERSION: &str = "1.11.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.
-15
Переглянути файл
@@ -1,15 +0,0 @@
[package]
name = "ide-flutter"
description = "Flutter devices, kept current by the `flutter daemon` protocol"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
ide-android = { path = "../ide-android" }
ide-core.workspace = true
parking_lot.workspace = true
serde_json.workspace = true
[dev-dependencies]
tempfile.workspace = true
-563
Переглянути файл
@@ -1,563 +0,0 @@
//! The devices a Flutter project can run on, from one `flutter daemon` per project window.
//!
//! The daemon speaks JSON-RPC over stdio, one bracketed message per line. After
//! `daemon.connected` it is asked for `device.enable`, which makes it report `device.added` /
//! `device.removed`, and once for `device.getDevices`, whose answer ends the "discovering" state.
//!
//! The daemon keeps running after its stdin closes, so closing the pipe does not end it: on Unix
//! a watcher in its process group ends the group once the IDE is gone, even after a crash. A
//! daemon that fails stays failed until the user restarts it.
use ide_android::AndroidDevice;
use ide_core::event::{FlutterDaemonStatus, FlutterDevice, FlutterDeviceList};
use ide_core::process::{kill_tree, own_group, prepare, terminate_tree};
use ide_core::tool_path::{find_command, search_path_in};
use ide_core::{IdeEvent, SharedSink};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::collections::{BTreeMap, VecDeque};
use std::io::{BufRead, BufReader, Read, Write};
use std::path::{Path, PathBuf};
use std::process::{Child, ChildStdin, Command, Stdio};
use std::sync::Arc;
use std::time::Duration;
const ENABLE: u64 = 1;
const GET_DEVICES: u64 = 2;
/// How long the daemon gets to exit on `SIGTERM`.
const KILL_GRACE: Duration = Duration::from_millis(200);
/// Lines of unrecognised output kept to explain a failure.
const OUTPUT_TAIL: usize = 8;
#[derive(Debug, PartialEq, Eq)]
enum Message {
Connected,
Added(FlutterDevice),
Removed(String),
Devices(Vec<FlutterDevice>),
Other,
}
fn device(value: &Value) -> Option<FlutterDevice> {
let text = |key| value.get(key).and_then(Value::as_str).map(str::to_owned);
Some(FlutterDevice {
id: text("id")?,
name: text("name")?,
platform_type: text("platformType"),
category: text("category"),
emulator: value.get("emulator").and_then(Value::as_bool).unwrap_or(false),
unavailable: None,
})
}
/// The messages of one stdout line; `None` for anything outside the protocol (the tool's own
/// chatter, such as waiting for the startup lock).
fn parse_line(line: &str) -> Option<Vec<Message>> {
let line = line.trim();
if !line.starts_with('[') {
return None;
}
let messages: Vec<Value> = serde_json::from_str(line).ok()?;
Some(messages.iter().map(parse_message).collect())
}
fn parse_message(message: &Value) -> Message {
let params = message.get("params").unwrap_or(&Value::Null);
match message.get("event").and_then(Value::as_str) {
Some("daemon.connected") => Message::Connected,
Some("device.added") => device(params).map_or(Message::Other, Message::Added),
Some("device.removed") => {
params.get("id").and_then(Value::as_str).map_or(Message::Other, |id| Message::Removed(id.to_owned()))
}
Some(_) => Message::Other,
None if message.get("id").and_then(Value::as_u64) == Some(GET_DEVICES) => {
let result = message.get("result").and_then(Value::as_array);
Message::Devices(result.into_iter().flatten().filter_map(device).collect())
}
None => Message::Other,
}
}
fn request(id: u64, method: &str) -> String {
format!("{}\n", json!([{ "id": id, "method": method }]))
}
/// The daemon's devices, plus the Android devices adb sees that Flutter leaves out until they
/// are usable. A daemon Android device's id is its adb serial.
fn merged(daemon: &BTreeMap<String, FlutterDevice>, adb: &[AndroidDevice]) -> Vec<FlutterDevice> {
let mut devices: Vec<FlutterDevice> = daemon.values().cloned().collect();
devices.extend(adb.iter().filter(|d| !d.is_online() && !daemon.contains_key(&d.serial)).map(|d| FlutterDevice {
id: d.serial.clone(),
name: d.label().replace('_', " "),
platform_type: Some("android".into()),
category: Some("mobile".into()),
emulator: d.serial.starts_with("emulator-"),
unavailable: Some(d.state.clone()),
}));
let rank = |d: &FlutterDevice| match d.category.as_deref() {
Some("mobile") => 0,
Some("desktop") => 1,
Some("web") => 2,
_ => 3,
};
devices.sort_by_cached_key(|d| (d.unavailable.is_some(), rank(d), d.emulator, d.name.to_lowercase(), d.id.clone()));
devices
}
struct Running {
child: Child,
stdin: Option<ChildStdin>,
}
#[derive(Default)]
struct State {
/// Bumped by every start and stop: a reader of an older process no longer has a say.
generation: u64,
running: Option<Running>,
status: FlutterDaemonStatus,
devices: BTreeMap<String, FlutterDevice>,
adb: Vec<AndroidDevice>,
}
impl State {
fn list(&self) -> FlutterDeviceList {
FlutterDeviceList { status: self.status.clone(), devices: merged(&self.devices, &self.adb) }
}
fn shut_down(&mut self) {
self.generation += 1;
if let Some(Running { mut child, stdin }) = self.running.take() {
drop(stdin);
// Off the caller's thread: closing a window must not wait for the grace period.
std::thread::spawn(move || terminate_tree(&mut child, KILL_GRACE));
}
}
}
struct Shared {
root: PathBuf,
sink: SharedSink,
/// Replaces the lookup on the search path (tests).
executable: Option<PathBuf>,
state: Mutex<State>,
}
impl Shared {
fn emit(&self, list: FlutterDeviceList) {
self.sink.emit(IdeEvent::FlutterDevices { list });
}
}
/// One project window's `flutter daemon`, started on first use.
pub struct FlutterDaemon(Arc<Shared>);
impl FlutterDaemon {
pub fn new(root: PathBuf, sink: SharedSink) -> Self {
Self::with_executable(root, sink, None)
}
fn with_executable(root: PathBuf, sink: SharedSink, executable: Option<PathBuf>) -> Self {
Self(Arc::new(Shared { root, sink, executable, state: Mutex::default() }))
}
/// The current list; starts the daemon unless it already ran. Never blocks on the process.
pub fn devices(&self) -> FlutterDeviceList {
let mut state = self.0.state.lock();
if state.status == FlutterDaemonStatus::Stopped {
start(&self.0, &mut state);
}
state.list()
}
/// Replaces the daemon with a new one (the user's way out of a failure).
pub fn restart(&self) -> FlutterDeviceList {
let mut state = self.0.state.lock();
state.shut_down();
start(&self.0, &mut state);
state.list()
}
/// Reads adb again: a device awaiting authorization changes no daemon event.
pub fn refresh(&self) {
let generation = self.0.state.lock().generation;
refresh_adb(&self.0, generation);
}
/// Ends the daemon (project closed, or no longer trusted).
pub fn stop(&self) {
let mut state = self.0.state.lock();
state.shut_down();
state.status = FlutterDaemonStatus::Stopped;
state.devices.clear();
state.adb.clear();
}
/// Ends the daemon before returning, for a process about to exit.
pub fn kill(&self) {
let mut state = self.0.state.lock();
state.generation += 1;
if let Some(mut running) = state.running.take() {
kill_tree(&mut running.child);
}
}
}
fn start(shared: &Arc<Shared>, state: &mut State) {
state.generation += 1;
state.status = FlutterDaemonStatus::Starting;
state.devices.clear();
state.adb.clear();
let (shared, generation) = (shared.clone(), state.generation);
std::thread::spawn(move || run(&shared, generation));
}
fn refresh_adb(shared: &Arc<Shared>, generation: u64) {
let shared = shared.clone();
std::thread::spawn(move || {
// Without adb there is simply nothing to add.
let adb = ide_android::devices().unwrap_or_default();
let mut state = shared.state.lock();
if state.generation != generation || state.adb == adb {
return;
}
state.adb = adb;
let list = state.list();
drop(state);
shared.emit(list);
});
}
/// `flutter daemon`, ended with its whole process group when process `parent` is gone.
#[cfg(unix)]
fn daemon_command(executable: &Path, parent: u32) -> Command {
const WATCHED: &str = r#"(while kill -0 "$1" 2>/dev/null; do sleep 5; done; kill -KILL 0) </dev/null >/dev/null 2>&1 &
exec "$2" daemon"#;
let mut cmd = Command::new("/bin/sh");
cmd.args(["-c", WATCHED, "sh"]).arg(parent.to_string()).arg(executable);
cmd
}
// No watcher on Windows, so a crashed IDE leaves the daemon; a Job Object would cover it.
#[cfg(not(unix))]
fn daemon_command(executable: &Path, _parent: u32) -> Command {
let mut cmd = Command::new(executable);
cmd.arg("daemon");
cmd
}
fn spawn_daemon(executable: &Path, root: &Path) -> std::io::Result<Child> {
let mut cmd = daemon_command(executable, std::process::id());
cmd.current_dir(root).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
prepare(own_group(&mut cmd));
cmd.spawn()
}
/// Sets the final status of a daemon that is gone, unless it was replaced or stopped meanwhile.
fn finish(shared: &Shared, generation: u64, status: FlutterDaemonStatus) {
let mut state = shared.state.lock();
if state.generation != generation {
return;
}
let running = state.running.take();
state.status = status;
let list = state.list();
drop(state);
if let Some(Running { mut child, .. }) = running {
std::thread::spawn(move || terminate_tree(&mut child, Duration::ZERO));
}
shared.emit(list);
}
fn keep_output(tail: &Mutex<VecDeque<String>>, line: &str) {
if line.trim().is_empty() {
return;
}
let mut tail = tail.lock();
if tail.len() == OUTPUT_TAIL {
tail.pop_front();
}
tail.push_back(line.trim_end().to_owned());
}
fn read_lines(pipe: impl Read, mut on_line: impl FnMut(&str) -> bool) {
let mut reader = BufReader::new(pipe);
let mut bytes = Vec::new();
loop {
bytes.clear();
match reader.read_until(b'\n', &mut bytes) {
Ok(0) | Err(_) => return,
Ok(_) if !on_line(&String::from_utf8_lossy(&bytes)) => return,
Ok(_) => {}
}
}
}
/// One daemon's whole life, on its own thread.
fn run(shared: &Arc<Shared>, generation: u64) {
let executable =
shared.executable.clone().or_else(|| find_command("flutter", &search_path_in(&shared.root), &shared.root));
let Some(executable) = executable else {
return finish(shared, generation, FlutterDaemonStatus::NotInstalled);
};
let mut child = match spawn_daemon(&executable, &shared.root) {
Ok(child) => child,
Err(e) => {
let message = format!("could not run {}: {e}", executable.display());
return finish(shared, generation, FlutterDaemonStatus::Failed { message });
}
};
let (Some(stdout), Some(stderr)) = (child.stdout.take(), child.stderr.take()) else {
return finish(shared, generation, FlutterDaemonStatus::Failed { message: "no output pipe".into() });
};
let stdin = child.stdin.take();
{
let mut state = shared.state.lock();
if state.generation != generation {
drop(state);
drop(stdin);
terminate_tree(&mut child, KILL_GRACE);
return;
}
state.running = Some(Running { child, stdin });
}
let tail = Arc::new(Mutex::new(VecDeque::new()));
let errors = {
let tail = tail.clone();
std::thread::spawn(move || {
read_lines(stderr, |line| {
keep_output(&tail, line);
true
});
})
};
read_lines(stdout, |line| match parse_line(line) {
Some(messages) => messages.into_iter().all(|message| handle(shared, generation, message)),
None => {
keep_output(&tail, line);
true
}
});
let _ = errors.join();
let message = Vec::from(std::mem::take(&mut *tail.lock())).join("\n");
let message = if message.is_empty() { "flutter daemon exited".to_owned() } else { message };
finish(shared, generation, FlutterDaemonStatus::Failed { message });
}
/// Applies one message; false once this daemon has been replaced or stopped.
fn handle(shared: &Arc<Shared>, generation: u64, message: Message) -> bool {
let mut state = shared.state.lock();
if state.generation != generation {
return false;
}
match message {
Message::Other => return true,
Message::Connected => {
if let Some(stdin) = state.running.as_mut().and_then(|r| r.stdin.as_mut()) {
let requests = request(ENABLE, "device.enable") + &request(GET_DEVICES, "device.getDevices");
let _ = stdin.write_all(requests.as_bytes()).and_then(|()| stdin.flush());
}
return true;
}
Message::Added(device) => {
state.devices.insert(device.id.clone(), device);
}
Message::Removed(id) => {
state.devices.remove(&id);
}
// Merged, not replaced: events may have overtaken this answer.
Message::Devices(devices) => {
state.devices.extend(devices.into_iter().map(|d| (d.id.clone(), d)));
state.status = FlutterDaemonStatus::Ready;
}
}
let list = state.list();
drop(state);
shared.emit(list);
refresh_adb(shared, generation);
true
}
#[cfg(test)]
mod tests {
use super::*;
fn dev(id: &str, name: &str, category: &str, emulator: bool) -> FlutterDevice {
FlutterDevice {
id: id.into(),
name: name.into(),
platform_type: None,
category: Some(category.into()),
emulator,
unavailable: None,
}
}
fn adb(serial: &str, state: &str) -> AndroidDevice {
AndroidDevice {
serial: serial.into(),
state: state.into(),
model: None,
product: None,
device: None,
transport_id: None,
}
}
#[test]
fn reads_the_daemon_protocol() {
assert_eq!(
parse_line(r#"[{"event":"daemon.connected","params":{"version":"0.6.1","pid":7}}]"#),
Some(vec![Message::Connected])
);
let added = parse_line(
r#"[{"event":"device.added","params":{"id":"emulator-5554","name":"Pixel","platform":"android-arm64",
"emulator":true,"category":"mobile","platformType":"android","ephemeral":true}}]"#
.replace('\n', " ")
.as_str(),
);
let Some([Message::Added(device)]) = added.as_deref() else { panic!("{added:?}") };
assert_eq!(device.id, "emulator-5554");
assert_eq!(device.platform_type.as_deref(), Some("android"));
assert!(device.emulator);
assert_eq!(
parse_line(r#"[{"event":"device.removed","params":{"id":"macos","name":"macOS"}}]"#),
Some(vec![Message::Removed("macos".into())])
);
let answer = parse_line(r#"[{"id":2,"result":[{"id":"chrome","name":"Chrome","category":null}]}]"#);
let Some([Message::Devices(devices)]) = answer.as_deref() else { panic!("{answer:?}") };
assert_eq!((devices[0].id.as_str(), devices[0].category.as_deref()), ("chrome", None));
assert_eq!(parse_line(r#"[{"id":1,"result":null}]"#), Some(vec![Message::Other]));
}
#[test]
fn output_outside_the_protocol_is_not_a_message() {
assert_eq!(parse_line("Waiting for another flutter command to release the startup lock..."), None);
assert_eq!(parse_line("[not json"), None);
}
#[test]
fn lists_usable_devices_first_and_adds_what_only_adb_sees() {
let daemon: BTreeMap<_, _> = [
dev("chrome", "Chrome", "web", false),
dev("macos", "macOS", "desktop", false),
dev("emulator-5554", "Pixel", "mobile", true),
dev("R5C", "Galaxy", "mobile", false),
]
.into_iter()
.map(|d| (d.id.clone(), d))
.collect();
let adb = [adb("R5C", "device"), adb("emulator-5554", "offline"), adb("X1", "unauthorized")];
let list = merged(&daemon, &adb);
let ids: Vec<_> = list.iter().map(|d| d.id.as_str()).collect();
assert_eq!(ids, ["R5C", "emulator-5554", "macos", "chrome", "X1"]);
assert_eq!(list[4].unavailable.as_deref(), Some("unauthorized"));
assert_eq!(list[1].unavailable, None, "what the daemon lists is usable");
}
#[cfg(unix)]
mod process {
use super::super::*;
use ide_core::EventSink;
use std::os::unix::fs::PermissionsExt;
use std::time::Instant;
#[derive(Default)]
struct Lists(Mutex<Vec<FlutterDeviceList>>);
impl EventSink for Lists {
fn emit(&self, event: IdeEvent) {
if let IdeEvent::FlutterDevices { list } = event {
self.0.lock().push(list);
}
}
}
fn daemon(dir: &Path, script: &str) -> (FlutterDaemon, Arc<Lists>) {
let path = dir.join("flutter");
std::fs::write(&path, format!("#!/bin/sh\n{script}")).unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
let lists = Arc::new(Lists::default());
(FlutterDaemon::with_executable(dir.to_owned(), lists.clone(), Some(path)), lists)
}
fn wait_for(what: &str, done: impl Fn() -> bool) {
let deadline = Instant::now() + Duration::from_secs(10);
while !done() {
assert!(Instant::now() < deadline, "timed out waiting for {what}");
std::thread::sleep(Duration::from_millis(10));
}
}
const SESSION: &str = r#"
echo $$ > pid
echo 'Waiting for another flutter command to release the startup lock...'
echo '[{"event":"daemon.connected","params":{"version":"0.6.1","pid":1}}]'
read enable; read get; echo "$enable$get" > requests
echo '[{"id":1,"result":null}]'
echo '[{"id":2,"result":[{"id":"macos","name":"macOS","category":"desktop","emulator":false}]}]'
echo '[{"event":"device.added","params":{"id":"chrome","name":"Chrome","category":"web","emulator":false}}]'
echo '[{"event":"device.removed","params":{"id":"macos","name":"macOS"}}]'
cat > /dev/null
"#;
#[test]
fn follows_devices_and_ends_with_the_project() {
let dir = tempfile::tempdir().unwrap();
let (daemon, lists) = daemon(dir.path(), SESSION);
assert_eq!(daemon.devices().status, FlutterDaemonStatus::Starting);
wait_for("the removal", || {
let list = daemon.devices();
list.status == FlutterDaemonStatus::Ready
&& list.devices.iter().map(|d| d.id.as_str()).collect::<Vec<_>>() == ["chrome"]
});
let requests = std::fs::read_to_string(dir.path().join("requests")).unwrap();
assert!(requests.contains("device.enable") && requests.contains("device.getDevices"), "{requests}");
assert!(lists.0.lock().iter().any(|l| l.devices.iter().any(|d| d.id == "macos")));
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
let alive =
|| Command::new("kill").args(["-0", pid.trim()]).stderr(Stdio::null()).status().unwrap().success();
assert!(alive());
daemon.stop();
wait_for("the process to end", || !alive());
assert_eq!(daemon.0.state.lock().status, FlutterDaemonStatus::Stopped);
}
#[test]
fn the_daemon_does_not_outlive_the_ide() {
let dir = tempfile::tempdir().unwrap();
let flutter = dir.path().join("flutter");
std::fs::write(&flutter, "#!/bin/sh\necho $$ > pid\nexec sleep 60\n").unwrap();
std::fs::set_permissions(&flutter, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut ide = Command::new("sleep").arg("60").spawn().unwrap();
let mut cmd = daemon_command(&flutter, ide.id());
cmd.current_dir(dir.path()).stdin(Stdio::piped());
let mut daemon = own_group(&mut cmd).spawn().unwrap();
wait_for("the daemon", || dir.path().join("pid").is_file());
assert_eq!(daemon.try_wait().unwrap(), None);
ide.kill().unwrap();
ide.wait().unwrap();
let deadline = Instant::now() + Duration::from_secs(10);
while daemon.try_wait().unwrap().is_none() {
assert!(Instant::now() < deadline, "the daemon outlived its parent");
std::thread::sleep(Duration::from_millis(50));
}
}
#[test]
fn a_crash_is_reported_and_not_restarted_until_asked() {
let dir = tempfile::tempdir().unwrap();
let (daemon, _lists) = daemon(dir.path(), "echo run >> runs\necho 'SDK is broken' >&2\nexit 3\n");
daemon.devices();
let failed = || matches!(daemon.0.state.lock().status, FlutterDaemonStatus::Failed { .. });
wait_for("the failure", failed);
let FlutterDaemonStatus::Failed { message } = daemon.devices().status else { panic!("still failed") };
assert_eq!(message, "SDK is broken");
std::thread::sleep(Duration::from_millis(100));
let runs = || std::fs::read_to_string(dir.path().join("runs")).unwrap().lines().count();
assert_eq!(runs(), 1);
daemon.restart();
wait_for("the second run", || runs() == 2);
}
}
}
-1
Переглянути файл
@@ -58,7 +58,6 @@ ide-plugin.workspace = true
ide-tools = { path = "../ide-tools" }
ide-scaffold.workspace = true
ide-docker = { path = "../ide-docker" }
ide-flutter = { path = "../ide-flutter" }
semver = "1"
serde.workspace = true
jsonschema = { version = "0.33", default-features = false }
+4 -19
Переглянути файл
@@ -11,12 +11,7 @@ use std::path::PathBuf;
use std::sync::{Arc, OnceLock};
fn main() {
let raw_args: Vec<String> = std::env::args().collect();
if let Some(project) = ide_mcp::stdio_request(&raw_args) {
let base = server_home();
std::process::exit(ide_mcp::stdio::run(&ide_mcp::discovery_path(&base.join("data")), project));
}
let args: Vec<String> = raw_args.into_iter().skip(1).collect();
let args: Vec<String> = std::env::args().skip(1).collect();
if args.iter().any(|a| a == "--version") {
println!("openidea-server {} (protocol {})", env!("CARGO_PKG_VERSION"), rpc::PROTOCOL_VERSION);
return;
@@ -36,9 +31,7 @@ fn main() {
std::process::exit(code);
}
if !args.iter().any(|a| a == "--stdio") {
eprintln!(
"usage: openidea-server --stdio | --mcp-stdio [--project <path>] | --connect <host> <port> | --version"
);
eprintln!("usage: openidea-server --stdio | --connect <host> <port> | --version");
std::process::exit(2);
}
// stdout carries the protocol: logs go to stderr.
@@ -46,7 +39,8 @@ fn main() {
.with_writer(std::io::stderr)
.with_env_filter(tracing_subscriber::EnvFilter::try_from_env("OPENIDEA_LOG").unwrap_or_else(|_| "info".into()))
.init();
let base = server_home();
let home = dirs::home_dir().unwrap_or_default();
let base = std::env::var_os("OPENIDEA_SERVER_HOME").map(PathBuf::from).unwrap_or_else(|| home.join(".openidea"));
// An SSH exec channel gets a minimal environment: take the login shell's, read
// afresh on every start, plus the IDE-managed tools. Before any other thread starts.
ide_host::shell_env::inherit_login_shell_env("openidea-server");
@@ -59,11 +53,6 @@ fn main() {
std::process::exit(code);
}
fn server_home() -> PathBuf {
let home = dirs::home_dir().unwrap_or_default();
std::env::var_os("OPENIDEA_SERVER_HOME").map(PathBuf::from).unwrap_or_else(|| home.join(".openidea"))
}
async fn run(base: PathBuf) -> i32 {
let (config_dir, data_dir) = (base.join("config"), base.join("data"));
for dir in [&config_dir, &data_dir] {
@@ -96,9 +85,6 @@ async fn run(base: PathBuf) -> i32 {
runtime: tokio::runtime::Handle::current(),
project_environment: true,
}));
// A stable path for `--mcp-stdio` client configurations across server upgrades.
host.mcp.set_stdio_link(base.join("bin").join("openidea-server"));
host.mcp.apply(&host);
// The desktop's code plugins run here, next to the project (`plugin_sync_packages`).
let plugins = match RemotePlugins::start(&plugins_data, &host, peer.clone()) {
Ok(p) => Some(p),
@@ -126,7 +112,6 @@ async fn run(base: PathBuf) -> i32 {
}
});
rpc::serve(host.clone(), dispatcher, peer, tokio::io::stdin(), tokio::io::stdout()).await;
host.mcp.stop(&host);
if let Some(plugins) = &plugins {
plugins.host().shutdown();
}
+11 -198
Переглянути файл
@@ -2,9 +2,9 @@
use crate::Host;
use ide_core::event::NotifyLevel;
use ide_core::settings::{ExternalFormatter, LanguagesSettings, Settings};
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, Pos, Range, TextEdit};
use ide_language::{LanguageConfig, PhpAlignment, Syntax};
use ide_core::settings::{ExternalFormatter, LanguagesSettings};
use ide_core::{DocId, IdeError, IdeEvent, IdeResult, Pos, Range, TextEdit};
use ide_language::LanguageConfig;
use ide_lsp::types::FormatOptions;
use ide_tools::{Tools, formatter};
use std::path::Path;
@@ -129,101 +129,12 @@ pub async fn format(
let project = host.project(window)?;
let snap = project.documents.snapshot(doc)?;
let settings = project.settings.effective();
let alignment = php_alignment(&settings, &snap.language);
let original = alignment.any().then(|| (snap.language.clone(), snap.text.clone()));
let Some(edits) = provider_edits(host, window, &project, snap, settings, range, options).await? else {
return Ok(Vec::new());
};
let Some((language, text)) = original else {
return Ok(edits);
};
let syntax = host.syntax();
tokio::task::spawn_blocking(move || align_formatted(&syntax, &language, &text, edits, range, alignment))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// PHP Code Style › Align key-value pairs / Align consecutive assignments (off by default, as in PhpStorm).
fn php_alignment(settings: &Settings, language: &LanguageId) -> PhpAlignment {
let style = settings.editor.code_style.languages.get(language.as_str());
PhpAlignment {
key_value_pairs: style.and_then(|s| s.align_key_value_pairs).unwrap_or(false),
assignments: style.and_then(|s| s.align_consecutive_assignments).unwrap_or(false),
}
}
/// The formatter's `edits` to `text` followed by the alignment, as one set of edits to `text`.
/// With a `range`, only its lines (where the formatter left them) are aligned.
fn align_formatted(
syntax: &Syntax,
language: &LanguageId,
text: &str,
edits: Vec<TextEdit>,
range: Option<Range>,
alignment: PhpAlignment,
) -> IdeResult<Vec<TextEdit>> {
let mut formatted = ide_text::Document::new(text);
// Edits the editor has to sort out itself (overlapping ones) are passed on unaligned.
let Ok((changes, _)) = formatted.apply_edits(&edits) else {
return Ok(edits);
};
let lines = range.map(|range| {
let original = ide_text::Document::new(text);
let start = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.start), false));
let end = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.end), true));
let last = if end.col == 0 && end.line > start.line { end.line - 1 } else { end.line };
(start.line as usize, last as usize)
});
let Some(aligned) = syntax.align_php(language, &formatted.text(), lines, alignment) else {
return Ok(edits);
};
let original = ide_text::Document::new(text);
Ok(original
.diff(&aligned)
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect())
}
/// Where UTF-16 `offset` of the text before `changes` ends up after them; inside a replaced
/// part, at its start or (`end`) its end.
fn map_offset(changes: &ChangeSet, offset: u32, end: bool) -> u32 {
let mut shift: i64 = 0;
for c in &changes.changes {
let inserted = c.insert.encode_utf16().count() as i64;
if c.to < offset || (c.to == offset && (c.from < c.to || end)) {
shift += inserted - i64::from(c.to - c.from);
} else if c.from < offset {
return (i64::from(c.from) + shift + if end { inserted } else { 0 }) as u32;
} else {
break;
}
}
(i64::from(offset) + shift) as u32
}
/// The edits of the formatter that handles the document; `None` when it doesn't run
/// (formatting on save is off for it).
async fn provider_edits(
host: &Host,
window: &str,
project: &crate::Project,
snap: ide_workspace::documents::DocumentInfo,
settings: Settings,
range: Option<Range>,
options: FormatOptions,
) -> IdeResult<Option<Vec<TextEdit>>> {
let doc = snap.id;
let language = project.languages.get(&snap.language);
if options.tool.is_none()
&& let Some(id) = settings.languages.plugin_formatters.get(snap.language.as_str()).filter(|s| !s.is_empty())
{
if options.on_save && !settings.editor.format_on_save {
return Ok(None);
return Ok(Vec::new());
}
if snap.read_only {
return Err(IdeError::invalid("The file is read-only"));
@@ -249,8 +160,7 @@ async fn provider_edits(
)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
.map(Some);
.map_err(|e| IdeError::internal(e.to_string()))?;
}
// A committed PHP-CS-Fixer configuration takes over Reformat Code for `.php` files.
if options.tool.is_none()
@@ -258,7 +168,7 @@ async fn provider_edits(
&& let Some(fixer) = formatter::php_cs_fixer(&snap.path)
{
if options.on_save && !settings.editor.format_on_save {
return Ok(None);
return Ok(Vec::new());
}
host.require_trust(window)?;
if snap.read_only {
@@ -278,7 +188,7 @@ async fn provider_edits(
body: Some("PHP-CS-Fixer does not support selection formatting; formatted the whole file".into()),
});
}
return Ok(Some(edits));
return Ok(edits);
}
let mut selected = external_tool(options.tool, language.as_ref(), &snap.path, &settings.languages)?;
if let Some(tool) = selected
@@ -290,13 +200,13 @@ async fn provider_edits(
}
let Some(selected) = selected else {
if options.on_save && !settings.editor.format_on_save {
return Ok(None);
return Ok(Vec::new());
}
return project.lsp.format(doc, range, options).await.map(Some);
return project.lsp.format(doc, range, options).await;
};
let tool_settings = settings.languages.formatter(selected);
if options.on_save && !tool_settings.run_on_save {
return Ok(None);
return Ok(Vec::new());
}
host.require_trust(window)?;
if snap.read_only {
@@ -352,7 +262,7 @@ async fn provider_edits(
)),
});
}
edits.map(Some).map_err(|e| e.with_tool(tool))
edits.map_err(|e| e.with_tool(tool))
}
#[cfg(test)]
@@ -503,103 +413,6 @@ mod tests {
);
}
fn after(text: &str, edits: &[TextEdit]) -> String {
let mut doc = ide_text::Document::new(text);
doc.apply_edits(edits).unwrap();
doc.text()
}
fn whole_file(text: &str, formatted: &str) -> Vec<TextEdit> {
let doc = ide_text::Document::new(text);
doc.diff(formatted)
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(doc.offset_to_pos(c.from), doc.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect()
}
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
#[test]
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
let php = LanguageId::new("php");
let mut settings = Settings::default();
assert_eq!(php_alignment(&settings, &php), PhpAlignment::default());
let style =
ide_core::editor_settings::LanguageCodeStyle { align_key_value_pairs: Some(true), ..Default::default() };
settings.editor.code_style.languages.insert("php".into(), style);
assert_eq!(php_alignment(&settings, &php), PhpAlignment { key_value_pairs: true, assignments: false });
assert_eq!(php_alignment(&settings, &LanguageId::new("javascript")), PhpAlignment::default());
}
#[test]
fn alignment_follows_the_formatter_edits_even_when_there_are_none() {
let syntax = Syntax::new();
let php = LanguageId::new("php");
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
let edits = align_formatted(&syntax, &php, text, Vec::new(), None, ALIGN).unwrap();
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
// The language server re-indents the array: the alignment applies to its result.
let text = "<?php\n$a = [\n'a' => 1,\n'bbb' => 2,\n];\n";
let formatted = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
let edits = align_formatted(&syntax, &php, text, whole_file(text, formatted), None, ALIGN).unwrap();
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
let unchanged = whole_file(text, formatted);
let off = align_formatted(&syntax, &php, text, unchanged.clone(), None, PhpAlignment::default()).unwrap();
assert_eq!(off, unchanged);
let overlapping = vec![
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 4)), new_text: "x".into() },
TextEdit { range: Range::new(Pos::new(1, 2), Pos::new(1, 6)), new_text: "y".into() },
];
let passed = align_formatted(&syntax, &php, text, overlapping.clone(), None, ALIGN).unwrap();
assert_eq!(passed, overlapping);
}
#[test]
fn a_selection_aligns_only_its_lines_whatever_the_formatter_changed() {
let syntax = Syntax::new();
let php = LanguageId::new("php");
let text = "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
// PHP-CS-Fixer formats the whole file (here: adds a line at the top) whatever the selection.
let formatted = format!("<?php\n\ndeclare(strict_types=1);\n{}", &text["<?php\n".len()..]);
let edits = whole_file(text, &formatted);
// Lines 3..=6 select the array, up to the start of the line after it.
let range = Range::new(Pos::new(3, 0), Pos::new(7, 0));
let aligned = align_formatted(&syntax, &php, text, edits, Some(range), ALIGN).unwrap();
assert_eq!(aligned.len(), 2, "one edit per changed region: {aligned:?}");
assert_eq!(
after(text, &aligned),
"<?php\n\ndeclare(strict_types=1);\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n"
);
let range = Range::new(Pos::new(1, 0), Pos::new(2, 9));
let aligned = align_formatted(&syntax, &php, text, Vec::new(), Some(range), ALIGN).unwrap();
assert_eq!(after(text, &aligned), "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
}
#[test]
fn offsets_map_through_changes() {
let changes = ChangeSet {
changes: vec![
ide_core::TextChange { from: 2, to: 2, insert: "ab".into() },
ide_core::TextChange { from: 5, to: 8, insert: "x".into() },
],
};
assert_eq!(map_offset(&changes, 0, false), 0);
assert_eq!(map_offset(&changes, 2, false), 2);
assert_eq!(map_offset(&changes, 2, true), 4);
assert_eq!(map_offset(&changes, 4, false), 6);
assert_eq!(map_offset(&changes, 6, false), 7);
assert_eq!(map_offset(&changes, 6, true), 8);
assert_eq!(map_offset(&changes, 8, false), 8);
assert_eq!(map_offset(&changes, 10, false), 10);
}
#[test]
fn ruff_ranges_are_one_based_unicode_columns() {
let text = ide_text::Document::new("😀x = 1\ny = 2\n");
+4 -21
Переглянути файл
@@ -59,8 +59,7 @@ pub struct HostConfig {
}
pub struct Host {
pub(crate) mcp_executable: Arc<RwLock<Option<PathBuf>>>,
pub mcp: mcp::McpService,
pub(crate) mcp_executable: RwLock<Option<PathBuf>>,
plugin_host: RwLock<std::sync::Weak<plugins::PluginHost>>,
/// Every `Diagnostics` event the host ever emitted, per file and producer:
/// the snapshot plugins read (`problems`), independent of windows and reports.
@@ -153,8 +152,7 @@ impl Host {
ssh.set_configs(global_settings.effective().ssh.configs);
let host = Self {
plugin_host: RwLock::default(),
mcp_executable: Arc::default(),
mcp: Default::default(),
mcp_executable: RwLock::default(),
diagnostics,
mcp_reports: Default::default(),
mcp_requests: Default::default(),
@@ -224,12 +222,12 @@ impl Host {
}
}
/// Publishes the executable of the running built-in MCP service (`None` while it is off).
/// Associates the plugin runtime that executes this host's project operations.
/// Publishes only the executable of the running built-in MCP service.
pub fn set_mcp_executable(&self, executable: Option<PathBuf>) {
*self.mcp_executable.write() = executable;
}
/// Associates the plugin runtime that executes this host's project operations.
pub fn set_plugin_host(&self, plugins: &Arc<plugins::PluginHost>) {
*self.plugin_host.write() = Arc::downgrade(plugins);
}
@@ -255,16 +253,6 @@ impl Host {
self.project(window)?.require_trust()
}
/// [`Self::require_trust`] for IDE-wide toolchain work (SDK detection, tool installs) that
/// also runs from a window without a project, such as Settings opened from the Welcome
/// screen: there is no project there to trust.
pub fn require_trust_if_project(&self, window: &str) -> IdeResult<()> {
match self.project(window) {
Ok(project) => project.require_trust(),
Err(_) => Ok(()),
}
}
/// The window that owns what `window` starts.
pub fn owner_window<'a>(&self, window: &'a str) -> &'a str {
(self.owner)(window)
@@ -343,7 +331,6 @@ impl Host {
}
project.documents.clear_workspace_edit_history();
project.agents.shutdown();
project.flutter.stop();
project.notebooks.stop_admission();
// What the closing window started goes with it — the builds and searches it
// asked for, its runs, its shells and its debug sessions — and its language
@@ -462,9 +449,6 @@ impl Host {
pub fn stop_processes_on_exit(&self) {
self.processes.kill_all();
self.terminals.kill_all();
for project in self.projects() {
project.flutter.kill();
}
}
/// Called before desktop exit, which may bypass document destructors.
@@ -486,7 +470,6 @@ impl Host {
let projects: Vec<_> = self.projects.write().drain().map(|(_, p)| p).collect();
for project in &projects {
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
project.flutter.kill();
}
for project in &projects {
project.plugin_diagnostics.close();
-1
Переглянути файл
@@ -869,7 +869,6 @@ async fn occurrences(
scope,
max_matches: 0,
context,
include_excluded: false,
};
let host = call.host();
let request = crate::mcp::tool::request_id();
+8 -8
Переглянути файл
@@ -1,5 +1,5 @@
use super::page::{OFFSET, Page};
use super::search::{PathScope, paths_param};
use super::scope::{self, Scope};
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(paths_param()),
.param(scope::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(paths_param())
.param(scope::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 paths = PathScope::of(&call)?;
let dir = Scope::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| paths.matches_path(&e.path.0));
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
Output::json(json!({
"activeFilePath": active.map(|e| call.display(&e.path.0)),
"openFiles": open.iter().filter(|p| paths.matches_path(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
"openFiles": open.iter().filter(|p| dir.contains(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 paths = PathScope::of(&call)?;
let dir = Scope::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| paths.matches_path(&f.path.0))
.filter(|f| dir.contains(&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);
+14 -124
Переглянути файл
@@ -8,10 +8,9 @@ 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, PathBuf};
use std::path::Path;
use std::time::{Duration, Instant};
const DEFAULT_READ_LIMIT: i64 = 2000;
@@ -167,9 +166,7 @@ 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.
What `.gitignore` ignores is marked [git-ignored] and what the project excludes [ide-excluded]; entries inside a
marked directory are not marked again.",
A page that starts inside a directory repeats the lines of the directories above it.",
|call| async move {
let directory = call.str("directoryPath")?;
let max_depth = call.opt_i64("maxDepth")?.unwrap_or(DEFAULT_TREE_DEPTH);
@@ -184,12 +181,6 @@ marked directory are not marked again.",
}
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(),
@@ -199,12 +190,11 @@ marked directory are not marked again.",
page,
seen: 0,
above: Vec::new(),
marks,
};
let tree = call
.host()
.blocking(move || {
tree.render(&dir, "", true, max_depth, true, root_mark, !root_mark.is_empty());
tree.render(&dir, "", true, max_depth, true);
Ok(tree)
})
.await?;
@@ -244,8 +234,7 @@ marked directory are not marked again.",
/// 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. An entry left out of the project is marked, the entries
/// inside it are not.
/// page are counted, not listed.
struct TreeRender {
out: String,
errors: Vec<String>,
@@ -257,48 +246,10 @@ 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 {
/// `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,
) {
fn render(&mut self, path: &Path, indent: &str, is_last: bool, max_depth: i64, is_root: bool) {
if max_depth <= 0 || self.timed_out || self.cancel.is_cancelled() {
return;
}
@@ -317,7 +268,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}{}{mark}\n", if is_dir { "/" } else { "" });
let line = format!("{indent}{prefix}{name}{}\n", if is_dir { "/" } else { "" });
let shown = if is_root {
self.out.push_str(&line);
true
@@ -327,38 +278,22 @@ impl TreeRender {
if !is_dir {
return;
}
// 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(),
let mut children: Vec<_> = match std::fs::read_dir(path) {
Ok(entries) => entries.filter_map(|e| e.ok().map(|e| e.path())).collect(),
Err(e) => {
self.errors.push(format!("Failed to read {}: {}", path.display(), e.message));
self.errors.push(format!("Failed to read {}: {e}", path.display()));
return;
}
};
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 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 child_indent = format!("{indent}{}", if is_last { " " } else { "│ " });
let n = children.len();
if !is_root {
self.above.push((line, shown));
}
// 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(),
);
for (i, child) in children.iter().enumerate() {
self.render(child, &child_indent, i + 1 == n, max_depth - 1, false);
}
if !is_root {
self.above.pop();
@@ -448,9 +383,8 @@ 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, "", false);
tree.render(tmp.path(), "", true, 5, true);
let root = format!("{}/\n", tmp.path().display());
(tree.out.strip_prefix(&root).unwrap().to_owned(), tree.seen)
};
@@ -462,48 +396,4 @@ 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")
);
}
}
+2 -3
Переглянути файл
@@ -10,8 +10,8 @@ mod files;
mod http;
mod page;
pub mod reports;
mod scope;
mod search;
pub mod service;
mod symbols;
mod tool;
mod util;
@@ -23,7 +23,6 @@ pub use reports::{
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
};
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
pub use service::{McpServerStatus, McpService};
use std::path::{Path, PathBuf};
use std::sync::Arc;
@@ -57,7 +56,7 @@ fn allowed(tool: &ide_mcp::Tool, trusted: bool) -> bool {
impl Registry {
fn target(&self, root: &Path) -> Result<(String, Arc<crate::Project>), String> {
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
return Err("project is on a remote host; connect to the MCP server on that host".into());
return Err("not supported for remote projects yet".into());
}
let projects = self.0.projects.read();
let open = || projects.iter().filter(|(_, p)| !p.light);
+3 -3
Переглянути файл
@@ -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 paths = crate::mcp::search::PathScope::of(&call)?;
let dir = crate::mcp::scope::Scope::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| paths.matches_dir(&call.root().join(s["workingDirectory"].as_str().unwrap_or_default())))
.filter(|s| dir.contains_shown(call.root(), 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::search::paths_param())
.param(crate::mcp::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+3 -221
Переглянути файл
@@ -139,14 +139,12 @@ 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 paths = crate::mcp::search::PathScope::of(&call)?;
let dir = crate::mcp::scope::Scope::of(&call)?;
let list: Vec<Value> = configs
.iter()
// A configuration belongs where it runs.
.filter(|c| {
paths.matches_dir(
&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)),
)
dir.contains(&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| {
@@ -171,7 +169,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::search::paths_param())
.param(crate::mcp::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
@@ -358,13 +356,6 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
t.drain(..cut);
}
});
let config = match resolve_jvm_application(call, config, errors).await? {
Ok(config) => config,
Err(reason) => {
errors.process_outputs.push(reason);
return Ok(false);
}
};
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await?;
let exit = wait_exit(call, info.id, None).await?.flatten();
if exit == Some(0) {
@@ -376,177 +367,6 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
Ok(false)
}
/// Run configuration kinds launched as a JVM main class (`JVM_APPLICATION_KINDS` in the UI).
const JVM_APPLICATION_KINDS: [&str; 2] = ["application", "spring-boot"];
const CLASSPATH: &str = "${classpath}";
const TEST_CLASSPATH: &str = "${testClasspath}";
/// `java` options whose value is the next argument (`parseJavaArgs` in the UI).
const JAVA_OPTIONS_WITH_VALUE: [&str; 13] = [
"-cp",
"-classpath",
"--class-path",
"-p",
"--module-path",
"--upgrade-module-path",
"--add-modules",
"--add-opens",
"--add-exports",
"--add-reads",
"--patch-module",
"--limit-modules",
"--enable-native-access",
];
/// The main class of `java` arguments and which classpath placeholder they use (`Some(true)`:
/// `${testClasspath}`; `None`: an explicit classpath or none).
fn java_main_class(args: &[String]) -> (Option<&str>, Option<bool>) {
let mut test = None;
let mut i = 0;
while i < args.len() {
let a = args[i].as_str();
if a == "-jar" {
return (None, test);
}
if matches!(a, "-cp" | "-classpath" | "--class-path") {
match args.get(i + 1).map(String::as_str) {
Some(CLASSPATH) => test = Some(false),
Some(TEST_CLASSPATH) => test = Some(true),
_ => {}
}
i += 2;
continue;
}
if JAVA_OPTIONS_WITH_VALUE.contains(&a) {
i += 2;
continue;
}
if !a.starts_with('-') {
return (Some(a), test);
}
i += 1;
}
(None, test)
}
/// `args` with the classpath placeholders replaced and the module path added (`resolveJavaCommand`).
fn resolved_java_args(args: &[String], info: &ide_lsp::jdtls::JavaLaunchInfo) -> Vec<String> {
let cp = info.class_paths.join(&info.path_list_separator);
let mut out = Vec::with_capacity(args.len() + 2);
if !info.module_paths.is_empty() && !args.iter().any(|a| a == "-p" || a == "--module-path") {
out.push("--module-path".to_owned());
out.push(info.module_paths.join(&info.path_list_separator));
}
out.extend(args.iter().map(|a| if a == CLASSPATH || a == TEST_CLASSPATH { cp.clone() } else { a.clone() }));
out
}
/// The module (relative to the project root) of a JVM source file: the part before
/// `src/<set>/<language>/` (`jvmModuleDir` without a build model).
fn jvm_module_of(rel: &str) -> Option<String> {
let rel = rel.replace('\\', "/");
let parts: Vec<&str> = rel.split('/').collect();
(0..parts.len().saturating_sub(3)).find_map(|i| {
(parts[i] == "src" && matches!(parts[i + 2], "java" | "kotlin" | "scala" | "groovy"))
.then(|| parts[..i].join("/"))
})
}
/// The module of a configuration saved without one, found from its main class's source
/// (`findJavaModule`): `None` unless exactly one module declares it.
async fn find_java_module(call: &Call, main: &str) -> IdeResult<Option<String>> {
let outer = main.split('$').next().unwrap_or(main);
let (pkg, simple) = outer.rsplit_once('.').unwrap_or(("", outer));
let mut names = vec![format!("{simple}.java"), format!("{simple}.kt")];
if let Some(stem) = simple.strip_suffix("Kt") {
names.push(format!("{stem}.kt"));
}
let mut modules = std::collections::BTreeSet::new();
for name in names {
for path in crate::ops::nav::find_files_named(&call.host(), call.window(), name).await? {
let path = std::path::PathBuf::from(path);
let Ok(text) = std::fs::read_to_string(&path) else { continue };
let declared = text
.lines()
.map(str::trim)
.find_map(|l| l.strip_prefix("package "))
.map(|p| p.trim_end_matches(';').trim())
.unwrap_or("");
if declared != pkg {
continue;
}
let rel = path.strip_prefix(call.root()).unwrap_or(&path).to_string_lossy().into_owned();
modules.insert(jvm_module_of(&rel).unwrap_or_default());
}
}
Ok((modules.len() == 1).then(|| modules.into_iter().next().unwrap_or_default()))
}
/// A JVM application configuration ready to start, as the Run tool window launches it:
/// built per its before-launch build policy, with `${classpath}` / `${testClasspath}`, the
/// module path and the module's `java` resolved through jdtls. `Err` says why it cannot start
/// (compile errors are added to `errors`). Other configurations are returned as they are.
async fn resolve_jvm_application(
call: &Call,
config: RunConfig,
errors: &mut BuildErrors,
) -> IdeResult<Result<RunConfig, String>> {
if !JVM_APPLICATION_KINDS.contains(&config.kind.as_str()) {
return Ok(Ok(config));
}
let (main, test) = java_main_class(&config.args);
let Some(main) = main.map(str::to_owned) else {
return Ok(Err(format!("No main class in '{}'", config.name)));
};
let module = match config.extras.module.clone() {
Some(module) => module,
None => match find_java_module(call, &main).await? {
Some(module) => module,
None => return Ok(Err(format!("Cannot determine the module for main class '{main}'"))),
},
};
let policy = config.extras.build_policy.unwrap_or_default();
let cancel = ide_core::CancellationToken::new();
let host = call.host();
let info = crate::ops::java::resolve_launch(
&host,
call.window(),
std::path::PathBuf::from(&module),
test == Some(true),
policy,
&cancel,
)
.await?;
use ide_lsp::jdtls::JavaBuildStatus;
if matches!(info.build, Some(JavaBuildStatus::Failed | JavaBuildStatus::WithErrors))
&& policy != ide_run::BuildPolicy::MakeAndContinueOnErrors
{
for e in &info.errors {
errors.errors.push(format!(
"{}:{}: {}",
std::path::PathBuf::from(e.path.clone()).display(),
e.line,
e.message
));
}
let reason = if info.build == Some(JavaBuildStatus::Failed) {
format!("Build failed; '{}' was not started.", config.name)
} else {
format!("Build has compile errors; '{}' was not started.", config.name)
};
return Ok(Err(reason));
}
if test.is_some() && info.class_paths.is_empty() {
return Ok(Err("The classpath is empty: is the module imported by the Java language server?".to_owned()));
}
let args = resolved_java_args(&config.args, &info);
let command = match (&info.java_exec, config.command.as_str()) {
(Some(exec), "java") => exec.clone(),
_ => config.command.clone(),
};
Ok(Ok(RunConfig { command, args, ..config }))
}
/// The configuration's before-launch tasks, as the Run tool window runs them; returns why
/// the launch is aborted, if it is. Tool windows are not activated.
async fn before_launch(
@@ -788,10 +608,6 @@ one by one",
if let Some(reason) = before_launch(&call, &config, &configs, &mut Vec::new(), &mut errors).await? {
return Err(execution_failed(&[errors.text(), Some(reason)]));
}
let config = match resolve_jvm_application(&call, config, &mut errors).await? {
Ok(config) => config,
Err(reason) => return Err(execution_failed(&[errors.text(), Some(reason)])),
};
let collector = Arc::new(Mutex::new(OutputCollector::create(&config.name)?));
let output_path = collector.lock().path.clone();
let sink = collector.clone();
@@ -868,40 +684,6 @@ provided, values are merged over existing env.",
mod tests {
use super::*;
fn strings(args: &[&str]) -> Vec<String> {
args.iter().map(|a| (*a).to_owned()).collect()
}
#[test]
fn java_arguments_name_the_main_class_and_classpath_placeholder() {
let run = strings(&["-Xmx1g", "-cp", CLASSPATH, "--add-opens", "a/b=ALL-UNNAMED", "com.example.App", "x"]);
assert_eq!(java_main_class(&run), (Some("com.example.App"), Some(false)));
assert_eq!(java_main_class(&strings(&["-classpath", TEST_CLASSPATH, "T"])), (Some("T"), Some(true)));
assert_eq!(java_main_class(&strings(&["-cp", "lib/*", "Main"])), (Some("Main"), None));
assert_eq!(java_main_class(&strings(&["-jar", "app.jar"])), (None, None));
}
#[test]
fn resolved_java_arguments_replace_the_placeholder_and_add_the_module_path() {
let info = ide_lsp::jdtls::JavaLaunchInfo {
class_paths: vec!["/p/target/classes".into(), "/m2/a.jar".into()],
module_paths: vec!["/m2/mod.jar".into()],
path_list_separator: ":".into(),
..Default::default()
};
assert_eq!(
resolved_java_args(&strings(&["-cp", CLASSPATH, "App"]), &info),
strings(&["--module-path", "/m2/mod.jar", "-cp", "/p/target/classes:/m2/a.jar", "App"])
);
}
#[test]
fn a_source_file_belongs_to_the_module_before_its_source_set() {
assert_eq!(jvm_module_of("repro-dto/src/main/java/com/example/App.java").as_deref(), Some("repro-dto"));
assert_eq!(jvm_module_of("src/test/kotlin/AppTest.kt").as_deref(), Some(""));
assert_eq!(jvm_module_of("scripts/App.java"), None);
}
fn config() -> RunConfig {
RunConfig {
id: "user:x".into(),
+56
Переглянути файл
@@ -0,0 +1,56 @@
//! 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))
}
}
+65 -173
Переглянути файл
@@ -6,6 +6,7 @@
//! 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;
@@ -36,10 +37,8 @@ const MIN_UNMASKED_MATCHES: usize = 10_000;
/// outside the window of a longer line are left out.
const LINE_WINDOW: usize = 500;
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 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 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 \
@@ -69,8 +68,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(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
@@ -92,8 +91,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(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
@@ -114,7 +113,8 @@ 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(paths_param())
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional(
"include_external",
ParamType::Boolean,
@@ -140,8 +140,13 @@ 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(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.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(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.output(result_schema())
@@ -331,39 +336,22 @@ async fn fill_lines(
// --- path globs ----------------------------------------------------------------
/// 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,
/// The `paths` argument: project-relative globs, `!` excludes.
struct PathScope {
/// `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 {
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> {
fn new(root: &Path, 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() {
@@ -374,18 +362,12 @@ impl PathScope {
Some(rest) => (true, rest.trim()),
None => (false, raw),
};
let mut glob = normalize_glob(pattern, root, attached)?;
let mut glob = normalize_glob(pattern, root)?;
// 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("/**");
}
if !negated {
match glob_folder(&glob, root) {
Some(folder) => roots.push(folder),
None => anywhere = true,
}
}
let alternatives = expand_braces(&engine_mask(&glob, attached));
let alternatives = expand_braces(&glob);
maskable &= alternatives.is_some();
let (set, masks) =
if negated { (&mut exclude, &mut exclude_masks) } else { (&mut include, &mut include_masks) };
@@ -394,83 +376,27 @@ 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),
})
}
pub(crate) fn is_all(&self) -> bool {
fn is_all(&self) -> bool {
self.include.is_none() && self.exclude.is_empty()
}
/// `path` is project-relative with `/` (absolute outside the project).
pub(crate) fn matches(&self, path: &str) -> bool {
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`; 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> {
/// `root`. Errors when that points outside the project.
fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
let mut value = raw.trim().replace('\\', "/");
if value.is_empty() {
return Err(IdeError::invalid("Glob pattern is empty"));
@@ -485,7 +411,7 @@ fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<Str
if !value.contains('/') {
value = format!("**/{value}");
}
let value = normalize_path_pattern(&value, root, attached)?;
let value = normalize_path_pattern(&value, root)?;
if value.is_empty() {
return Err(IdeError::invalid(format!("Invalid glob pattern: {raw}")));
}
@@ -495,7 +421,7 @@ fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<Str
/// 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, attached: &[PathBuf]) -> IdeResult<String> {
fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
let outside = || {
IdeError::invalid(format!("Specified path '{pattern}' points to the location outside of the project directory"))
};
@@ -516,16 +442,8 @@ fn normalize_path_pattern(pattern: &str, root: &Path, attached: &[PathBuf]) -> I
} 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,
@@ -626,7 +544,8 @@ 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 scope = PathScope::of(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
// 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() {
@@ -646,18 +565,22 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
whole_word: false,
include,
exclude,
scope: SearchScope::Project,
// Only `scope` is walked.
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
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().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
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();
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');
@@ -827,35 +750,27 @@ 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 scope = PathScope::of(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
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();
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(),
// `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()],
None => std::iter::once(root.clone())
.chain(
content
.iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r))
.cloned(),
call.project()
.content_roots()
.into_iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
)
.map(|r| (r.clone(), r))
.collect(),
};
let host = call.host();
@@ -875,7 +790,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(|(dir, base)| walk.dir(dir, base, &mut found));
let more = roots.iter().any(|base| walk.dir(base, base, &mut found));
if walk.cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
@@ -962,23 +877,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 scope = PathScope::of(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
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, within) = (project.clone(), q.clone(), scope.clone());
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
host.blocking(move || {
Ok(if within.is_all() {
project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool)
} else {
Ok(match dir {
// Filtered in the index: a pool cut before the filter could miss every match.
project
Some(dir) => project
.index
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| within.matches_path(p), &|| false)
.unwrap_or_default()
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
.unwrap_or_default(),
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
})
})
.await?
@@ -987,6 +902,7 @@ 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 {
@@ -1004,11 +920,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 `paths`; library symbols are what was
// asked for.
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
// are what was asked for.
let inside = location.uri.is_none()
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
if inside && !scope.matches(&path) {
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
continue;
}
let item = SearchItem {
@@ -1083,13 +999,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/**");
@@ -1166,33 +1082,9 @@ 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"));
}
}
-296
Переглянути файл
@@ -1,296 +0,0 @@
//! Agents › IDE MCP Server: runs `ide_mcp::McpServer` over built-in host tools
//! while `mcpServer.enabled` is on, and reports where it listens.
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, IpcPath};
use parking_lot::{Mutex, RwLock};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::net::IpAddr;
use std::path::PathBuf;
use std::sync::Arc;
/// The server while it runs, or why it doesn't.
#[derive(Default)]
pub struct McpService {
server: Mutex<Option<ide_mcp::McpServer>>,
/// The address, port and token settings the running server was started with.
running_with: Mutex<Option<Listen>>,
error: Mutex<Option<String>>,
/// A link to this executable advertised for `--mcp-stdio` instead of `current_exe()`.
stdio_link: RwLock<Option<PathBuf>>,
}
/// What the address, port and token settings ask the server for.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Listen {
/// `mcpServer.address`.
address: IpAddr,
/// `mcpServer.port` with `mcpServer.fixedPort`; otherwise a free port.
port: Option<u16>,
fixed_token: bool,
}
impl McpService {
/// Advertises `link` in `--mcp-stdio` client configs and agent sessions, pointed at this
/// executable whenever the server starts. Without one (or where it can't be written),
/// `current_exe()` is advertised.
pub fn set_stdio_link(&self, link: PathBuf) {
*self.stdio_link.write() = Some(link);
}
pub(crate) fn stdio_executable(&self) -> PathBuf {
self.stdio_link.read().clone().or_else(|| std::env::current_exe().ok()).unwrap_or_default()
}
fn update_stdio_link(&self) {
let mut link = self.stdio_link.write();
if let Some(path) = link.as_deref()
&& let Err(e) = point_at_current_exe(path)
{
tracing::warn!("MCP server: cannot link {} ({e}); advertising this executable", path.display());
*link = None;
}
}
/// Starts, stops or restarts the server to match the global `mcpServer` settings:
/// `enabled`, and the address, port and token it listens with.
pub fn apply(&self, host: &Arc<Host>) {
let settings = host.global_settings.effective().mcp_server;
let mut server = self.server.lock();
if !settings.enabled {
let was_running = server.take();
let stopped = was_running.is_some();
if let Some(running) = was_running {
running.stop();
}
*self.running_with.lock() = None;
host.set_mcp_executable(None);
*self.error.lock() = None;
drop(server);
if stopped {
for project in host.projects() {
project.agents.notify_mcp_servers_changed();
}
}
return;
}
let Ok(address) = settings.address.trim().parse::<IpAddr>() else {
let stopped = server.take().map(|running| running.stop()).is_some();
*self.running_with.lock() = None;
host.set_mcp_executable(None);
*self.error.lock() = Some(format!("the listen address `{}` is not an IP address", settings.address.trim()));
drop(server);
if stopped {
for project in host.projects() {
project.agents.notify_mcp_servers_changed();
}
}
return;
};
let wanted = Listen {
address,
port: settings.fixed_port.then_some(settings.port).filter(|p| *p != 0),
fixed_token: settings.fixed_token,
};
if server.is_some() && *self.running_with.lock() == Some(wanted) {
return;
}
// Another address, port or token: clients connect anew.
if let Some(running) = server.take() {
let held = (running.address(), running.port());
running.stop();
if let Some(port) = port_to_wait_for(held, wanted.port) {
wait_until_free(address, port);
}
}
let token = if wanted.fixed_token {
match ide_mcp::kept_token(&ide_mcp::token_path(&host.data_dir)) {
Ok(token) => Some(token),
Err(e) => {
tracing::warn!("MCP server: cannot keep the token ({e}); using a new one for this run");
None
}
}
} else {
None
};
let discovery = ide_mcp::discovery_path(&host.data_dir);
match ide_mcp::McpServer::start_with(
Arc::new(crate::mcp::Registry::new(host.clone())),
Some(discovery),
&host.runtime,
ide_mcp::ServerOptions { address: Some(address), port: wanted.port, token },
) {
Ok(started) => {
self.update_stdio_link();
host.set_mcp_executable(Some(self.stdio_executable()));
*server = Some(started);
*self.running_with.lock() = Some(wanted);
*self.error.lock() = None;
drop(server);
for project in host.projects() {
project.agents.notify_mcp_servers_changed();
}
}
Err(e) => {
tracing::warn!("MCP server: {e}");
host.set_mcp_executable(None);
*self.running_with.lock() = None;
*self.error.lock() = Some(e.to_string());
}
}
}
/// Stops the server on exit (its discovery file goes with it).
pub fn stop(&self, host: &Host) {
host.set_mcp_executable(None);
if let Some(server) = self.server.lock().take() {
server.stop();
}
*self.running_with.lock() = None;
}
}
/// Replaces the symlink `link` with one to this executable.
fn point_at_current_exe(link: &std::path::Path) -> std::io::Result<()> {
#[cfg(unix)]
{
let exe = std::env::current_exe()?;
let dir = link.parent().ok_or_else(|| std::io::Error::other("no parent directory"))?;
std::fs::create_dir_all(dir)?;
let tmp = dir.join(format!(".openidea-server.{}", std::process::id()));
let _ = std::fs::remove_file(&tmp);
std::os::unix::fs::symlink(&exe, &tmp)?;
std::fs::rename(&tmp, link).inspect_err(|_| {
let _ = std::fs::remove_file(&tmp);
})
}
#[cfg(not(unix))]
{
let _ = link;
Err(std::io::ErrorKind::Unsupported.into())
}
}
/// The port a restart listening on `wanted` waits for after stopping the server that listened
/// on `held`: only its own, at any address (`127.0.0.1` and `0.0.0.0` overlap). A port another
/// program holds (the run fell back to a free one) stays taken, and waiting for it would block
/// the window.
fn port_to_wait_for(held: (IpAddr, u16), wanted: Option<u16>) -> Option<u16> {
wanted.filter(|port| held.1 == *port)
}
/// Waits briefly for a stopped server's port to close, so the restart gets it again.
fn wait_until_free(address: IpAddr, port: u16) {
for _ in 0..100 {
if std::net::TcpListener::bind((address, port)).is_ok() {
return;
}
std::thread::sleep(std::time::Duration::from_millis(20));
}
}
/// What Settings › Agents › IDE MCP Server shows.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpServerStatus {
pub running: bool,
/// Why it isn't running though turned on.
pub error: Option<String>,
/// The address listened on (`0.0.0.0` / `::`: every address).
pub address: Option<String>,
pub port: Option<u16>,
/// Why the fixed port (`mcpServer.port`) isn't the one listened on: it was in use or
/// reserved, so a free port was taken for this run.
pub port_unavailable: Option<String>,
/// The window's project, which the URL and command below are for.
pub project: Option<IpcPath>,
/// `http://<address>:<port>/mcp?project=<root>`, with loopback for every address.
pub url: Option<String>,
/// Bearer token of `url` (changes with every run unless `mcpServer.fixedToken` is on).
pub token: Option<String>,
/// The stdio bridge: this host's executable and its arguments.
pub stdio_command: Vec<String>,
}
#[command(trust = outside_restricted)]
pub fn mcp_server_status(host: &Host, window: &str) -> IdeResult<McpServerStatus> {
let root: Option<PathBuf> = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let server = host.mcp.server.lock();
let exe = host.mcp.stdio_executable();
Ok(McpServerStatus {
running: server.is_some(),
error: host.mcp.error.lock().clone(),
address: server.as_ref().map(|s| s.address().to_string()),
port: server.as_ref().map(|s| s.port()),
port_unavailable: server.as_ref().and_then(|s| s.port_unavailable().map(str::to_owned)),
url: server.as_ref().zip(root.as_ref()).map(|(s, r)| s.url(r)),
token: server.as_ref().map(|s| s.token().to_owned()),
stdio_command: root.as_ref().map(|r| ide_mcp::stdio_command(&exe, r)).unwrap_or_default(),
project: root.map(IpcPath::from),
})
}
/// Settings › Agents › IDE MCP Server › Regenerate Token: forgets the kept token, and restarts the
/// server with a new one. Clients configured with the old token stop working.
#[command(trust = outside_restricted)]
pub fn mcp_regenerate_token(host: &Arc<Host>) -> IdeResult<()> {
match std::fs::remove_file(ide_mcp::token_path(&host.data_dir)) {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(e.into()),
}
*host.mcp.running_with.lock() = None;
host.mcp.apply(host);
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_ui_ready(host: &Host, window: &str, ready: bool) -> IdeResult<()> {
let window = host.owner_window(window);
host.project(window)?;
host.mcp_requests.set_ready(window, ready);
Ok(())
}
/// The user closed the Run tool window tab of an agent command (`run_command`).
#[command(trust = trusted)]
pub fn mcp_agent_run_closed(host: &Host, window: &str, name: String) -> IdeResult<()> {
let project = host.project(window)?;
host.mcp_agent_runs.closed(&project.root, &name);
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_respond(host: &Host, window: &str, id: u32, allow: bool, error: Option<String>) -> IdeResult<()> {
host.mcp_requests.answer(host.owner_window(window), id, allow, error)
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
#[test]
fn a_restart_waits_only_for_the_port_the_stopped_server_held() {
let local = IpAddr::V4(Ipv4Addr::LOCALHOST);
let any = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
assert_eq!(port_to_wait_for((local, 64342), Some(64342)), Some(64342));
// Another address on the same port overlaps the old listener: wait for it too.
assert_eq!(port_to_wait_for((any, 64342), Some(64342)), Some(64342));
// The fixed port was taken by another program: the server ran on a free one.
assert_eq!(port_to_wait_for((local, 51234), Some(64342)), None);
assert_eq!(port_to_wait_for((local, 64342), None), None);
}
}
ide_command::domain!(
mcp:
mcp_agent_run_closed,
mcp_regenerate_token,
mcp_respond,
mcp_server_status,
mcp_ui_ready,
);
+8 -8
Переглянути файл
@@ -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 paths = super::search::PathScope::of(&call)?;
let dir = super::scope::Scope::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 !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)));
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)));
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::search::paths_param())
.param(super::scope::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::search::paths_param())
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
@@ -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 paths = super::search::PathScope::of(&call)?;
let scope = super::scope::Scope::of(&call)?;
let path = call.resolve_readable(&call.str("filePath")?).await?;
let opened = open_at(&call, path).await?;
let hierarchy_at = |pos| {
@@ -378,8 +378,8 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
}
result => result?,
};
if !paths.is_all() {
found.items.retain(|i| i.uri.is_none() && paths.matches_path(&i.path.0));
if scope.dir().is_some() {
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
}
let incomplete = found.incomplete;
let (mut root, items) = call_items(found, |p| call.display(p));
+1 -1
Переглянути файл
@@ -236,7 +236,7 @@ impl Tool {
destructive: false,
output_schema: None,
input_schema: json!({ "type": "object", "properties": {
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
"projectPath": { "type": "string", "description": "Any directory inside an open project. Optional when only one project is open." }
}, "required": [] }),
},
handler: Arc::new(move |call| Box::pin(handler(call))),
+14 -20
Переглянути файл
@@ -266,39 +266,33 @@ By default all Git repositories are returned.",
.map(|r| (r.root.into_path_buf(), r.head))
.collect();
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
let paths = super::search::PathScope::of(&call)?;
let scope = super::scope::Scope::of(&call)?;
let git = git_executable(&call);
// 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(),
// 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),
};
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 {
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
None => repos,
Some(path) => {
// The innermost repository containing the path.
let repo = match innermost_repo(repos.clone(), &path) {
Some(repo) => repo,
match innermost_repo(repos, &path) {
Some(repo) => vec![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?;
(root, branch)
vec![(root, branch)]
}
None => {
let shown = wanted.clone().unwrap_or_else(|| call.display(&path));
let shown = wanted.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();
@@ -311,7 +305,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| paths.matches_path(&root.join(e.path.trim_end_matches('/'))));
entries.retain(|e| scope.contains(&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()
@@ -358,7 +352,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::search::paths_param())
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+5 -41
Переглянути файл
@@ -268,24 +268,6 @@ pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: Agent
host.project(window)?.agents.prompt(&task, prompt, now).await
}
/// Runs a `!` line of the composer in the task's folder with the user's shell, without
/// starting a turn; its output goes to the agent with the next message.
#[command(trust = trusted)]
pub async fn agent_shell(
host: &Host,
window: &str,
task: String,
command: String,
request: RequestId,
) -> IdeResult<()> {
host.require_trust(window)?;
let agents = host.project(window)?.agents.clone();
let cancel = host.begin_request(request);
let result = agents.run_shell(&task, &command, cancel).await;
host.end_request(request);
result
}
/// Answers a non-blocking question, without cancelling the current turn.
#[command(trust = trusted)]
pub async fn agent_answer_question(
@@ -387,21 +369,10 @@ pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktr
host.project(window)?.agents.delete(&task, remove_worktree).await
}
/// The task's changed files as `view` compares them (without: since it started).
#[command(trust = trusted)]
pub async fn agent_changes(
host: &Host,
window: &str,
task: String,
view: Option<AgentChangesView>,
) -> IdeResult<Vec<AgentChange>> {
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
host.require_trust(window)?;
let agents = &host.project(window)?.agents;
match view.unwrap_or_default() {
AgentChangesView::SinceStart => agents.changes(&task).await,
AgentChangesView::Group => Ok(agents.grouped_changes(&task).await?.uncommitted),
AgentChangesView::LastTurn => agents.turn_changes(&task).await,
}
host.project(window)?.agents.changes(&task).await
}
/// The task's uncommitted changes and the commits made since it started.
@@ -411,17 +382,11 @@ pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> I
host.project(window)?.agents.grouped_changes(&task).await
}
/// Content of `path` as `view` compares it (without: when the task started), the left side of its diff.
/// Content of `path` when the task started (left side of its diff).
#[command(trust = trusted)]
pub async fn agent_base_text(
host: &Host,
window: &str,
task: String,
path: IpcPath,
view: Option<AgentChangesView>,
) -> IdeResult<Option<String>> {
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
host.require_trust(window)?;
host.project(window)?.agents.base_text(&task, path.into_path_buf(), view.unwrap_or_default()).await
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
}
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
@@ -1098,7 +1063,6 @@ ide_command::domain!(
agent_rollback_changes,
agent_send_queued_now,
agent_set_command,
agent_shell,
agent_set_config,
agent_set_env,
agent_set_mcp_overrides,
+6 -48
Переглянути файл
@@ -815,15 +815,7 @@ pub async fn build_run(
if compile::menu_up_to_date(&cache, &root, &model, file.as_deref(), &token) {
let started = std::time::Instant::now();
let plan = prepare_plan(
compile::plan(
&root,
&model,
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
None,
&token,
)?,
compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref())?,
&root,
&settings,
);
@@ -861,15 +853,7 @@ pub async fn build_run(
if member == &root { cache.clone() } else { cache.join(crate::project::project_key(member)) };
let model = with_profiles(load(member, &member_cache, &settings), &member_cache);
let plan = prepare_plan(
compile::plan(
member,
&model,
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
None,
&token,
)?,
compile::plan(member, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref())?,
member,
&settings,
);
@@ -883,15 +867,7 @@ pub async fn build_run(
plan
} else {
let model = with_profiles(load(&root, &cache, &settings), &cache);
match compile::plan(
&root,
&model,
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
Some(&cache),
&token,
) {
match compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref()) {
Ok(plan) => prepare_plan(plan, &root, &settings),
// No build tool: a Java project builds from its Project Structure.
Err(e) if e.kind == ide_core::error::ErrorKind::NotFound => {
@@ -906,11 +882,6 @@ pub async fn build_run(
if result.success && single && kind == BuildKind::Build {
let model = with_profiles(load(&root, &cache, &settings), &cache);
compile::record_menu_build(&cache, &root, &model, file.as_deref(), &token);
// Only a project build covers every changed module; after Build Module the
// others may still be stale.
if file.is_none() {
compile::record_module_build(&cache, &root, &model, &token);
}
}
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
@@ -1044,16 +1015,7 @@ mod build_tool_settings_tests {
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join(marker), source).unwrap();
let plan = prepare_plan(
compile::plan(
&dir,
&Default::default(),
BuildKind::Artifacts,
None,
None,
None,
&ide_core::CancellationToken::new(),
)
.unwrap(),
compile::plan(&dir, &Default::default(), BuildKind::Artifacts, None, None).unwrap(),
root,
&settings,
);
@@ -1127,9 +1089,7 @@ mod build_tool_settings_tests {
let expected = root.join(if runner.is_empty() { "project-jdk" } else { runner });
let model = load(&root, &root.join("cache"), &settings);
assert_eq!(model.maven.as_ref().unwrap().projects[0].env["JAVA_HOME"], expected.to_string_lossy());
let plan =
compile::plan(&root, &model, BuildKind::Build, None, None, None, &ide_core::CancellationToken::new())
.unwrap();
let plan = compile::plan(&root, &model, BuildKind::Build, None, None).unwrap();
assert!(!plan.steps.is_empty());
for step in plan.steps {
assert_eq!(step.env["JAVA_HOME"], expected.to_string_lossy());
@@ -1161,9 +1121,7 @@ mod build_tool_settings_tests {
let expected = root.join(name);
let model = load(&root, &root.join("cache"), &settings);
assert_eq!(model.maven.as_ref().unwrap().projects[0].env["JAVA_HOME"], expected.to_string_lossy());
let plan =
compile::plan(&root, &model, BuildKind::Build, None, None, None, &ide_core::CancellationToken::new())
.unwrap();
let plan = compile::plan(&root, &model, BuildKind::Build, None, None).unwrap();
assert!(!plan.steps.is_empty());
for step in plan.steps {
assert_eq!(step.env["JAVA_HOME"], expected.to_string_lossy());
-61
Переглянути файл
@@ -24,34 +24,6 @@ pub struct StatementOutcome {
pub error: Option<String>,
}
#[command(trust = trusted)]
pub fn db_approve_jdbc_source(host: &Host, window: &str, source: DataSource) -> IdeResult<()> {
host.project(window)?.db.approve_jdbc_source(&source)
}
#[command(trust = trusted)]
pub async fn db_jdbc_driver_classes(host: &Host, window: &str, jars: Vec<String>) -> IdeResult<Vec<String>> {
host.project(window)?;
tokio::task::spawn_blocking(move || ide_db::jdbc_driver_classes(&jars))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub fn db_jdbc_drivers(host: &Host, window: &str) -> IdeResult<Vec<ide_db::DbJdbcDriver>> {
host.project(window)?.db.jdbc_drivers()
}
#[command(trust = trusted)]
pub fn db_save_jdbc_driver(host: &Host, window: &str, driver: ide_db::DbJdbcDriver) -> IdeResult<()> {
host.project(window)?.db.save_jdbc_driver(driver)
}
#[command(trust = trusted)]
pub fn db_remove_jdbc_driver(host: &Host, window: &str, id: String) -> IdeResult<()> {
host.project(window)?.db.remove_jdbc_driver(&id)
}
#[command(trust = trusted)]
pub fn db_sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
// The data sources configured for the project (the tree's roots).
@@ -167,32 +139,6 @@ pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<(
Ok(())
}
#[command(trust = trusted)]
pub async fn db_create_database(
host: &Host,
window: &str,
id: String,
template: String,
statement: String,
) -> IdeResult<()> {
// Creates a database on the server of data source `id` with `statement`, copied from `template` (New › Database).
let db = host.project(window)?.db.clone();
db.create_database(&id, &template, &statement).await
}
#[command(trust = trusted)]
pub async fn db_drop_database(
host: &Host,
window: &str,
id: String,
database: String,
statement: String,
) -> IdeResult<()> {
// Drops `database` of the server of data source `id` with `statement` (Drop… on a database node).
let db = host.project(window)?.db.clone();
db.drop_database(&id, &database, &statement).await
}
#[command(trust = trusted)]
pub async fn db_databases(host: &Host, window: &str, id: String) -> IdeResult<Databases> {
// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
@@ -532,21 +478,14 @@ 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,
db_history,
db_jdbc_driver_classes,
db_jdbc_drivers,
db_approve_jdbc_source,
db_save_jdbc_driver,
db_remove_jdbc_driver,
db_object_ddl,
db_remove_history,
db_retain_catalog,
+6 -38
Переглянути файл
@@ -113,11 +113,7 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
})
.await?;
}
let java_analyzer = java_analyzer_command(host, window, &config)?;
let custom = |command: &str| {
if let Some(binary) = java_analyzer {
return Some(binary.to_string_lossy().into_owned());
}
let path = ide_sdk::apply::tool_command(&root, &settings, command)
.or_else(|| ruby_tools.into_iter().find(|(name, _)| *name == command).map(|(_, path)| path))?;
Some(path.to_string_lossy().into_owned())
@@ -146,28 +142,6 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
result
}
/// For java-analyzer's debugger, the executable of the java-analyzer serving the module
/// (`projectRoot`, else the working directory), so the session debugs with the server that
/// analyzes the code.
fn java_analyzer_command(host: &Host, window: &str, config: &LaunchConfig) -> IdeResult<Option<PathBuf>> {
if config.adapter != ide_dap::adapter::JAVA_ANALYZER {
return Ok(None);
}
let project = host.project(window)?;
let extra: serde_json::Value =
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok()).unwrap_or_default();
let module = extra["projectRoot"]
.as_str()
.map(PathBuf::from)
.or_else(|| config.cwd.clone().map(PathBuf::from))
.unwrap_or_else(|| project.root.clone());
project.lsp.java_analyzer_binary(&module).map(Some).ok_or_else(|| {
ide_core::IdeError::unavailable(
"No java-analyzer serves this module: configure it as a Java language server to debug without jdtls",
)
})
}
fn require_unity_editor(pid: u32) -> IdeResult<()> {
if !ide_core::process::process_alive(pid) {
return Err(ide_core::IdeError::unavailable(format!(
@@ -204,16 +178,13 @@ fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port
}
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
/// java-debug, java-analyzer or the Kotlin debugger (JAR Application debugs through a run with a
/// JDWP agent).
/// java-debug or the Kotlin debugger (JAR Application debugs through a run with a JDWP agent).
fn is_jvm_launch(config: &LaunchConfig) -> bool {
config.request == "launch"
&& matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER | ide_dap::adapter::JAVA_ANALYZER)
config.request == "launch" && matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER)
}
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
/// java-debug's and java-analyzer's `vmArgs` (one line, or a list) or the Kotlin debugger's
/// `vmArguments` (a list).
/// java-debug's `vmArgs` (one line, or a list) or the Kotlin debugger's `vmArguments` (a list).
fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig {
if options.is_empty() || !is_jvm_launch(&config) {
return config;
@@ -223,7 +194,7 @@ fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig
else {
return config;
};
let key = if config.adapter == ide_dap::kotlin::ADAPTER { "vmArguments" } else { "vmArgs" };
let key = if config.adapter == "java-debug" { "vmArgs" } else { "vmArguments" };
let value = match extra.get(key) {
None | Some(serde_json::Value::Null) if key == "vmArgs" => {
ide_run::java_agent::add_to_vm_args_text("", options).into()
@@ -357,8 +328,8 @@ pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String
host.debugger.send_input(session, &text)
}
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId, reason: HotReloadReason) -> IdeResult<()> {
host.debugger.hot_reload(session, reason).await
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_reload(session).await
}
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
@@ -764,9 +735,6 @@ mod tests {
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!([agent]));
let java_analyzer =
launch(ide_dap::adapter::JAVA_ANALYZER, "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]}));
assert_eq!(vm_args(&add_java_agents(java_analyzer, options)), serde_json::json!(["-Xmx1g", agent]));
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
for config in [
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
-13
Переглянути файл
@@ -70,18 +70,6 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
/// An automatic save: `false` (nothing written) when the file changed on disk after the
/// buffer was edited, which only an explicit save overwrites.
#[command(trust = always)]
pub async fn doc_autosave(host: &Host, window: &str, doc: DocId) -> IdeResult<bool> {
let project = host.project(window)?;
let saved = host.blocking(move || project.documents.autosave(doc)).await?;
if saved {
host.debugger.refresh_source_mirrors(host.owner_window(window)).await?;
}
Ok(saved)
}
#[command(trust = always)]
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
let project = host.project(window)?;
@@ -121,7 +109,6 @@ ide_command::domain!(
doc_open,
doc_open_untitled,
doc_save,
doc_autosave,
doc_save_all,
doc_save_as,
doc_snapshot,
-28
Переглянути файл
@@ -1,28 +0,0 @@
//! Flutter's devices. The daemon runs on the project host, where `flutter run` and the debug
//! adapter run too, so a remote project lists the devices of its remote machine.
use crate::Host;
use ide_command::command;
use ide_core::IdeResult;
use ide_core::event::FlutterDeviceList;
/// The project's Flutter devices, starting its `flutter daemon` on first use. Changes arrive as
/// `IdeEvent::FlutterDevices`.
#[command(trust = trusted)]
pub fn flutter_devices(host: &Host, window: &str) -> IdeResult<FlutterDeviceList> {
Ok(host.project(window)?.flutter.devices())
}
/// Looks at adb again, for Android devices Flutter doesn't report (awaiting authorization, offline).
#[command(trust = trusted)]
pub fn flutter_devices_refresh(host: &Host, window: &str) -> IdeResult<()> {
host.project(window)?.flutter.refresh();
Ok(())
}
/// Replaces the project's `flutter daemon`, after a failure or an SDK change.
#[command(trust = trusted)]
pub fn flutter_daemon_restart(host: &Host, window: &str) -> IdeResult<FlutterDeviceList> {
Ok(host.project(window)?.flutter.restart())
}
ide_command::domain!(flutter: flutter_devices, flutter_devices_refresh, flutter_daemon_restart);
+7 -29
Переглянути файл
@@ -3,7 +3,6 @@ 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)]
@@ -164,27 +163,14 @@ 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<()> {
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() };
// Local History keeps the contents so deleted files can be restored.
let project = host.project(window).ok();
let history = project.as_ref().map(|p| p.history.clone());
host.blocking(move || {
let paths = ide_workspace::file_ops::deletion_paths(&path)?;
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);
}
if let Some(h) = history {
for p in &paths {
h.record_deletion(p, DELETE_SNAPSHOT_LIMIT);
}
}
ide_workspace::file_ops::delete(&path)?;
@@ -192,17 +178,11 @@ async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable:
if let Some(p) = project {
let _ = p.with_backend_of(&path, |r| r.files_deleted(&paths));
}
Ok(undo)
Ok(())
})
.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();
@@ -300,11 +280,9 @@ 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,
);
-5
Переглянути файл
@@ -311,11 +311,6 @@ async fn shutdown_does_not_wait_forever_for_a_stuck_capture() {
shutdown_within(&f.host, std::time::Duration::from_millis(200)).await;
assert!(started.elapsed() < std::time::Duration::from_secs(5));
assert!(cancel.is_cancelled());
// The cleanup is only waited for briefly and finishes in the background on a busy machine.
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
while stuck_dir.exists() && std::time::Instant::now() < deadline {
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
}
assert!(!stuck_dir.exists(), "its directory is removed once the wait is over");
}
+32 -169
Переглянути файл
@@ -5,14 +5,12 @@ use crate::Host;
use ide_command::command;
use super::build::load;
use ide_build::BuildModel;
use ide_build::compile;
use ide_core::error::ErrorKind;
use ide_core::settings::Settings;
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId};
use ide_lsp::jdtls::{JavaBuildStatus, JavaLaunchInfo};
use ide_run::BuildPolicy;
use std::path::{Path, PathBuf};
use std::path::PathBuf;
/// Cancellable with `cancel_request(request)`.
/// Builds according to `policy`, then resolves the runtime (or test)
@@ -36,7 +34,7 @@ pub async fn java_resolve_launch(
result
}
pub(crate) async fn resolve_launch(
async fn resolve_launch(
host: &Host,
window: &str,
module: PathBuf,
@@ -47,9 +45,6 @@ pub(crate) async fn resolve_launch(
let started = std::time::Instant::now();
let project = host.project(window)?;
let module = project.root.join(module);
if !project.lsp.java_served_by_jdtls(&module) {
return resolve_launch_without_jdtls(host, &project, module, test, policy, cancel).await;
}
let settings = project.settings.effective();
// A launch builds incrementally unless the configuration asks for Rebuild or NoBuild.
let build = policy != BuildPolicy::NoBuild;
@@ -166,7 +161,35 @@ pub(crate) async fn resolve_launch(
}
}
let compile_ms = started.elapsed().as_millis() - lsp_ms;
finish_launch(&mut info, &project.root, &module, &settings, &model, &data_dir);
// The module/project JDK, else the JDK jdtls compiles the module against, else one matching its Java version.
let project_jdk = ide_sdk::apply::module_jdk(&project.root, &module, &settings);
let from_jdtls = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_jdtls).or_else(|| {
// The build model's level includes what the module inherits from its parent POMs.
let release = model
.maven
.as_ref()
.and_then(|m| m.projects.iter().find(|p| project.root.join(&p.dir) == module))
.and_then(|p| p.java_version)
.or_else(|| ide_sdk::java::project_java_version(&module));
let jdks = ide_sdk::java::installed_jdks();
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
});
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
let exec = PathBuf::from(info.java_exec.as_deref().unwrap_or("java"));
let shorten =
ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
info.shorten_command_line = Some(shorten.as_str().to_owned());
if info.error_count > 0 {
let own = ide_sdk::lombok::agent_in_args(settings.languages.java.jdtls_vm_args.split_whitespace());
let managed = ide_tools::managed_bundle(&data_dir, "lombok");
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
let root = project.root.clone();
// Detection may read the project's sources.
let lombok = ide_sdk::lombok::lombok_agent(&root, own, managed, repo);
info.hints.extend(lombok.problem());
}
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
@@ -183,151 +206,6 @@ pub(crate) async fn resolve_launch(
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// A launch of a module jdtls doesn't serve (another Java language server, or none): the
/// build tool compiles it, and the classpath comes from that server, else from Maven.
async fn resolve_launch_without_jdtls(
host: &Host,
project: &std::sync::Arc<crate::Project>,
module: PathBuf,
test: bool,
policy: BuildPolicy,
cancel: &CancellationToken,
) -> IdeResult<JavaLaunchInfo> {
let started = std::time::Instant::now();
let settings = project.settings.effective();
let kind = if policy == BuildPolicy::Rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
let (model, built) = {
let (root, cache, settings, module, cancel) =
(project.root.clone(), project.build_cache_dir(), settings.clone(), module.clone(), cancel.clone());
tokio::task::spawn_blocking(move || {
let model = load(&root, &cache, &settings);
let built = if policy == BuildPolicy::NoBuild {
None
} else {
Some(compile::build_for_launch(&root, &model, &module, test, kind, &cancel))
};
(model, built)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
};
let mut info =
JavaLaunchInfo { path_list_separator: if cfg!(windows) { ";" } else { ":" }.into(), ..Default::default() };
let mut class_paths = Vec::new();
match built {
None => {}
Some(Err(e)) if e.kind == ErrorKind::Cancelled => return Err(e),
Some(Err(e)) => {
return Err(IdeError::unavailable(format!(
"Cannot build the module without jdtls: {}. Running needs a Maven or Gradle build, or jdtls",
e.message
)));
}
Some(Ok(built)) => {
info.build = Some(match built.failure {
None => JavaBuildStatus::Succeeded,
Some(failure) if policy == BuildPolicy::MakeAndContinueOnErrors => {
info.hints.push(failure);
JavaBuildStatus::Failed
}
Some(failure) => return Err(IdeError::internal(failure)),
});
class_paths.extend(built.class_dirs.iter().map(|p| p.to_string_lossy().into_owned()));
}
}
let build_ms = started.elapsed().as_millis();
let from_server = project.lsp.java_server_classpath(&module, test, cancel).await?;
let data_dir = host.local_data_dir.clone();
let project = project.clone();
let cancel = cancel.clone();
tokio::task::spawn_blocking(move || {
match from_server {
Some(server) => {
info.project_root = server.classpath.project_root;
info.module_paths = server.classpath.module_paths;
info.java_home = server.jdk_home.map(Into::into);
append_unique_class_paths(&mut class_paths, server.classpath.class_paths);
}
None => {
let is_maven = model
.maven
.as_ref()
.is_some_and(|m| m.projects.iter().any(|p| project.root.join(&p.dir) == module));
if !is_maven {
return Err(IdeError::unavailable(
"Cannot resolve the classpath: the Java language server does not report it \
(java-analyzer/projectClasspath), and the module is not a Maven project",
));
}
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
let classpath = compile::module_classpath(
&project.root,
&model,
&module,
test,
local_repo,
&project.build_cache_dir(),
&cancel,
)?;
append_unique_class_paths(
&mut class_paths,
std::env::split_paths(&classpath).map(|p| p.to_string_lossy().into_owned()),
);
}
}
info.class_paths = class_paths;
apply_library_classpath(&mut info, &project.root, &settings.project_structure.libraries, test);
finish_launch(&mut info, &project.root, &module, &settings, &model, &data_dir);
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
tracing::info!(build_ms, total_ms = started.elapsed().as_millis(), "Java launch resolved without jdtls");
Ok(info)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Picks the `java` launcher and how to shorten its command line, and explains likely
/// causes of compile errors.
fn finish_launch(
info: &mut JavaLaunchInfo,
root: &Path,
module: &Path,
settings: &Settings,
model: &BuildModel,
data_dir: &Path,
) {
// The module/project JDK, else the JDK the Java language server builds the module with, else one
// matching its Java version.
let project_jdk = ide_sdk::apply::module_jdk(root, module, settings);
let from_server = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_server).or_else(|| {
// The build model's level includes what the module inherits from its parent POMs.
let release = model
.maven
.as_ref()
.and_then(|m| m.projects.iter().find(|p| root.join(&p.dir) == module))
.and_then(|p| p.java_version)
.or_else(|| ide_sdk::java::project_java_version(module));
let jdks = ide_sdk::java::installed_jdks();
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
});
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
let exec = PathBuf::from(info.java_exec.as_deref().unwrap_or("java"));
let shorten = ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
info.shorten_command_line = Some(shorten.as_str().to_owned());
if info.error_count > 0 {
let own = ide_sdk::lombok::agent_in_args(settings.languages.java.jdtls_vm_args.split_whitespace());
let managed = ide_tools::managed_bundle(data_dir, "lombok");
let repo = ide_sdk::apply::maven_local_repository(root, settings);
// Detection may read the project's sources.
let lombok = ide_sdk::lombok::lombok_agent(root, own, managed, repo);
info.hints.extend(lombok.problem());
}
}
/// With Settings › Maven › Delegate IDE build/run actions to Maven, javac's verdict replaces
/// JDT's. Classes JDT wrote for sources with errors look up to date to Maven's incremental
/// compiler, so a launch JDT reports errors for recompiles everything.
@@ -496,21 +374,6 @@ fn use_snapshot_on(
copies
}
/// The debug adapter for the JVMs of `module`: `java-debug` inside jdtls, or `java-analyzer`
/// (`java-analyzer dap`) when jdtls doesn't serve the module and java-analyzer does.
#[command(trust = trusted)]
pub fn java_debug_adapter(host: &Host, window: &str, module: PathBuf) -> IdeResult<String> {
let project = host.project(window)?;
let module = project.root.join(module);
let lsp = &project.lsp;
Ok(if !lsp.java_served_by_jdtls(&module) && lsp.java_analyzer_binary(&module).is_some() {
ide_dap::adapter::JAVA_ANALYZER
} else {
"java-debug"
}
.to_owned())
}
/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).
#[command(trust = trusted)]
pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> IdeResult<u16> {
@@ -808,4 +671,4 @@ mod tests {
}
}
ide_command::domain!(java: java_build_workspace, java_debug_adapter, java_debug_server, java_resolve_launch);
ide_command::domain!(java: java_build_workspace, java_debug_server, java_resolve_launch);
+3 -15
Переглянути файл
@@ -359,22 +359,10 @@ pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: Got
if kind != GotoKind::Definition {
return result;
}
// A Maven placeholder (`@profileActive@` in `application.yml` or `.properties`) navigates to its pom.
let maven = super::maven_placeholder::definition(host, window, doc, pos).await;
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else {
return match maven {
None => result,
Some(found) => {
let in_string = in_string_literal(host, window, doc, pos).await;
definition_targets(result, vec![found], in_string)
}
};
};
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else { return result };
let found = plugin_call(move || plugins.provide_definition(&d, pos)).await.unwrap_or_default();
let found: Vec<Location> = maven
.into_iter()
.chain(found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }))
.collect();
let found: Vec<Location> =
found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }).collect();
let in_string = !found.is_empty() && in_string_literal(host, window, doc, pos).await;
definition_targets(result, found, in_string)
}
-154
Переглянути файл
@@ -1,154 +0,0 @@
//! ⌘B on a Maven resource-filtering placeholder: `@property@` in a YAML or properties
//! resource (Spring's `application.yml` / `application.properties`) jumps to the `<properties>` entry that defines it,
//! in the nearest `pom.xml` above the file, up through the project root. Parent
//! poms the nearest pom declares itself are followed from there; a parent outside
//! that walk that no pom declares is not.
use super::doc::blocking;
use crate::Host;
use ide_build::maven;
use ide_core::{DocId, Location, Pos};
use std::path::Path;
/// The definition location of the placeholder under `pos` in `doc`, when `doc` is a
/// YAML or properties file holding a `@token@` there and a pom above it defines that property.
pub(crate) async fn definition(host: &Host, window: &str, doc: DocId, pos: Pos) -> Option<Location> {
let project = host.project(window).ok()?;
blocking(move || {
let snap = project.documents.text_snapshot(doc)?;
if snap.large || !matches!(snap.language.as_str(), "yaml" | "properties") {
return Ok(None);
}
let path = project.documents.identity(doc)?.0;
let Some((name, _token_at)) = placeholder_at(&snap.text, pos) else { return Ok(None) };
Ok(pom_defining(&project.root, &path, &name))
})
.await
.ok()
.flatten()
}
/// The `@token@` enclosing `pos` on its line, with the token's range (UTF-16 columns).
fn placeholder_at(text: &str, pos: Pos) -> Option<(String, ide_core::Range)> {
let line = text.split_inclusive('\n').nth(pos.line as usize)?;
let line = line.trim_end_matches(['\n', '\r']);
let cursor = utf16_to_byte(line, pos.col)?;
let mut opener: Option<usize> = None;
for (i, b) in line.as_bytes().iter().enumerate() {
if *b != b'@' {
continue;
}
if let Some(start) = opener.replace(i) {
let token = &line[start + 1..i];
let valid =
!token.is_empty() && token.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'));
if valid && start <= cursor && cursor <= i {
let col = |byte: usize| line[..byte].encode_utf16().count() as u32;
return Some((
token.to_owned(),
ide_core::Range::new(Pos::new(pos.line, col(start)), Pos::new(pos.line, col(i + 1))),
));
}
opener = None;
}
}
None
}
/// The nearest `pom.xml` above `from` (up to and including `root`) defining `name`.
fn pom_defining(root: &Path, from: &Path, name: &str) -> Option<Location> {
let mut dir = from.parent()?.to_path_buf();
loop {
let pom = dir.join("pom.xml");
if pom.is_file()
&& let Some(found) = maven::property_declaration(&pom, name, maven::default_local_repo())
{
return Some(Location::file(found.path, found.range));
}
if dir == root || !dir.starts_with(root) {
return None;
}
dir = dir.parent()?.to_path_buf();
}
}
/// UTF-16 column → byte offset within one line.
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
let col = col as usize;
let mut units = 0usize;
for (byte, c) in line.char_indices() {
if units == col {
return Some(byte);
}
units += c.len_utf16();
if units > col {
return None;
}
}
(units == col).then_some(line.len())
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::Pos;
fn at(line: u32, col: u32) -> Pos {
Pos::new(line, col)
}
#[test]
fn finds_the_placeholder_under_the_cursor_and_its_range() {
let text = "spring:\n profiles:\n active: @profileActive@\n";
let (name, range) = placeholder_at(text, at(2, 20)).unwrap();
assert_eq!(name, "profileActive");
assert_eq!(range.start, at(2, 12));
assert_eq!(range.end, at(2, 27));
// The `@`s themselves and inside the token navigate; just past the token does not.
for col in [12u32, 13, 26] {
assert_eq!(placeholder_at(text, at(2, col)).unwrap().0, "profileActive");
}
// A second pair on the line and unrelated cursors stay unresolved.
let multi = "a: @one@ @two@\n";
assert_eq!(placeholder_at(multi, at(0, 4)).unwrap().0, "one");
assert_eq!(placeholder_at(multi, at(0, 10)).unwrap().0, "two");
assert!(placeholder_at(multi, at(0, 8)).is_none(), "between the pairs");
assert!(placeholder_at(multi, at(0, 9)).is_some(), "the opening @ of the next pair");
assert!(placeholder_at(multi, at(0, 14)).is_none(), "just past the last pair");
assert!(placeholder_at("value: plain\n", at(0, 7)).is_none());
}
#[test]
fn the_nearest_pom_wins_and_the_walk_stops_at_the_project_root() {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
let root = base.join("project");
let deep = root.join("core/src/main/resources");
std::fs::create_dir_all(&deep).unwrap();
std::fs::write(
root.join("pom.xml"),
"<project>\n <properties>\n <parentName>parent</parentName>\n </properties>\n</project>\n",
)
.unwrap();
std::fs::create_dir_all(root.join("core")).unwrap();
std::fs::write(
root.join("core/pom.xml"),
"<project>\n <properties>\n <name>module</name>\n </properties>\n</project>\n",
)
.unwrap();
let from = deep.join("application.yml");
// The module pom defines `name` first: its file wins, pointing at its `<name>` entry.
let found = pom_defining(&root, &from, "name").unwrap();
assert_eq!(found.path, root.join("core/pom.xml"));
assert_eq!(found.range.start.line, 2);
// A property only the parent defines resolves there; unknown ones resolve nowhere.
let parent = pom_defining(&root, &from, "parentName").unwrap();
assert_eq!(parent.path, root.join("pom.xml"));
assert_eq!(parent.range.start.line, 2);
assert!(pom_defining(&root, &from, "missing").is_none());
// A file outside the project root has no pom walk.
let outside = tmp.path().join("elsewhere/application.yml");
std::fs::create_dir_all(tmp.path().join("elsewhere")).unwrap();
assert!(pom_defining(&root, &outside, "name").is_none());
}
}
-5
Переглянути файл
@@ -15,14 +15,12 @@ pub mod deploy;
pub mod doc;
pub mod docker;
pub mod env;
pub mod flutter;
pub mod fs;
pub mod heap;
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;
@@ -86,14 +84,12 @@ ide_command::domains!(
doc_commands: crate::ops::doc::commands,
docker: crate::ops::docker,
env: crate::ops::env,
flutter: crate::ops::flutter,
fs: crate::ops::fs,
heap: crate::ops::heap,
history: crate::ops::history,
java: crate::ops::java,
jvm_icons: crate::ops::jvm_icons,
lsp: crate::ops::lsp,
mcp: crate::mcp::service,
mcp_reports: crate::mcp::reports,
nav: crate::ops::nav,
notebook: crate::ops::notebook,
@@ -101,7 +97,6 @@ ide_command::domains!(
plugins_commit: crate::plugins::commit,
plugins_index_ops: crate::plugins::index_ops,
plugins_run_targets: crate::plugins::run_targets,
plugins_search: crate::plugins::search,
plugins_views: crate::plugins::views,
project: crate::ops::project,
refactor: crate::ops::refactor,
-26
Переглянути файл
@@ -68,31 +68,6 @@ 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>> {
@@ -400,7 +375,6 @@ ide_command::domain!(
path_completions,
recent_files,
remove_recent,
scope_files,
web_goto,
web_unresolved_references,
);
+1 -21
Переглянути файл
@@ -80,13 +80,6 @@ pub fn settings_get(host: &Host, window: &str) -> Settings {
})
}
/// Defaults plus the global layer, without any project's values: what new
/// projects (and projects without their own value) get.
#[command(trust = always)]
pub fn settings_get_global(host: &Host) -> Settings {
host.with_proxy_password(host.global_settings.effective())
}
/// The removed built-in theme id a settings file of this window still names, if any:
/// `settings_get` reports the built-in that stands in for it, so the notice about
/// a theme that moved to a plugin can address the installs it concerns.
@@ -103,16 +96,13 @@ pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
/// re-reads its effective settings.
#[command(trust = always, desktop_body = sync)]
pub fn settings_set(
host: &Arc<Host>,
host: &Host,
window: &str,
scope: SettingsScope,
key: String,
value: String,
) -> IdeResult<Settings> {
let applied = set_settings(host, window, scope, &key, &value)?;
if key == "mcpServer" || key.starts_with("mcpServer.") {
host.mcp.apply(host);
}
let sink = host.window_sink(window);
sink.emit(IdeEvent::SettingsChanged { key });
if let Some(root) = applied.roots_changed {
@@ -312,15 +302,6 @@ 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);
}
@@ -396,7 +377,6 @@ ide_command::domain!(
project_trust_set,
project_trust_status,
settings_get,
settings_get_global,
settings_removed_theme,
settings_set,
);
+12 -12
Переглянути файл
@@ -34,9 +34,9 @@ pub struct ProjectInterpreter {
}
/// Installed interpreters / toolchains of `kind`; project-local ones first.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust_if_project(window)?;
host.require_trust(window)?;
let project = host.project(window).ok();
if kind == SdkKind::Jdk {
host.apply_added_jdks();
@@ -63,10 +63,10 @@ pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<V
}
/// The Python interpreters of the recently opened projects, each with its project.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeResult<Vec<ProjectInterpreter>> {
// Newest first. The open project is skipped: `sdk_detect` lists its own.
host.require_trust_if_project(window)?;
host.require_trust(window)?;
let current = host.project(window).ok().map(|p| p.root.clone());
let config = host.config_dir.clone();
// Probing runs the project's interpreter (and its settings may name any program): only
@@ -111,9 +111,9 @@ pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeRe
}
/// An existing Python executable or virtualenv folder as an SDK; `None` if Python cannot run.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<Sdk>> {
host.require_trust_if_project(window)?;
host.require_trust(window)?;
let root = host.project(window).ok().map(|p| p.root.clone());
tokio::task::spawn_blocking(move || Ok(ide_sdk::python_interpreter_sdk(&path, root.as_deref())))
.await
@@ -320,7 +320,7 @@ pub async fn sdk_locate_tools(
}
/// Creates a Python environment with `tool` (`venv` / `uv` / `poetry`); output streams through `on_output`.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn sdk_python_create_venv(
host: &Host,
window: &str,
@@ -330,7 +330,7 @@ pub async fn sdk_python_create_venv(
request: RequestId,
on_output: Channel<String>,
) -> IdeResult<Sdk> {
host.require_trust_if_project(window)?;
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
ide_sdk::python::create_venv(tool, &base, &location, &cancel, &|line| {
@@ -343,14 +343,14 @@ pub async fn sdk_python_create_venv(
result?
}
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn sdk_python_packages(
host: &Host,
window: &str,
python: PathBuf,
request: RequestId,
) -> IdeResult<Vec<PythonPackage>> {
host.require_trust_if_project(window)?;
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let result =
tokio::task::spawn_blocking(move || ide_sdk::python::list_packages(&python, &cancel)).await.map_err(join_err);
@@ -360,7 +360,7 @@ pub async fn sdk_python_packages(
/// Installs (`uninstall = false`) or removes a package; output streams through `on_output`.
#[allow(clippy::too_many_arguments)]
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn sdk_python_pip(
host: &Host,
window: &str,
@@ -371,7 +371,7 @@ pub async fn sdk_python_pip(
request: RequestId,
on_output: Channel<String>,
) -> IdeResult<()> {
host.require_trust_if_project(window)?;
host.require_trust(window)?;
let project_root = host.project(window).ok().map(|p| p.root.clone());
let cancel = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
+5 -12
Переглянути файл
@@ -34,10 +34,8 @@ 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 not searched, unless the query asks for them.
if !query.include_excluded {
query.exclude.extend(project.search_excludes());
}
// ignored names are never searched.
query.exclude.extend(project.search_excludes());
let cancel = host.begin_request(request);
let events = on_event.clone();
let syntax = host.syntax();
@@ -82,15 +80,10 @@ pub(crate) fn search_project(
query.scope,
ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. }
));
let content_roots: Vec<std::path::PathBuf> = match query.scope {
let content_roots = match query.scope {
ide_search::SearchScope::Project
| ide_search::SearchScope::FileSet { .. }
| 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(),
| ide_search::SearchScope::Pattern { .. } => project.content_roots(),
_ => within.into_iter().collect(),
};
let filter = |rel: &str| match set {
@@ -151,7 +144,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.
pub(crate) fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
let prefix = format!("{}/", prefix.trim_end_matches('/'));
masks
.iter()
+3 -6
Переглянути файл
@@ -15,9 +15,6 @@ impl ReplaceHost for DocumentsHost<'_> {
Some(doc) => (doc, false),
None => (docs.open(path)?.id, true),
};
// A buffer without unsaved changes (open only for the search preview, or a clean
// tab) is saved like a closed file; one the user is editing is left unsaved.
let save = transient || !docs.is_dirty(doc)?;
let result = (|| {
// Recompute if the user typed between reading the text and applying.
for _ in 0..3 {
@@ -30,7 +27,7 @@ impl ReplaceHost for DocumentsHost<'_> {
continue;
}
docs.apply_edits(doc, &edits)?;
if save {
if transient {
docs.save(doc)?;
}
return Ok(edits.len() as u32);
@@ -49,8 +46,8 @@ impl ReplaceHost for DocumentsHost<'_> {
///
/// Edits go through the document layer as one patch per file, so open editors
/// update live and undo the whole file's replacements in one step. Unsaved
/// editor buffers are replaced in place and left unsaved; other open documents
/// are saved, and files that were not open are opened transiently, saved and closed.
/// editor buffers are replaced in place and left unsaved; 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,
+6 -13
Переглянути файл
@@ -11,29 +11,22 @@ use std::path::PathBuf;
/// The installer, reporting the executables chosen in the window's settings.
fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
host.require_trust_if_project(window)?;
host.require_trust(window)?;
let data = host.local_data_dir.clone();
let (settings, root) = match host.project(window) {
Ok(project) => (project.settings.effective(), project.root.clone()),
Err(_) => (host.global_settings.effective(), Default::default()),
};
let mut custom: std::collections::BTreeMap<_, _> = settings
let custom = settings
.tools
.iter()
.filter_map(|(command, t)| Some((command.clone(), ide_sdk::apply::setting_path(&root, &t.path)?)))
.collect();
let langs = host.languages.all();
custom.extend(ide_sdk::apply::server_command_paths(
langs.iter().flat_map(|l| &l.language_servers),
&root,
&settings,
));
// Godot is usually an app bundle / Flatpak outside the search path.
let found = ide_sdk::godot::find(None).map(|p| (ide_sdk::godot::COMMAND.to_owned(), p));
let runtime = ide_sdk::apply::tool_install_environment(&root, &settings);
let work_dir = (!root.as_os_str().is_empty()).then_some(root);
Ok(Tools::new(&data)
.with_downloads(settings.tool_downloads.clone())
.with_runtime(runtime.commands, runtime.env)
.with_custom_paths(custom)
.with_found_paths(found.into_iter().collect())
@@ -63,7 +56,7 @@ fn reconfigure_servers(host: &Host) {
}
/// Status of every known language server / debug adapter and the languages using it.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
let tools = tools(host, window)?;
let langs = languages(host, window);
@@ -72,7 +65,7 @@ pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
/// Installs (or reinstalls) a tool into `<app-data>/tools`, streaming output through
/// `on_event`. Cancel with `cancel_request(request)`.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn tools_install(
host: &Host,
window: &str,
@@ -100,7 +93,7 @@ pub async fn tools_install(
/// Newer versions of the tools the IDE installed (release downloads and npm packages).
/// Cancel with `cancel_request(request)`.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> IdeResult<Vec<ToolUpdate>> {
let tools = tools(host, window)?;
let cancel = host.begin_request(request);
@@ -110,7 +103,7 @@ pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> Ide
}
/// Removes a tool the IDE installed.
#[command(trust = outside_restricted)]
#[command(trust = trusted)]
pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResult<ToolInfo> {
let tools = tools(host, window)?;
let langs = languages(host, window);
-2
Переглянути файл
@@ -18,7 +18,6 @@ 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()
})
@@ -41,7 +40,6 @@ 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)
})
-25
Переглянути файл
@@ -338,13 +338,6 @@ 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>> {
@@ -1068,22 +1061,6 @@ 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)]
@@ -1592,7 +1569,6 @@ 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,
@@ -1640,7 +1616,6 @@ ide_command::domain!(
vcs_revision_files,
vcs_reword,
vcs_roots,
vcs_detected_roots,
vcs_shelf_delete,
vcs_shelf_diff,
vcs_shelf_import,
+3 -10
Переглянути файл
@@ -47,19 +47,12 @@ pub async fn serves_page(url: &str) -> bool {
response.status().is_success() && html
}
/// The built-in server's URL for `path` (started on first use). A file whose language is
/// HTML (Settings › File Types can make it so) is served as a page, whatever its extension.
/// The built-in server's URL for `path` (started on first use).
#[command(trust = always)]
pub async fn web_url(host: &Host, window: &str, path: IpcPath) -> IdeResult<String> {
// Under the window's project when it holds the file.
let project = host.project(window).ok();
let root = project.as_ref().map(|p| p.root.as_path());
let languages = project.as_ref().map_or(&host.languages, |p| &p.languages);
if matches!(languages.detect(&path, None).as_str(), "html" | "django-html") {
host.web.page_url_for(root, &path).await
} else {
host.web.url_for(root, &path).await
}
let root = host.project(window).ok().map(|p| p.root.clone());
host.web.url_for(root.as_deref(), &path).await
}
#[cfg(test)]
-50
Переглянути файл
@@ -568,8 +568,6 @@ 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>>,
@@ -650,7 +648,6 @@ 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(),
@@ -877,9 +874,6 @@ 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);
@@ -1712,18 +1706,6 @@ 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,
@@ -3294,7 +3276,6 @@ 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());
@@ -4460,9 +4441,6 @@ 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)]
@@ -4634,34 +4612,6 @@ 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.
-7
Переглянути файл
@@ -184,12 +184,6 @@ 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(
@@ -302,7 +296,6 @@ 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,
-325
Переглянути файл
@@ -1,325 +0,0 @@
//! 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"));
}
}
+1 -3
Переглянути файл
@@ -162,8 +162,7 @@ impl PluginHost {
.collect()
}
/// What a plugin receives for `document-changed`: the path relative to the file's own
/// project, and that project's root, since two open projects can hold the same relative path.
/// What a plugin receives for `document-changed`: the path relative to the file's own project.
pub(super) fn relativize_documents(
shared: &super::api::Shared,
client: Option<&str>,
@@ -182,7 +181,6 @@ impl PluginHost {
.to_string_lossy()
.replace('\\', "/");
change.path = relative;
change.project = Some(ide_core::ipc_path::to_ipc(&root));
Some(WorkbenchEvent::DocumentChanged(change))
})
.collect()
+1 -1
Переглянути файл
@@ -30,7 +30,7 @@ pub(crate) fn validate_pattern(pattern: &str) -> Result<(), String> {
}
}
pub(crate) fn unsupported_construct(pattern: &str) -> Option<&'static str> {
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");
}
-7
Переглянути файл
@@ -20,7 +20,6 @@ mod auth;
mod build_graph;
pub mod commands;
pub mod commit;
mod console_rules;
mod database;
mod dependencies;
pub(crate) mod diagnostics;
@@ -51,7 +50,6 @@ pub mod remote;
pub mod remote_host;
mod run_detectors;
pub mod run_targets;
pub mod search;
mod semantic_tokens;
mod snippets;
mod theme;
@@ -440,11 +438,6 @@ 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)?;
-1
Переглянути файл
@@ -76,7 +76,6 @@ pub fn register_builtin_points(
registry.register(Arc::new(super::navigation::IndexersPoint))?;
registry.register(Arc::new(super::providers::ProvidersPoint::new(providers.clone())))?;
registry.register(Arc::new(UiPoint::new(super::providers::SECRETS_POINT, ui.clone(), super::providers::secret)))?;
registry.register(Arc::new(UiPoint::new(super::search::POINT, ui.clone(), super::search::declaration)))?;
registry.register(Arc::new(UiPoint::new(super::endpoints::POINT, ui.clone(), super::endpoints::declaration)))?;
registry.register(Arc::new(UiPoint::new(
"runConfigurations",
-1
Переглянути файл
@@ -144,7 +144,6 @@ pub fn forwarded(event: &PluginEvent) -> bool {
| PluginEvent::ContentTabReply { .. }
| PluginEvent::OpenDiff { .. }
| PluginEvent::DecorationsChanged { .. }
| PluginEvent::ConsoleRulesChanged { .. }
| PluginEvent::EditorOpen { .. }
| PluginEvent::EditorRanges { .. }
| PluginEvent::Notification { .. }
Loaded 100 of 938 files, more files were not shown because too many files have changed in this diff. Show more