дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-19 16:15:42 +02:00
Порівняти коміти
1
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
3c6f544280 |
No files matched your search
@@ -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`
|
||||
|
||||
@@ -213,31 +213,6 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
/// Availability for an explicit session switch must come from a recent discovery for this
|
||||
/// launch, not from the display fallback or a different project's session report.
|
||||
pub(super) fn fresh_model(
|
||||
&self,
|
||||
shared: &Shared,
|
||||
spec: &provider::ProviderSpec,
|
||||
model: &str,
|
||||
) -> Option<crate::AgentConfigValue> {
|
||||
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
|
||||
let select = |catalog: &CatalogData| {
|
||||
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
|
||||
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
|
||||
return None;
|
||||
}
|
||||
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
|
||||
};
|
||||
let state = self.state.lock();
|
||||
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
|
||||
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
|
||||
}
|
||||
let cache = shared.known.lock();
|
||||
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
|
||||
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
|
||||
}
|
||||
|
||||
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
let state = self.state.lock();
|
||||
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
|
||||
|
||||
@@ -11,7 +11,6 @@ const PROVIDER: &str = "catalog-test";
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Pending {
|
||||
launch: usize,
|
||||
method: String,
|
||||
params: Value,
|
||||
reply: oneshot::Sender<Result<Value, String>>,
|
||||
@@ -45,7 +44,7 @@ impl Harness {
|
||||
let launches = launches.clone();
|
||||
let live = live.clone();
|
||||
move |_, _, client, _| {
|
||||
let launch = launches.fetch_add(1, Ordering::SeqCst);
|
||||
launches.fetch_add(1, Ordering::SeqCst);
|
||||
live.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Live(live.clone());
|
||||
let pending = pending_tx.clone();
|
||||
@@ -76,17 +75,10 @@ impl Harness {
|
||||
}
|
||||
let response = match request["method"].as_str().unwrap() {
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
|
||||
"session/new"
|
||||
| "session/set_config_option"
|
||||
| "session/set_model"
|
||||
| "session/load"
|
||||
| "session/resume"
|
||||
| "session/prompt"
|
||||
| "session/set_mode" => {
|
||||
"session/new" | "session/set_config_option" | "session/set_model" => {
|
||||
let (reply, mut result) = oneshot::channel();
|
||||
pending
|
||||
.send(Pending {
|
||||
launch,
|
||||
method: request["method"].as_str().unwrap().to_owned(),
|
||||
params: request["params"].clone(),
|
||||
reply,
|
||||
@@ -298,223 +290,6 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_confirmed_by_the_live_session() {
|
||||
switch_chat_model(ChatSwitch::Live).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
|
||||
switch_chat_model(ChatSwitch::Resume).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
|
||||
switch_chat_model(ChatSwitch::ResumeFails).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
|
||||
switch_chat_model(ChatSwitch::Unavailable).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
|
||||
switch_chat_model(ChatSwitch::Idle).await;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum ChatSwitch {
|
||||
Live,
|
||||
Resume,
|
||||
ResumeFails,
|
||||
Unavailable,
|
||||
Idle,
|
||||
}
|
||||
|
||||
async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::with_initialize(json!({
|
||||
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
|
||||
}));
|
||||
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let task = manager
|
||||
.create(NewAgentTask {
|
||||
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
|
||||
provider: PROVIDER.into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
|
||||
let mut initial = response(&["old"], &["low", "high"]);
|
||||
initial["sessionId"] = json!("saved-chat");
|
||||
initial["modes"] = json!({
|
||||
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
|
||||
});
|
||||
next.reply.send(Ok(initial.clone())).unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(0, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let mode = manager.set_config(&task.id, "mode", "ask".into());
|
||||
tokio::pin!(mode);
|
||||
let set = next_chat_request(&mut harness, mode.as_mut()).await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
mode.await.unwrap();
|
||||
}
|
||||
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
|
||||
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
|
||||
if matches!(scenario, ChatSwitch::Idle) {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
}
|
||||
|
||||
let mut events = events(&manager);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
|
||||
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
|
||||
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
|
||||
|
||||
let live = matches!(scenario, ChatSwitch::Live);
|
||||
let offline = matches!(scenario, ChatSwitch::Idle);
|
||||
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
|
||||
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
}
|
||||
}
|
||||
// A fallback selection settles without waiting for a new process.
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not open another session: {request:?}"),
|
||||
}
|
||||
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
|
||||
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
|
||||
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
|
||||
|
||||
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
|
||||
if !live {
|
||||
let load = harness.next().await;
|
||||
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
|
||||
assert_eq!(load.params["sessionId"], "saved-chat");
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
|
||||
}}))
|
||||
.unwrap();
|
||||
if load_fails {
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "config_option_update",
|
||||
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
|
||||
}}))
|
||||
.unwrap();
|
||||
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
|
||||
} else {
|
||||
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
|
||||
let mut resumed = response(models, &["low", "high"]);
|
||||
resumed["modes"] = initial["modes"].clone();
|
||||
load.reply.send(Ok(resumed)).unwrap();
|
||||
}
|
||||
if load_fails || unavailable {
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
|
||||
let task = snapshot(&manager);
|
||||
assert_eq!(task.model.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
|
||||
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
|
||||
if load_fails {
|
||||
manager
|
||||
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
|
||||
.await
|
||||
.unwrap();
|
||||
let retry = harness.next().await;
|
||||
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
|
||||
assert_eq!(retry.params["sessionId"], "saved-chat");
|
||||
retry.reply.send(Ok(initial.clone())).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!(set.method, "session/set_mode");
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
let prompt = harness.next().await;
|
||||
assert_eq!(prompt.method, "session/prompt");
|
||||
assert_eq!(prompt.params["sessionId"], "saved-chat");
|
||||
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
}
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
}
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("new"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
|
||||
manager.shutdown();
|
||||
}
|
||||
|
||||
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
|
||||
let task = manager.task(id).unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while task.state.lock().task.status != status || task.state.lock().busy {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
async fn next_chat_request(
|
||||
harness: &mut Harness,
|
||||
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
|
||||
) -> Pending {
|
||||
tokio::select! {
|
||||
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
|
||||
request = harness.next() => request,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -219,23 +219,6 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
|
||||
}
|
||||
}
|
||||
|
||||
/// Legacy setters and agents that report the change in a notification may return no model.
|
||||
pub(super) fn accepts_model(reply: &Value, id: &str, value: &str) -> bool {
|
||||
reply
|
||||
.get("configOptions")
|
||||
.and_then(Value::as_array)
|
||||
.and_then(|options| {
|
||||
options.iter().find(|option| {
|
||||
option.get("category").and_then(Value::as_str) == Some("model")
|
||||
|| option.get("id").or_else(|| option.get("configId")).and_then(Value::as_str) == Some(id)
|
||||
})
|
||||
})
|
||||
.and_then(|option| option.get("currentValue"))
|
||||
.or_else(|| reply.pointer("/models/currentModelId"))
|
||||
.and_then(Value::as_str)
|
||||
.is_none_or(|current| current == value)
|
||||
}
|
||||
|
||||
/// `available_commands_update`.
|
||||
pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
|
||||
update
|
||||
|
||||
@@ -348,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>,
|
||||
@@ -362,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).
|
||||
@@ -383,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,
|
||||
@@ -402,24 +393,6 @@ struct TaskState {
|
||||
background_tasks: Vec<Value>,
|
||||
}
|
||||
|
||||
impl TaskState {
|
||||
fn pending_model(&self) -> Option<&AgentConfigChoice> {
|
||||
let id = self.pending_model.as_deref()?;
|
||||
self.wanted.iter().find(|c| c.id == id)
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> AgentTask {
|
||||
let mut task = self.task.clone();
|
||||
if let Some(choice) = self.pending_model()
|
||||
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
|
||||
{
|
||||
model.current = Some(choice.value.clone());
|
||||
task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
task
|
||||
}
|
||||
}
|
||||
|
||||
/// A running agent and its session.
|
||||
#[derive(Clone)]
|
||||
struct Live {
|
||||
@@ -546,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
|
||||
}
|
||||
@@ -777,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,
|
||||
@@ -892,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,
|
||||
@@ -1025,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
|
||||
@@ -1035,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
|
||||
@@ -1223,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,
|
||||
@@ -1268,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;
|
||||
@@ -1569,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))
|
||||
@@ -1612,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,
|
||||
@@ -1663,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() {
|
||||
@@ -1682,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.
|
||||
@@ -1692,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)
|
||||
@@ -1817,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();
|
||||
@@ -1875,12 +1748,10 @@ impl Task {
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
pending_model: file.pending_model,
|
||||
model_choice: 0,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
turn: file.turn.map(Arc::new),
|
||||
pending_rollback: file.pending_rollback,
|
||||
title_renamed: file.title_renamed,
|
||||
busy: false,
|
||||
@@ -1914,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();
|
||||
}
|
||||
@@ -1972,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) });
|
||||
}
|
||||
|
||||
@@ -2069,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,
|
||||
@@ -2125,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);
|
||||
@@ -2175,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 = {
|
||||
@@ -2183,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.
|
||||
@@ -2534,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);
|
||||
@@ -2548,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`",
|
||||
@@ -2558,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)
|
||||
@@ -2595,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))
|
||||
@@ -2645,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);
|
||||
@@ -2666,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!(
|
||||
@@ -2747,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 {
|
||||
@@ -2780,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;
|
||||
@@ -2799,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),
|
||||
}
|
||||
}
|
||||
@@ -2811,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);
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -2852,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();
|
||||
@@ -3639,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 {
|
||||
@@ -3827,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:?}");
|
||||
@@ -3967,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:?}");
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -536,9 +536,7 @@ impl PathMap {
|
||||
let abs = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
// rustc prints workspace members' files relative to the workspace root, above
|
||||
// the member's manifest directory (`base`) when a member is built on its own.
|
||||
let in_base = base.and_then(|b| Path::new(b).ancestors().map(|a| a.join(p)).find(|c| c.exists()));
|
||||
let in_base = base.map(|b| Path::new(b).join(p)).filter(|c| c.exists());
|
||||
in_base.unwrap_or_else(|| cwd.join(p))
|
||||
};
|
||||
let abs = normalize(&abs);
|
||||
@@ -715,7 +713,7 @@ pub fn run(
|
||||
}
|
||||
}
|
||||
};
|
||||
let out = process::run_bounded(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
|
||||
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
|
||||
let parsed = parser.feed(line);
|
||||
match parsed.console {
|
||||
Some(text) if text.is_empty() => {}
|
||||
@@ -757,7 +755,7 @@ pub fn run(
|
||||
if !out.success {
|
||||
success = false;
|
||||
if !messages.iter().any(|m| m.severity == Severity::Error) {
|
||||
let summary = crate::sync::error_summary(&out);
|
||||
let summary = crate::sync::error_summary(&out.text);
|
||||
let text = if summary.is_empty() { last_error_line.clone() } else { summary };
|
||||
let m = BuildMessage { severity: Severity::Error, text, path: None, range: None, code: None };
|
||||
on_event(BuildEvent::Message { message: m.clone() });
|
||||
@@ -1305,22 +1303,6 @@ mod tests {
|
||||
assert_eq!(identifier_len("x é_1 c", 2), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_a_member_build_s_workspace_relative_paths() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().to_path_buf();
|
||||
write(&root, "client/src/main.rs", "fn main() {}\n");
|
||||
write(&root, "client/src/lib.rs", "\n");
|
||||
write(&root, "src/lib.rs", "\n");
|
||||
let map = PathMap { root: root.clone(), canonical: None };
|
||||
let member = root.join("client");
|
||||
let base = member.to_str();
|
||||
// Build Module runs in the member; rustc names its files from the workspace root.
|
||||
assert_eq!(map.resolve("client/src/main.rs", &member, base), root.join("client/src/main.rs"));
|
||||
// A crate built from its own directory names them from there.
|
||||
assert_eq!(map.resolve("src/lib.rs", &member, base), member.join("src/lib.rs"));
|
||||
}
|
||||
|
||||
// Uses Unix absolute paths for the canonical root.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
|
||||
@@ -30,7 +30,6 @@ def processedResources = { Project p, s ->
|
||||
def describe = { Project p ->
|
||||
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
|
||||
if (p.gradle.parent != null) m.build = identity(p.rootProject)
|
||||
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
|
||||
// Gradle 4.x has it as a convention property, not an extension.
|
||||
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
|
||||
if (sets != null) {
|
||||
|
||||
@@ -41,10 +41,6 @@ pub struct GradleProject {
|
||||
/// Project-relative build script, if any.
|
||||
pub build_file: Option<String>,
|
||||
pub tasks: Vec<GradleTask>,
|
||||
/// Configurations Gradle can resolve, or null before Gradle reports the project.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub resolvable_configurations: Option<Vec<String>>,
|
||||
/// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
|
||||
/// `:buildSrc`); null for the opened build.
|
||||
#[serde(default)]
|
||||
@@ -305,7 +301,6 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
|
||||
path,
|
||||
name,
|
||||
tasks,
|
||||
resolvable_configurations: None,
|
||||
build: None,
|
||||
}
|
||||
}
|
||||
@@ -322,8 +317,6 @@ pub struct ReportedProject {
|
||||
pub build_dir: Option<String>,
|
||||
#[serde(default)]
|
||||
pub source_sets: Vec<ReportedSourceSet>,
|
||||
#[serde(default)]
|
||||
pub resolvable_configurations: Option<Vec<String>>,
|
||||
/// Toolchain language version, else target compatibility.
|
||||
#[serde(default)]
|
||||
pub java: Option<u32>,
|
||||
@@ -419,7 +412,6 @@ pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &
|
||||
if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
|
||||
project.tasks.clear();
|
||||
}
|
||||
project.resolvable_configurations = p.resolvable_configurations.clone();
|
||||
project.build = p.build.clone();
|
||||
project
|
||||
})
|
||||
@@ -1638,11 +1630,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
|
||||
path: path.into(),
|
||||
dir: ws.join(d).to_string_lossy().into_owned(),
|
||||
build: build.map(Into::into),
|
||||
resolvable_configurations: match path {
|
||||
":" => Some(vec!["reviewTools".into(), "runtimeClasspath".into()]),
|
||||
":lib:core" => Some(Vec::new()),
|
||||
_ => None,
|
||||
},
|
||||
..ReportedProject::default()
|
||||
};
|
||||
format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
|
||||
@@ -1671,12 +1658,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
|
||||
);
|
||||
let build_src = &model.projects[2];
|
||||
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
|
||||
assert_eq!(
|
||||
model.projects[0].resolvable_configurations,
|
||||
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
|
||||
);
|
||||
assert_eq!(model.projects[1].resolvable_configurations, None);
|
||||
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
|
||||
assert!(!model.projects[4].tasks.is_empty());
|
||||
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
|
||||
}
|
||||
|
||||
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
|
||||
configuration: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<GradleDependency>> {
|
||||
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
|
||||
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
|
||||
return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
|
||||
}
|
||||
if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
|
||||
@@ -143,7 +143,7 @@ pub fn gradle_dependencies(
|
||||
}
|
||||
let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
|
||||
let mut args: Vec<String> =
|
||||
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
|
||||
vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
|
||||
if options.offline {
|
||||
args.push("--offline".into());
|
||||
}
|
||||
@@ -156,10 +156,7 @@ pub fn gradle_dependencies(
|
||||
|_, _| {},
|
||||
)?;
|
||||
if !out.success {
|
||||
return Err(IdeError::unavailable(error_summary(&out)));
|
||||
}
|
||||
if let Some(note) = sync::truncation_note(&out) {
|
||||
return Err(IdeError::unavailable(note));
|
||||
return Err(IdeError::unavailable(error_summary(&out.text)));
|
||||
}
|
||||
Ok(parse_report(&out.text))
|
||||
}
|
||||
@@ -340,14 +337,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
|
||||
&gradle::load(root).unwrap(),
|
||||
&options,
|
||||
":app",
|
||||
"review.tools",
|
||||
"testRuntimeClasspath",
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(root.join("args")).unwrap().trim(),
|
||||
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
|
||||
"--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -13,8 +13,6 @@ pub mod kotlin_bridge;
|
||||
pub mod maven;
|
||||
pub mod pom_edit;
|
||||
mod process;
|
||||
#[cfg(test)]
|
||||
mod process_numbers;
|
||||
pub mod sbt;
|
||||
mod sync;
|
||||
pub mod web;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
|
||||
//! run it on both revisions of `process.rs` and compare the printed numbers.
|
||||
//!
|
||||
//! ```text
|
||||
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
|
||||
//! ```
|
||||
|
||||
use crate::process;
|
||||
use ide_core::CancellationToken;
|
||||
use std::collections::BTreeMap;
|
||||
use std::time::Instant;
|
||||
|
||||
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
|
||||
#[test]
|
||||
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
|
||||
fn high_output_process_numbers() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
|
||||
let start = Instant::now();
|
||||
let mut lines = 0u64;
|
||||
let mut fed = 0usize;
|
||||
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
lines += 1;
|
||||
fed += line.len() + 1;
|
||||
})
|
||||
.unwrap();
|
||||
println!(
|
||||
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
|
||||
start.elapsed(),
|
||||
out.success,
|
||||
out.text.len()
|
||||
);
|
||||
}
|
||||
@@ -268,20 +268,8 @@ fn run(
|
||||
process::run(program, args, cwd, env, cancel, |_, line| on_line(line))
|
||||
}
|
||||
|
||||
/// What a sync records when a *successful* child run's output was truncated: parsing a
|
||||
/// truncated listing would silently produce an incomplete model, so it is surfaced, not hidden.
|
||||
pub(crate) fn truncation_note(out: &Output) -> Option<String> {
|
||||
out.truncated.then(|| {
|
||||
format!(
|
||||
"the build printed more than the retained {} MiB of output; the model may be incomplete",
|
||||
crate::process::MAX_TEXT_BYTES / (1024 * 1024)
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// The first error lines of a failed build, for the tool window.
|
||||
pub(crate) fn error_summary(output: &Output) -> String {
|
||||
let text = &output.text;
|
||||
pub(crate) fn error_summary(text: &str) -> String {
|
||||
// The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
|
||||
if text.contains("org.gradle.wrapper.GradleWrapperMain") {
|
||||
return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
|
||||
@@ -301,15 +289,11 @@ pub(crate) fn error_summary(output: &Output) -> String {
|
||||
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
|
||||
.take(4)
|
||||
.collect();
|
||||
let mut summary = if lines.is_empty() {
|
||||
if lines.is_empty() {
|
||||
text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("the build failed").trim().to_owned()
|
||||
} else {
|
||||
lines.join("\n")
|
||||
};
|
||||
if output.truncated {
|
||||
summary.push_str("\n[the build printed more than the retained output; this summary may miss lines]");
|
||||
}
|
||||
summary
|
||||
}
|
||||
|
||||
/// `[INFO] Building core 1.0-SNAPSHOT [2/3]` → ("core 1.0-SNAPSHOT", 2, 3).
|
||||
@@ -413,9 +397,7 @@ pub fn sync_maven(
|
||||
}
|
||||
}
|
||||
if !out.success {
|
||||
errors.push(error_summary(&out));
|
||||
} else if let Some(note) = truncation_note(&out) {
|
||||
errors.push(note);
|
||||
errors.push(error_summary(&out.text));
|
||||
}
|
||||
}
|
||||
cache.at_ms = now_ms();
|
||||
@@ -455,8 +437,6 @@ pub fn sync_gradle_model(
|
||||
let mut args: Vec<String> = vec![
|
||||
"--console=plain".into(),
|
||||
"-q".into(),
|
||||
// The init script reports the evaluated projects, even when a build enables the configuration cache.
|
||||
"-Dorg.gradle.configuration-cache=false".into(),
|
||||
"--init-script".into(),
|
||||
init_script.to_string_lossy().into_owned(),
|
||||
"tasks".into(),
|
||||
@@ -477,7 +457,7 @@ pub fn sync_gradle_model(
|
||||
Ok(out) => out,
|
||||
Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
|
||||
Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
|
||||
Output { success: false, text: error.message, truncated: false }
|
||||
Output { success: false, text: error.message }
|
||||
}
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
@@ -490,7 +470,7 @@ pub fn sync_gradle_model(
|
||||
let cache = GradleCache {
|
||||
hash: hash_gradle_files(&gradle::build_files(root, &model)),
|
||||
at_ms: now_ms(),
|
||||
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
|
||||
error: (!out.success).then(|| error_summary(&out.text)),
|
||||
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
|
||||
projects,
|
||||
resources: true,
|
||||
@@ -934,22 +914,10 @@ mod tests {
|
||||
);
|
||||
assert_eq!(maven_building("[INFO] Building jar: x.jar"), None);
|
||||
let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
|
||||
let out = |text: &str, truncated| crate::process::Output { success: false, text: text.to_owned(), truncated };
|
||||
assert_eq!(error_summary(&out(text, false)), "Failed to execute goal");
|
||||
assert_eq!(error_summary(&out("one\nlast line\n\n", false)), "last line");
|
||||
assert_eq!(error_summary(text), "Failed to execute goal");
|
||||
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
|
||||
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
|
||||
assert!(error_summary(&out(missing_jar, false)).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
|
||||
// A truncated capture says so instead of hiding that lines are missing.
|
||||
assert!(error_summary(&out(text, true)).ends_with("this summary may miss lines]"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_truncated_successful_run_is_surfaced_not_silent() {
|
||||
let out = |truncated| crate::process::Output { success: true, text: String::new(), truncated };
|
||||
assert!(truncation_note(&out(false)).is_none());
|
||||
let note = truncation_note(&out(true)).unwrap();
|
||||
assert!(note.starts_with("the build printed more than the retained 32 MiB"), "{note}");
|
||||
assert!(note.ends_with("the model may be incomplete"));
|
||||
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -18,21 +18,14 @@ struct State {
|
||||
database: String,
|
||||
settings: Vec<(String, String)>,
|
||||
read_only: bool,
|
||||
session: Mutex<Session>,
|
||||
session_id: String,
|
||||
session: Mutex<bool>,
|
||||
closed: CancellationToken,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Session {
|
||||
id: Option<String>,
|
||||
initialized: bool,
|
||||
strict_read_only: bool,
|
||||
}
|
||||
|
||||
/// The response format: a names line, a types line, then one JSON array per row, so rows past
|
||||
/// the grid's limit are skipped without being parsed.
|
||||
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
|
||||
const SESSION_LOST: &str = "ClickHouse HTTP session not found on this node (code 372). Use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
|
||||
|
||||
pub(crate) fn transaction_error() -> IdeError {
|
||||
IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
|
||||
@@ -43,32 +36,11 @@ impl ClickhousePool {
|
||||
if source.options.transaction == DbTxMode::Manual {
|
||||
return Err(transaction_error());
|
||||
}
|
||||
let mut use_http_session = None;
|
||||
let mut settings = Vec::with_capacity(setup.params.len());
|
||||
for (name, value) in setup.params {
|
||||
if name.eq_ignore_ascii_case("use_http_session") {
|
||||
if use_http_session.is_some() {
|
||||
return Err(IdeError::invalid("ClickHouse use_http_session must be specified only once"));
|
||||
}
|
||||
use_http_session = Some(if value.eq_ignore_ascii_case("true") {
|
||||
true
|
||||
} else if value.eq_ignore_ascii_case("false") {
|
||||
false
|
||||
} else {
|
||||
return Err(IdeError::invalid("ClickHouse use_http_session must be true or false"));
|
||||
});
|
||||
} else if reserved_setting(&name) {
|
||||
for (name, _) in &setup.params {
|
||||
if reserved_setting(name) {
|
||||
return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
|
||||
} else {
|
||||
settings.push((name, value));
|
||||
}
|
||||
}
|
||||
let use_http_session = use_http_session.unwrap_or(true);
|
||||
if !use_http_session && (!setup.statements.is_empty() || !source.options.startup_script.trim().is_empty()) {
|
||||
return Err(IdeError::invalid(
|
||||
"ClickHouse use_http_session=false does not support startup scripts; configure database and settings on the data source for each request",
|
||||
));
|
||||
}
|
||||
let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
|
||||
let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
|
||||
if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
|
||||
@@ -134,49 +106,15 @@ impl ClickhousePool {
|
||||
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
|
||||
password: password.unwrap_or_default().to_owned(),
|
||||
database: if database.is_empty() { "default".into() } else { database.into() },
|
||||
settings,
|
||||
settings: setup.params,
|
||||
read_only: source.read_only,
|
||||
session: Mutex::new(Session {
|
||||
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
|
||||
..Session::default()
|
||||
}),
|
||||
session_id: uuid::Uuid::new_v4().to_string(),
|
||||
session: Mutex::new(false),
|
||||
closed: CancellationToken::new(),
|
||||
}));
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
if !rejects_driver_setting(&error) {
|
||||
return Err(error);
|
||||
}
|
||||
if !use_http_session {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
// USE once so later queries inherit the selection (and may change it).
|
||||
if use_http_session && !database.is_empty() {
|
||||
let name = crate::sql::quote_ident(crate::DbDriver::Clickhouse, database);
|
||||
pool.execute(&format!("USE {name}"), 0, &cancel).await?;
|
||||
}
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
for sql in setup.statements {
|
||||
pool.execute(&sql, 0, &cancel).await?;
|
||||
}
|
||||
@@ -213,30 +151,27 @@ impl ClickhousePool {
|
||||
}
|
||||
|
||||
/// `max_rows`: the rows the server may send (the skipped ones included).
|
||||
fn request(&self, client: &Client, query_id: &str, max_rows: usize, session: &Session) -> RequestBuilder {
|
||||
fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
|
||||
let mut request = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
|
||||
.query(&self.0.settings)
|
||||
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
|
||||
if !session.strict_read_only {
|
||||
request = request.query(&[
|
||||
.query(&[
|
||||
("session_id", self.0.session_id.clone()),
|
||||
("session_timeout", "3600".into()),
|
||||
("query_id", query_id.to_owned()),
|
||||
("default_format", FORMAT.into()),
|
||||
("output_format_json_quote_denormals", "1".into()),
|
||||
("max_result_rows", max_rows.saturating_add(1).to_string()),
|
||||
("result_overflow_mode", "break".into()),
|
||||
]);
|
||||
}
|
||||
if let Some(session_id) = &session.id {
|
||||
request = request.query(&[("session_id", session_id.as_str()), ("session_timeout", "3600")]);
|
||||
if session.initialized {
|
||||
request = request.query(&[("session_check", "1")]);
|
||||
}
|
||||
}
|
||||
if session.id.is_none() || !session.initialized {
|
||||
if initialized {
|
||||
request = request.query(&[("session_check", "1")]);
|
||||
} else {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
if self.0.read_only {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -265,7 +200,7 @@ impl ClickhousePool {
|
||||
};
|
||||
let client = self.client()?;
|
||||
let query_id = uuid::Uuid::new_v4().to_string();
|
||||
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), &session).body(sql.to_owned());
|
||||
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), *session).body(sql.to_owned());
|
||||
let started = Instant::now();
|
||||
let fetch = async {
|
||||
let mut response = request.send().await.map_err(http_error)?;
|
||||
@@ -319,7 +254,7 @@ impl ClickhousePool {
|
||||
match result {
|
||||
Some(result) => {
|
||||
if result.is_ok() {
|
||||
session.initialized = true;
|
||||
*session = true;
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -372,7 +307,11 @@ impl ClickhousePool {
|
||||
let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
|
||||
|| matches!(code, Some("193" | "194" | "195" | "516" | "497"));
|
||||
let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
|
||||
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
|
||||
let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
|
||||
"ClickHouse HTTP session expired; reconnect to restore session settings"
|
||||
} else {
|
||||
detail
|
||||
};
|
||||
self.redact_error(IdeError::new(
|
||||
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
|
||||
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
|
||||
@@ -384,9 +323,9 @@ type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);
|
||||
|
||||
/// Decodes a streamed [`FORMAT`] body. Reads past the first `skip` rows unparsed (a later
|
||||
/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
|
||||
/// unparsed, so a grid limit bounds memory even if a strict read-only server does not allow
|
||||
/// per-query result limits. A line that is not a JSON array starts the exception ClickHouse
|
||||
/// writes when a query fails mid-stream.
|
||||
/// unparsed, so a grid limit bounds memory however large the block
|
||||
/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
|
||||
/// starts the exception ClickHouse writes when a query fails mid-stream.
|
||||
struct RowReader {
|
||||
skip: usize,
|
||||
max_rows: usize,
|
||||
@@ -494,11 +433,7 @@ impl RowReader {
|
||||
let rest = std::mem::take(&mut self.pending);
|
||||
self.line(&rest)?;
|
||||
if let Some(exception) = self.exception {
|
||||
let detail = exception_text(&exception);
|
||||
return Err(IdeError::invalid(format!(
|
||||
"ClickHouse: {}",
|
||||
if session_not_found(detail) { SESSION_LOST } else { detail }
|
||||
)));
|
||||
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
|
||||
}
|
||||
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
|
||||
let types = self.types.unwrap_or_default();
|
||||
@@ -510,13 +445,6 @@ impl RowReader {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a server message reports a named HTTP session this node doesn't have.
|
||||
fn session_not_found(detail: &str) -> bool {
|
||||
detail.starts_with("Code: 372.")
|
||||
|| detail.starts_with("Session not found")
|
||||
|| detail.starts_with("SESSION_NOT_FOUND")
|
||||
}
|
||||
|
||||
/// The server's message in a failed response: rows already streamed and the
|
||||
/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
|
||||
fn exception_text(body: &str) -> &str {
|
||||
@@ -551,20 +479,6 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.is_some_and(|(name, _)| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
fn reserved_setting(name: &str) -> bool {
|
||||
let name = name.to_ascii_lowercase();
|
||||
name.starts_with("output_format_json_")
|
||||
@@ -661,19 +575,6 @@ mod tests {
|
||||
DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
|
||||
}
|
||||
|
||||
fn property(name: &str, value: &str) -> DbProperty {
|
||||
DbProperty { name: name.into(), value: value.into() }
|
||||
}
|
||||
|
||||
fn request_url(request: &str) -> Url {
|
||||
let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
Url::parse(&format!("http://localhost{target}")).unwrap()
|
||||
}
|
||||
|
||||
fn query_value(url: &Url, key: &str) -> Option<String> {
|
||||
url.query_pairs().find(|(name, _)| name == key).map(|(_, value)| value.into_owned())
|
||||
}
|
||||
|
||||
fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
|
||||
decode_from(body, 0, max_rows, chunk)
|
||||
}
|
||||
@@ -752,7 +653,6 @@ mod tests {
|
||||
let (port, requests) = server(vec![
|
||||
("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
|
||||
("200 OK", "", ""),
|
||||
("200 OK", "", ""),
|
||||
(
|
||||
"200 OK",
|
||||
"X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
|
||||
@@ -764,7 +664,7 @@ mod tests {
|
||||
user: "reader".into(),
|
||||
read_only: true,
|
||||
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
|
||||
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
|
||||
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
|
||||
@@ -787,7 +687,7 @@ mod tests {
|
||||
assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
|
||||
assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
|
||||
assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
|
||||
assert_eq!(value(&urls[3], "max_result_rows").as_deref(), Some("2"));
|
||||
assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
|
||||
for (request, url) in requests.iter().zip(&urls) {
|
||||
assert!(request.starts_with("POST /?"));
|
||||
assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
|
||||
@@ -795,10 +695,8 @@ mod tests {
|
||||
assert_eq!(value(url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
|
||||
assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(value(url, "use_http_session"), None);
|
||||
}
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("USE `analytics`"));
|
||||
assert!(pool.transaction(&[]).await.is_err());
|
||||
let cancel = CancellationToken::new();
|
||||
cancel.cancel();
|
||||
@@ -808,71 +706,6 @@ mod tests {
|
||||
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_requests_keep_database_settings_readonly_and_limits() {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE); 3]).await;
|
||||
let source = DataSource {
|
||||
database: "configured_database".into(),
|
||||
read_only: true,
|
||||
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
pool.execute("SELECT 2", 2, &CancellationToken::new()).await.unwrap();
|
||||
pool.execute("SELECT 3", 3, &CancellationToken::new()).await.unwrap();
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
let mut query_ids = std::collections::HashSet::new();
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name} must not be sent in stateless mode");
|
||||
}
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("analytics"));
|
||||
assert_eq!(query_value(&url, "session_timezone").as_deref(), Some("UTC"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "max_result_rows"), Some((index + 2).to_string()));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), Some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "default_format").as_deref(), Some(FORMAT));
|
||||
assert!(query_ids.insert(query_value(&url, "query_id").unwrap()));
|
||||
assert!(request.ends_with(&format!("SELECT {}", index + 1)));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn default_session_expiry_never_recreates_the_session_or_replays_sql() {
|
||||
for failure in [
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 372\r\n", "session unavailable"),
|
||||
("500 Internal Server Error", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
|
||||
("200 OK", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
|
||||
] {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE), failure, ("200 OK", "", ONE)]).await;
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let sql = "INSERT INTO events VALUES (1)";
|
||||
let error = pool.execute(sql, 0, &CancellationToken::new()).await.unwrap_err();
|
||||
assert!(error.message.contains("372"));
|
||||
assert!(error.message.contains("one node or session affinity"));
|
||||
assert!(error.message.contains("use_http_session=false"));
|
||||
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 3);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with(sql));
|
||||
assert!(requests[2].ends_with("SELECT 1"));
|
||||
let session_id = query_value(&request_url(&requests[0]), "session_id").unwrap();
|
||||
for request in &requests[1..] {
|
||||
let url = request_url(request);
|
||||
assert_eq!(query_value(&url, "session_id").as_deref(), Some(session_id.as_str()));
|
||||
assert_eq!(query_value(&url, "session_check").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database"), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sequential_queries_reuse_the_http_connection() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
@@ -893,144 +726,6 @@ mod tests {
|
||||
task.await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn connects_when_server_forbids_settings_in_readonly_mode() {
|
||||
let (port, requests) = server(vec![
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'output_format_json_quote_denormals' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", ONE),
|
||||
("200 OK", "", ""),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "system".into(),
|
||||
read_only: true,
|
||||
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let result = pool.execute("SELECT number FROM numbers(2)", 1, &CancellationToken::new()).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into())]]);
|
||||
assert!(result.has_more);
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[0].contains("output_format_json_quote_denormals=1"));
|
||||
assert!(requests[1].ends_with("SELECT getSetting('readonly')"));
|
||||
assert!(!requests[1].contains("session_check="));
|
||||
assert_eq!(query_value(&request_url(&requests[1]), "database").as_deref(), Some("system"));
|
||||
assert!(requests[2].contains("session_check=1"));
|
||||
let session_id = query_value(&request_url(&requests[1]), "session_id").unwrap();
|
||||
assert_ne!(query_value(&request_url(&requests[0]), "session_id").as_deref(), Some(session_id.as_str()));
|
||||
for request in &requests[1..] {
|
||||
assert_eq!(query_value(&request_url(request), "session_id").as_deref(), Some(session_id.as_str()));
|
||||
assert!(request.contains("default_format=JSONCompactEachRowWithNamesAndTypes"));
|
||||
assert!(request.contains("max_threads=2"));
|
||||
for setting in
|
||||
["output_format_json_quote_denormals=", "max_result_rows=", "result_overflow_mode=", "readonly="]
|
||||
{
|
||||
assert!(!request.contains(setting), "{setting} is not allowed in a strict read-only session");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
)])
|
||||
.await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
let url = request_url(&requests[0]);
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), read_only.then_some("1"));
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn incompatible_stateless_options_are_rejected_before_connecting() {
|
||||
for (properties, startup_script, expected) in [
|
||||
(vec![property("use_http_session", "false")], "SET max_threads = 2", "does not support startup scripts"),
|
||||
(vec![property("use_http_session", "invalid")], "", "must be true or false"),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("USE_HTTP_SESSION", "true")],
|
||||
"",
|
||||
"must be specified only once",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_id", "custom")],
|
||||
"",
|
||||
"manages the session_id",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_check", "0")],
|
||||
"",
|
||||
"manages the session_check",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_timeout", "60")],
|
||||
"",
|
||||
"manages the session_timeout",
|
||||
),
|
||||
] {
|
||||
let source = DataSource {
|
||||
properties,
|
||||
options: DbOptions { startup_script: startup_script.into(), ..Default::default() },
|
||||
..source(1)
|
||||
};
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("incompatible options must fail");
|
||||
assert!(error.message.contains(expected), "{}", error.message);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn readonly_probe_does_not_disable_settings_on_a_writable_session() {
|
||||
let (port, requests) = server(vec![
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"readonly\"]\n[\"UInt64\"]\n[0]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource { read_only: true, ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("writable session must stay rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(requests.await.unwrap()[1].ends_with("SELECT getSetting('readonly')"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn readonly_probe_matches_only_the_driver_settings() {
|
||||
for (code, setting, expected) in [
|
||||
(164, "max_result_rows", true),
|
||||
(164, "result_overflow_mode", true),
|
||||
(164, "readonly", true),
|
||||
(164, "max_threads", false),
|
||||
(516, "max_result_rows", false),
|
||||
] {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn server_errors_keep_details_and_hide_passwords() {
|
||||
let (port, requests) = server(vec![(
|
||||
|
||||
@@ -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))),
|
||||
|
||||
@@ -369,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.
|
||||
@@ -393,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.
|
||||
|
||||
@@ -359,22 +359,10 @@ pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: Got
|
||||
if kind != GotoKind::Definition {
|
||||
return result;
|
||||
}
|
||||
// A Maven placeholder (`@profileActive@` in `application.yml` or `.properties`) navigates to its pom.
|
||||
let maven = super::maven_placeholder::definition(host, window, doc, pos).await;
|
||||
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else {
|
||||
return match maven {
|
||||
None => result,
|
||||
Some(found) => {
|
||||
let in_string = in_string_literal(host, window, doc, pos).await;
|
||||
definition_targets(result, vec![found], in_string)
|
||||
}
|
||||
};
|
||||
};
|
||||
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else { return result };
|
||||
let found = plugin_call(move || plugins.provide_definition(&d, pos)).await.unwrap_or_default();
|
||||
let found: Vec<Location> = maven
|
||||
.into_iter()
|
||||
.chain(found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }))
|
||||
.collect();
|
||||
let found: Vec<Location> =
|
||||
found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }).collect();
|
||||
let in_string = !found.is_empty() && in_string_literal(host, window, doc, pos).await;
|
||||
definition_targets(result, found, in_string)
|
||||
}
|
||||
|
||||
@@ -1,154 +0,0 @@
|
||||
//! ⌘B on a Maven resource-filtering placeholder: `@property@` in a YAML or properties
|
||||
//! resource (Spring's `application.yml` / `application.properties`) jumps to the `<properties>` entry that defines it,
|
||||
//! in the nearest `pom.xml` above the file, up through the project root. Parent
|
||||
//! poms the nearest pom declares itself are followed from there; a parent outside
|
||||
//! that walk that no pom declares is not.
|
||||
|
||||
use super::doc::blocking;
|
||||
use crate::Host;
|
||||
use ide_build::maven;
|
||||
use ide_core::{DocId, Location, Pos};
|
||||
use std::path::Path;
|
||||
|
||||
/// The definition location of the placeholder under `pos` in `doc`, when `doc` is a
|
||||
/// YAML or properties file holding a `@token@` there and a pom above it defines that property.
|
||||
pub(crate) async fn definition(host: &Host, window: &str, doc: DocId, pos: Pos) -> Option<Location> {
|
||||
let project = host.project(window).ok()?;
|
||||
blocking(move || {
|
||||
let snap = project.documents.text_snapshot(doc)?;
|
||||
if snap.large || !matches!(snap.language.as_str(), "yaml" | "properties") {
|
||||
return Ok(None);
|
||||
}
|
||||
let path = project.documents.identity(doc)?.0;
|
||||
let Some((name, _token_at)) = placeholder_at(&snap.text, pos) else { return Ok(None) };
|
||||
Ok(pom_defining(&project.root, &path, &name))
|
||||
})
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
}
|
||||
|
||||
/// The `@token@` enclosing `pos` on its line, with the token's range (UTF-16 columns).
|
||||
fn placeholder_at(text: &str, pos: Pos) -> Option<(String, ide_core::Range)> {
|
||||
let line = text.split_inclusive('\n').nth(pos.line as usize)?;
|
||||
let line = line.trim_end_matches(['\n', '\r']);
|
||||
let cursor = utf16_to_byte(line, pos.col)?;
|
||||
let mut opener: Option<usize> = None;
|
||||
for (i, b) in line.as_bytes().iter().enumerate() {
|
||||
if *b != b'@' {
|
||||
continue;
|
||||
}
|
||||
if let Some(start) = opener.replace(i) {
|
||||
let token = &line[start + 1..i];
|
||||
let valid =
|
||||
!token.is_empty() && token.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'));
|
||||
if valid && start <= cursor && cursor <= i {
|
||||
let col = |byte: usize| line[..byte].encode_utf16().count() as u32;
|
||||
return Some((
|
||||
token.to_owned(),
|
||||
ide_core::Range::new(Pos::new(pos.line, col(start)), Pos::new(pos.line, col(i + 1))),
|
||||
));
|
||||
}
|
||||
opener = None;
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The nearest `pom.xml` above `from` (up to and including `root`) defining `name`.
|
||||
fn pom_defining(root: &Path, from: &Path, name: &str) -> Option<Location> {
|
||||
let mut dir = from.parent()?.to_path_buf();
|
||||
loop {
|
||||
let pom = dir.join("pom.xml");
|
||||
if pom.is_file()
|
||||
&& let Some(found) = maven::property_declaration(&pom, name, maven::default_local_repo())
|
||||
{
|
||||
return Some(Location::file(found.path, found.range));
|
||||
}
|
||||
if dir == root || !dir.starts_with(root) {
|
||||
return None;
|
||||
}
|
||||
dir = dir.parent()?.to_path_buf();
|
||||
}
|
||||
}
|
||||
|
||||
/// UTF-16 column → byte offset within one line.
|
||||
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
|
||||
let col = col as usize;
|
||||
let mut units = 0usize;
|
||||
for (byte, c) in line.char_indices() {
|
||||
if units == col {
|
||||
return Some(byte);
|
||||
}
|
||||
units += c.len_utf16();
|
||||
if units > col {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
(units == col).then_some(line.len())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::Pos;
|
||||
|
||||
fn at(line: u32, col: u32) -> Pos {
|
||||
Pos::new(line, col)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finds_the_placeholder_under_the_cursor_and_its_range() {
|
||||
let text = "spring:\n profiles:\n active: @profileActive@\n";
|
||||
let (name, range) = placeholder_at(text, at(2, 20)).unwrap();
|
||||
assert_eq!(name, "profileActive");
|
||||
assert_eq!(range.start, at(2, 12));
|
||||
assert_eq!(range.end, at(2, 27));
|
||||
// The `@`s themselves and inside the token navigate; just past the token does not.
|
||||
for col in [12u32, 13, 26] {
|
||||
assert_eq!(placeholder_at(text, at(2, col)).unwrap().0, "profileActive");
|
||||
}
|
||||
// A second pair on the line and unrelated cursors stay unresolved.
|
||||
let multi = "a: @one@ @two@\n";
|
||||
assert_eq!(placeholder_at(multi, at(0, 4)).unwrap().0, "one");
|
||||
assert_eq!(placeholder_at(multi, at(0, 10)).unwrap().0, "two");
|
||||
assert!(placeholder_at(multi, at(0, 8)).is_none(), "between the pairs");
|
||||
assert!(placeholder_at(multi, at(0, 9)).is_some(), "the opening @ of the next pair");
|
||||
assert!(placeholder_at(multi, at(0, 14)).is_none(), "just past the last pair");
|
||||
assert!(placeholder_at("value: plain\n", at(0, 7)).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_nearest_pom_wins_and_the_walk_stops_at_the_project_root() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
let deep = root.join("core/src/main/resources");
|
||||
std::fs::create_dir_all(&deep).unwrap();
|
||||
std::fs::write(
|
||||
root.join("pom.xml"),
|
||||
"<project>\n <properties>\n <parentName>parent</parentName>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::create_dir_all(root.join("core")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("core/pom.xml"),
|
||||
"<project>\n <properties>\n <name>module</name>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
let from = deep.join("application.yml");
|
||||
// The module pom defines `name` first: its file wins, pointing at its `<name>` entry.
|
||||
let found = pom_defining(&root, &from, "name").unwrap();
|
||||
assert_eq!(found.path, root.join("core/pom.xml"));
|
||||
assert_eq!(found.range.start.line, 2);
|
||||
// A property only the parent defines resolves there; unknown ones resolve nowhere.
|
||||
let parent = pom_defining(&root, &from, "parentName").unwrap();
|
||||
assert_eq!(parent.path, root.join("pom.xml"));
|
||||
assert_eq!(parent.range.start.line, 2);
|
||||
assert!(pom_defining(&root, &from, "missing").is_none());
|
||||
// A file outside the project root has no pom walk.
|
||||
let outside = tmp.path().join("elsewhere/application.yml");
|
||||
std::fs::create_dir_all(tmp.path().join("elsewhere")).unwrap();
|
||||
assert!(pom_defining(&root, &outside, "name").is_none());
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,6 @@ pub mod history;
|
||||
pub mod java;
|
||||
pub mod jvm_icons;
|
||||
pub mod lsp;
|
||||
pub mod maven_placeholder;
|
||||
pub mod nav;
|
||||
pub mod notebook;
|
||||
pub mod project;
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -324,7 +324,7 @@ impl Host {
|
||||
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
|
||||
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
|
||||
documents.add_observer(Arc::new(LspObserver(lsp.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver::new(history.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver(history.clone())));
|
||||
documents.add_observer(Arc::new(DeployObserver {
|
||||
remote: self.remote.clone(),
|
||||
settings: settings.clone(),
|
||||
@@ -785,7 +785,7 @@ impl Host {
|
||||
lsp.set_servers_hook(Box::new(|_, _| Vec::new()));
|
||||
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
|
||||
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver::new(history.clone())));
|
||||
documents.add_observer(Arc::new(HistoryObserver(history.clone())));
|
||||
let watcher = match watch_dir {
|
||||
Some(dir) => light_watcher(dir, &sink, &documents, &history)?,
|
||||
// A quiet private folder stands in until the first save brings a
|
||||
@@ -1890,42 +1890,14 @@ impl DocumentObserver for SyntaxObserver {
|
||||
}
|
||||
}
|
||||
|
||||
struct HistoryObserver {
|
||||
history: Arc<LocalHistory>,
|
||||
/// Documents edited since they were opened: only the first edit looks for a missing original.
|
||||
edited: Mutex<HashSet<ide_core::DocId>>,
|
||||
}
|
||||
|
||||
impl HistoryObserver {
|
||||
fn new(history: Arc<LocalHistory>) -> Self {
|
||||
Self { history, edited: Mutex::default() }
|
||||
}
|
||||
}
|
||||
struct HistoryObserver(Arc<LocalHistory>);
|
||||
|
||||
impl DocumentObserver for HistoryObserver {
|
||||
fn changed(
|
||||
&self,
|
||||
doc: ide_core::DocId,
|
||||
path: &Path,
|
||||
_version: u32,
|
||||
_changes: &[AppliedChange],
|
||||
_full_text: &dyn Fn() -> String,
|
||||
) {
|
||||
// The file on disk still has its content from before the edit.
|
||||
if self.edited.lock().insert(doc)
|
||||
&& let Err(e) = self.history.record_original(path)
|
||||
{
|
||||
tracing::warn!("local history: {e}");
|
||||
}
|
||||
}
|
||||
fn saved(&self, _doc: ide_core::DocId, path: &Path, text: &str) {
|
||||
if let Err(e) = self.history.record(path, text, "Saved") {
|
||||
if let Err(e) = self.0.record(path, text, "Saved") {
|
||||
tracing::warn!("local history: {e}");
|
||||
}
|
||||
}
|
||||
fn closed(&self, doc: ide_core::DocId, _path: &Path) {
|
||||
self.edited.lock().remove(&doc);
|
||||
}
|
||||
}
|
||||
|
||||
/// Uploads saved files: remote files' local copies, and automatic upload to the default server.
|
||||
|
||||
@@ -5298,7 +5298,6 @@ fn document_changes_reach_plugins_relative_to_the_project() {
|
||||
let deliver = |path: &str| {
|
||||
let change = ide_plugin::DocumentChanged {
|
||||
path: to_ipc(&f.project.join(path)),
|
||||
project: None,
|
||||
base_version: 1,
|
||||
version: 2,
|
||||
changes: Vec::new(),
|
||||
@@ -5312,8 +5311,6 @@ fn document_changes_reach_plugins_relative_to_the_project() {
|
||||
// Queued with the absolute path, filtered again at delivery, handed over project-relative.
|
||||
deliver("config/app.yaml");
|
||||
assert_eq!(f.run("test.path-events", "document", None).unwrap().as_deref(), Some("config/app.yaml"));
|
||||
// With the project it is relative to: another open project may hold the same path.
|
||||
assert_eq!(f.run("test.path-events", "document-project", None).unwrap(), Some(to_ipc(&f.project)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -146,52 +146,3 @@ async fn replace_all_covers_matches_past_the_limit() {
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
/// #4202: a file the search preview holds open (no unsaved changes) is saved like a closed
|
||||
/// one; a buffer with unsaved edits is replaced in place and left for the editor to save.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn replace_all_saves_open_buffers_without_unsaved_changes() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
for name in ["previewed.txt", "edited.txt", "closed.txt"] {
|
||||
std::fs::write(root.join(name), "TOKEN\n").unwrap();
|
||||
}
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&root, true, false).unwrap();
|
||||
host.open_project("main", &root).unwrap();
|
||||
let project = host.project("main").unwrap();
|
||||
project.documents.open(&root.join("previewed.txt")).unwrap();
|
||||
let edited = project.documents.open(&root.join("edited.txt")).unwrap().id;
|
||||
project.documents.replace_all(edited, "TOKEN\nmore\n").unwrap();
|
||||
ops::search::replace_in_files(
|
||||
&host,
|
||||
"main",
|
||||
RequestId::next(),
|
||||
query("TOKEN", false),
|
||||
"DONE".into(),
|
||||
false,
|
||||
vec![],
|
||||
true,
|
||||
ops::Channel::new(|_| {}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let disk = |name: &str| std::fs::read_to_string(root.join(name)).unwrap();
|
||||
assert_eq!(disk("previewed.txt"), "DONE\n");
|
||||
assert_eq!(disk("closed.txt"), "DONE\n");
|
||||
assert_eq!(disk("edited.txt"), "TOKEN\n", "unsaved edits stay unsaved");
|
||||
assert_eq!(project.documents.text_snapshot(edited).unwrap().text, "DONE\nmore\n");
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -241,15 +241,6 @@ impl PathFilter {
|
||||
(!rel.is_empty()).then_some(rel)
|
||||
}
|
||||
|
||||
/// Recent Files' stored form: the store key for a project file, the absolute
|
||||
/// path for one outside it (a scratch file). Loading joins it to the root,
|
||||
/// which leaves an absolute path as it is.
|
||||
pub(crate) fn recent_key(&self, path: &Path) -> Option<String> {
|
||||
self.store_key(path).or_else(|| {
|
||||
(path.is_absolute() && !path.starts_with(&self.root)).then(|| path.to_str().map(str::to_owned))?
|
||||
})
|
||||
}
|
||||
|
||||
fn excluded_rel(&self, rel: &str) -> bool {
|
||||
self.excludes.is_match(rel)
|
||||
}
|
||||
|
||||
@@ -400,10 +400,15 @@ impl ProjectIndex {
|
||||
|
||||
/// Boost for "recent files" ranking.
|
||||
/// Records a recently opened file; a virtual document's URI (library
|
||||
/// class) is kept verbatim, and a file outside the project (a scratch file)
|
||||
/// by its absolute path.
|
||||
/// class) is kept verbatim, like IDEA lists library classes in Recent Files.
|
||||
pub fn mark_recent(&self, path: &Path) {
|
||||
let Some(path) = self.recent_key(path) else { return };
|
||||
let path = match path.to_str() {
|
||||
Some(s) if ide_core::text::is_virtual_uri(s) => path.to_owned(),
|
||||
_ => match self.normalize(path) {
|
||||
Some(p) => p,
|
||||
None => return,
|
||||
},
|
||||
};
|
||||
{
|
||||
let mut r = self.shared.recent.lock();
|
||||
r.retain(|p| p != &path);
|
||||
@@ -415,7 +420,13 @@ impl ProjectIndex {
|
||||
|
||||
/// Drops a file from Recent Files (Delete in the ⌘E popup).
|
||||
pub fn remove_recent(&self, path: &Path) {
|
||||
let Some(path) = self.recent_key(path) else { return };
|
||||
let path = match path.to_str() {
|
||||
Some(s) if ide_core::text::is_virtual_uri(s) => path.to_owned(),
|
||||
_ => match self.normalize(path) {
|
||||
Some(p) => p,
|
||||
None => return,
|
||||
},
|
||||
};
|
||||
{
|
||||
let mut r = self.shared.recent.lock();
|
||||
let before = r.len();
|
||||
@@ -462,20 +473,6 @@ impl ProjectIndex {
|
||||
&self.root
|
||||
}
|
||||
|
||||
/// How Recent Files stores `path`: a virtual URI verbatim, a project file normalized,
|
||||
/// and an existing file outside the root canonicalized. Excluded files under the root
|
||||
/// are left out.
|
||||
fn recent_key(&self, path: &Path) -> Option<PathBuf> {
|
||||
if path.to_str().is_some_and(ide_core::text::is_virtual_uri) {
|
||||
return Some(path.to_owned());
|
||||
}
|
||||
if let Some(p) = self.normalize(path) {
|
||||
return Some(p);
|
||||
}
|
||||
let p = dunce::canonicalize(path).ok().filter(|p| p.is_file())?;
|
||||
(!p.starts_with(&self.root)).then_some(p)
|
||||
}
|
||||
|
||||
/// Absolute path inside the root (or a content root), or `None` for paths outside the project.
|
||||
fn normalize(&self, path: &Path) -> Option<PathBuf> {
|
||||
let filter = self.shared.filter();
|
||||
|
||||
@@ -251,26 +251,6 @@ fn recent_files_skip_deleted_files_but_keep_virtual_documents() {
|
||||
assert_eq!(idx.recent_files(), vec![virt]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recent_files_keep_files_outside_the_project() {
|
||||
let fx = sample();
|
||||
let scratches = tempfile::tempdir().unwrap();
|
||||
let scratch = dunce::canonicalize(scratches.path()).unwrap().join("generated-requests.http");
|
||||
std::fs::write(&scratch, "GET http://localhost\n").unwrap();
|
||||
let app = fx.root.join("web/app.py");
|
||||
{
|
||||
let idx = fx.open();
|
||||
idx.mark_recent(&app);
|
||||
idx.mark_recent(&scratch);
|
||||
assert_eq!(idx.recent_files(), vec![scratch.clone(), app.clone()]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
}
|
||||
let idx = fx.open();
|
||||
assert_eq!(idx.recent_files(), vec![scratch.clone(), app.clone()], "persisted by absolute path");
|
||||
idx.remove_recent(&scratch);
|
||||
assert_eq!(idx.recent_files(), vec![app]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistence_skips_unchanged_files_on_reopen() {
|
||||
let fx = sample();
|
||||
|
||||
@@ -591,7 +591,7 @@ impl Shared {
|
||||
let update_elapsed = update_started.elapsed();
|
||||
let snapshot_started = Instant::now();
|
||||
if let Some(store) = &self.store {
|
||||
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.recent_key(p)).collect();
|
||||
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
|
||||
let d = self.data.read();
|
||||
let snapshot_started = Instant::now();
|
||||
if let Err(e) = store.save_snapshot(&d, &filter, guard) {
|
||||
@@ -976,7 +976,7 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
if save_recent && let Some(store) = &self.store {
|
||||
let rels: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.recent_key(p)).collect();
|
||||
let rels: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
|
||||
if let Err(e) = store.save_recent(&rels) {
|
||||
tracing::warn!("index cache: saving recent files failed: {e}");
|
||||
}
|
||||
|
||||
@@ -65,28 +65,6 @@ pub(crate) fn lenient_diagnostics(server: &str, items: Value) -> Vec<lsp::Diagno
|
||||
parsed
|
||||
}
|
||||
|
||||
/// rust-analyzer publishes its own analysis next to `cargo check`'s (flycheck): one type
|
||||
/// mismatch then arrives as `rust-analyzer(E0308)` and `rustc(E0308)`. Its own entry is
|
||||
/// dropped when the compiler reports the same code and severity over an overlapping range.
|
||||
fn drop_compiler_duplicates(diagnostics: &mut Vec<lsp::Diagnostic>) {
|
||||
let overlaps = |a: &lsp::Range, b: &lsp::Range| a.start <= b.end && b.start <= a.end;
|
||||
let compiler: Vec<(lsp::Range, Option<lsp::NumberOrString>, Option<lsp::DiagnosticSeverity>)> = diagnostics
|
||||
.iter()
|
||||
.filter(|d| d.source.as_deref() == Some("rustc") && d.code.is_some())
|
||||
.map(|d| (d.range, d.code.clone(), d.severity))
|
||||
.collect();
|
||||
if compiler.is_empty() {
|
||||
return;
|
||||
}
|
||||
diagnostics.retain(|d| {
|
||||
d.source.as_deref() != Some("rust-analyzer")
|
||||
|| d.code.is_none()
|
||||
|| !compiler
|
||||
.iter()
|
||||
.any(|(range, code, severity)| code == &d.code && severity == &d.severity && overlaps(range, &d.range))
|
||||
});
|
||||
}
|
||||
|
||||
impl ClientHandler {
|
||||
pub fn new(mgr: Weak<LspManager>, server: Arc<Server>, generation: u64) -> Self {
|
||||
Self { mgr, server, generation }
|
||||
@@ -315,20 +293,11 @@ impl ClientHandler {
|
||||
}
|
||||
};
|
||||
params.diagnostics = lenient_diagnostics(&self.server.name, raw.unwrap_or(Value::Null));
|
||||
drop_compiler_duplicates(&mut params.diagnostics);
|
||||
let Some(path) = uri_to_path(params.uri.as_str())
|
||||
.or_else(|| crate::notebook::is_cell_uri(params.uri.as_str()).then(|| PathBuf::from(params.uri.as_str())))
|
||||
else {
|
||||
return;
|
||||
};
|
||||
if self.server.name == crate::compose::SERVER {
|
||||
// Maven resource-filtering placeholders (`@profileActive@`) parse as invalid
|
||||
// YAML but are replaced before the file is ever read: their parser error is noise.
|
||||
let text = mgr.docs.lock().values().find(|d| d.path == path).map(|d| d.text.as_str().to_owned());
|
||||
if let Some(text) = text {
|
||||
params.diagnostics.retain(|d| !crate::maven_placeholder::false_positive(&text, d));
|
||||
}
|
||||
}
|
||||
if self.server.name == "jdtls"
|
||||
&& let Some(failure) = crate::jdtls::build_plan_failure(&path, &self.server.root, ¶ms.diagnostics)
|
||||
{
|
||||
@@ -732,28 +701,6 @@ mod tests {
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
#[test]
|
||||
fn rust_analyzer_s_own_entry_yields_to_the_compiler_s_for_the_same_error() {
|
||||
let diagnostic = |source: &str, code: &str, line: u32, severity| lsp::Diagnostic {
|
||||
range: lsp::Range::new(lsp::Position::new(line, 21), lsp::Position::new(line, 27)),
|
||||
severity: Some(severity),
|
||||
code: Some(lsp::NumberOrString::String(code.into())),
|
||||
source: Some(source.into()),
|
||||
message: format!("{source} {code}"),
|
||||
..Default::default()
|
||||
};
|
||||
let error = lsp::DiagnosticSeverity::ERROR;
|
||||
let mut items = vec![
|
||||
diagnostic("rust-analyzer", "E0308", 1, error),
|
||||
diagnostic("rustc", "E0308", 1, error),
|
||||
diagnostic("rust-analyzer", "E0308", 5, error),
|
||||
diagnostic("rust-analyzer", "unused_variables", 1, lsp::DiagnosticSeverity::WARNING),
|
||||
];
|
||||
drop_compiler_duplicates(&mut items);
|
||||
let left: Vec<_> = items.iter().map(|d| (d.message.as_str(), d.range.start.line)).collect();
|
||||
assert_eq!(left, [("rustc E0308", 1), ("rust-analyzer E0308", 5), ("rust-analyzer unused_variables", 1)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tsserver_aborts_are_out_of_memory() {
|
||||
assert!(tsserver_ran_out_of_memory("TSServer exited. Code: 134. Signal: null"));
|
||||
|
||||
@@ -25,7 +25,6 @@ mod kotlin_lsp;
|
||||
mod launch;
|
||||
mod library_source;
|
||||
mod loading;
|
||||
mod maven_placeholder;
|
||||
mod message_requests;
|
||||
mod notebook;
|
||||
mod phoxite;
|
||||
|
||||
@@ -1,113 +0,0 @@
|
||||
//! `@property@` placeholders in YAML resources: Maven resource filtering replaces
|
||||
//! them before the file is ever read as YAML, so Spring projects use them unquoted
|
||||
//! (`spring.profiles.active: @profileActive@`). The YAML spec reserves `@` and the
|
||||
//! `yaml` parser behind `yaml-language-server` therefore reports
|
||||
//! "Plain value cannot start with reserved character @" for every one of them.
|
||||
//! The diagnostic is dropped when the reported scalar is exactly a Maven
|
||||
//! placeholder; anything else the parser flags keeps showing.
|
||||
|
||||
use lsp_types as lsp;
|
||||
|
||||
const RESERVED_AT: &str = "Plain value cannot start with reserved character @";
|
||||
|
||||
/// Whether `diagnostic` is the reserved-`@` parser error on a scalar whose text in
|
||||
/// `text` is exactly a Maven placeholder (`@token@`).
|
||||
pub(crate) fn false_positive(text: &str, diagnostic: &lsp::Diagnostic) -> bool {
|
||||
diagnostic.message == RESERVED_AT && placeholder_at(text, &diagnostic.range).is_some()
|
||||
}
|
||||
|
||||
/// The name between the `@`s of the diagnostic range, when it covers one whole placeholder.
|
||||
fn placeholder_at(text: &str, range: &lsp::Range) -> Option<String> {
|
||||
if range.start.line != range.end.line {
|
||||
return None;
|
||||
}
|
||||
let line = text.split_inclusive('\n').nth(range.start.line as usize)?;
|
||||
let line = line.trim_end_matches(['\n', '\r']);
|
||||
let start = utf16_to_byte(line, range.start.character)?.min(line.len());
|
||||
// The parser's scalar range ends one past the line (its newline), so the end clamps.
|
||||
let end = utf16_to_byte(line, range.end.character).unwrap_or(line.len());
|
||||
if end < start {
|
||||
return None;
|
||||
}
|
||||
let inner = line[start..end].strip_prefix('@')?.strip_suffix('@')?;
|
||||
(!inner.is_empty() && inner.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_')))
|
||||
.then(|| inner.to_owned())
|
||||
}
|
||||
|
||||
/// UTF-16 column → byte offset within one line, `None` inside a surrogate pair or past the line.
|
||||
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
|
||||
let col = col as usize;
|
||||
let mut units = 0usize;
|
||||
for (byte, c) in line.char_indices() {
|
||||
if units == col {
|
||||
return Some(byte);
|
||||
}
|
||||
units += c.len_utf16();
|
||||
if units > col {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
(units == col).then_some(line.len())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use lsp_types::{Position, Range};
|
||||
|
||||
fn at(line: u32, from: u32, to: u32) -> Range {
|
||||
Range { start: Position::new(line, from), end: Position::new(line, to) }
|
||||
}
|
||||
|
||||
fn across(from: (u32, u32), to: (u32, u32)) -> Range {
|
||||
Range { start: Position::new(from.0, from.1), end: Position::new(to.0, to.1) }
|
||||
}
|
||||
|
||||
fn diagnostic(range: Range) -> lsp::Diagnostic {
|
||||
lsp::Diagnostic { range, message: RESERVED_AT.to_owned(), ..Default::default() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_maven_placeholder_placeholder_is_a_false_positive() {
|
||||
let text = "spring:\n profiles:\n active: @profileActive@\n";
|
||||
assert!(false_positive(text, &diagnostic(at(2, 12, 27))));
|
||||
// The parser ends the scalar's range one past the line (its newline): still caught.
|
||||
assert!(false_positive(text, &diagnostic(at(2, 12, 28))));
|
||||
// Columns also decode on a line with non-ASCII text before the scalar.
|
||||
let text = "name: 项目\nvalue: @profileActive@\n";
|
||||
assert!(false_positive(text, &diagnostic(at(1, 7, 22))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn other_reserved_character_errors_and_shapes_still_show() {
|
||||
let text = "active: @profileActive@\n";
|
||||
// Not the parser's message (a backtick, a different wording).
|
||||
assert!(!false_positive(
|
||||
text,
|
||||
&lsp::Diagnostic {
|
||||
message: "Plain value cannot start with reserved character `".to_owned(),
|
||||
..diagnostic(at(0, 8, 11))
|
||||
}
|
||||
));
|
||||
// The error's range is stale and no longer covers a placeholder.
|
||||
assert!(!false_positive(text, &diagnostic(at(0, 0, 10))));
|
||||
// A single `@`, an unpaired one or a name with spaces is no placeholder.
|
||||
assert!(!false_positive("active: @\n", &diagnostic(at(0, 8, 9))));
|
||||
assert!(!false_positive("active: @profile\n", &diagnostic(at(0, 8, 16))));
|
||||
assert!(!false_positive("active: @pro file@\n", &diagnostic(at(0, 8, 18))));
|
||||
// A range crossing lines is kept.
|
||||
assert!(!false_positive("a: @x@\nb: y\n", &diagnostic(across((0, 3), (1, 0)))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn utf16_columns_decode_multi_byte_and_surrogate_pairs() {
|
||||
// "é" is one UTF-16 unit; "😀" is two, and a column inside it is out of range.
|
||||
let line = "é😀@token@";
|
||||
assert_eq!(utf16_to_byte(line, 0), Some(0));
|
||||
assert_eq!(utf16_to_byte(line, 1), Some(2));
|
||||
assert_eq!(utf16_to_byte(line, 2), None);
|
||||
assert_eq!(utf16_to_byte(line, 3), Some(6));
|
||||
assert_eq!(utf16_to_byte(line, 4), Some(7));
|
||||
assert_eq!(utf16_to_byte(line, 10), Some(line.len()));
|
||||
}
|
||||
}
|
||||
@@ -250,9 +250,6 @@ pub struct DocumentTextChange {
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DocumentChanged {
|
||||
pub path: String,
|
||||
/// The open project `path` is relative to, set when the event is handed to a plugin
|
||||
/// (the editor posts the absolute path and `null`).
|
||||
pub project: Option<String>,
|
||||
pub base_version: u64,
|
||||
pub version: u64,
|
||||
pub changes: Vec<DocumentTextChange>,
|
||||
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ada68dfdf2875668eff1765ec22678315f18ac6f1364c5f7eda742cb58dc3c60
|
||||
c10d6f373bd3a701e201350d0272a211da72b23cef010144760db5bae44e2c11
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
2279ae4f79c565c4cd59d9191f394c4d7d5b23ef955f1bd30c2e5396d608e46c
|
||||
cd7a14b6d4464a559c197ba7fcba30fb045a8927c074fd0c310bec6039af0e0f
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
77be736c11c39de3a1b021a5e66e905c76e2d32352d889d6bcc9315607c54271
|
||||
017cb719d8c3a226cb6178d75da7ae0396b2d78799658ef560f729e8e06f36e3
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
304690bf13cba5d262d54d709d6f18c627880954f0140919118aea0439fbaaf3
|
||||
93a9660a0941f2f57d11ea7ae331bd6d209ddcb134729ee88ec2fd96e978e631
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
b24767627e7445ec093cc79cd6c18844e4dcdf123c6b04c24bc37f109c5cdb0f
|
||||
6a0008339af0935c7c0128d23bf3e885a642c335ad57097cffb3f000766aba33
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
0fa52a91772ceb3d45307db4f2561c132df4b966d15f7f9ce177b7a373f7163d
|
||||
09369df431bb6922463a242484eb82325ce8af287654af97a99eefb3884115a5
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
34ea07edc731ab28748b99c398f7e1ee4d41aa22c0760d57027adad40759292f
|
||||
897898835f2f42763da34dad29b8f926b230b33f506830e4118e6c5914720bd4
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
470a54d825e84e8ec0418a244c1fc46426c02f299f4a456ff4cc83fa604d08a0
|
||||
b56b918d1ff51c902dc956a7da944163194fcc93ba5bcf8baafa44fc2b6b039b
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
20a4f662437478b20e5a80aa30afe20b155001f94c2934843ab11b69192833d4
|
||||
ec2f6463d1ce5d70ad7331ae51bca3c8205b55f1f9e5abfe2218d53be2b61437
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
c118a6562e0398e7f0deb64abc9913dd14acec74869d5c04c452923a81455463
|
||||
8a25727e09b96b35bc90f906215e13d29697b3792ed81f7f80024299e8b23d44
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
194fa719b8c96ca23f2da73d2d7225c4805b5c48af67b1efff8e76852f0a6a1c
|
||||
33d331d6ab59aa44f9884504ecc77a474e99c7223253735983c327bee6e75984
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
3db661dd4d45a242b79caf642510d71841ba9f09b3b5eaa1854eabe9fcf6292e
|
||||
b804f22b06f924aebce86f8bc2c24b5306913f2d2a4a0167af10ce86c8f606db
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
196769808ae37ede0a7564f42cae087a18f756b3cd31acb7d99470f1bfd70ea6
|
||||
27e24e96578471e51dace84968daa6ee189aae0d63d27f3054bf4f3a0841fe0c
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
dcd05de6c207f4594d347ad3dc44089204353dc898e53873f437e3db1928d629
|
||||
283320b057d39decafce4f86e09ace4df46ef2f31524b6cac0af22bd62795b0c
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ece50a864d5a85263cb30eb39dceae90fe174336904e9208ae5c9d5da5cbb036
|
||||
dff4f3571bf72eedfbe2e0e2d6b8908e703e890639fb1b854eb4f35226ddbc98
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
a2854d3c357d976b5ee1bf7b31fa541a55581102d37ec85ea719d4fdedd962cb
|
||||
f5d7f62056547beffaadf68a04e8393ee29d73d57501d9f8bb39e902e9d9bf61
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
dbebe5cfa79092169689d43945e4d71e1a61303ce88f6b4f02216ab69083b955
|
||||
8ea7d2a041efe6bcabe8f9bb58b216fe583a7ad39207f0f10b4bf423facc56e7
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
993b0f11e8cae470b0529fcfcbe9a520c855069ef63f242da3b26a3da2574d5d
|
||||
3b5b541b94b674762d6c0494bb5e26bbc871460767015a669ecd2771dc063b8a
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
d803928d82cbb2991b3f0c53b73dbe2da625b7b2ce25050706b6da09687f2873
|
||||
64411ddd70ae2906710d03c90add26727aa319db38c5bd23971eb442943154c5
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
1c779c4913a2b83fa51980ee0017e3f2625041f1b4de921cedcdcb3bd4120d67
|
||||
ff7468eabf0b09be01afda83ede9d8b540d17cbccb414e1972899bb851c19d84
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
bd09f3b47470087095ae50c3b0f134c471dd9ba1e5f812cd0285cef904065725
|
||||
b24fb8d5161006104698fb07a43432601b4f16fdc4a34cc70058cbef7e973066
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
ada14d3aa0e462478de7dff28be356b2105f4d3ec8d4dff8a7a4a858d15c4613
|
||||
8ded9b882110bc6b1235b14797128d5999f20079178a6134f172f64f77922985
|
||||
@@ -33,10 +33,6 @@ title = "off"
|
||||
id = "document"
|
||||
title = "document"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "document-project"
|
||||
title = "document-project"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "count"
|
||||
title = "count"
|
||||
@@ -33,7 +33,6 @@ impl Plugin for Fixture {
|
||||
}
|
||||
"count" => Ok(host::storage::get("count")?),
|
||||
"document" => Ok(host::storage::get("document")?),
|
||||
"document-project" => Ok(host::storage::get("document-project")?),
|
||||
_ => Err(Error::NotFound(id.into())),
|
||||
}
|
||||
}
|
||||
@@ -43,7 +42,6 @@ impl Plugin for Fixture {
|
||||
for event in events {
|
||||
if let Event::DocumentChanged(change) = event {
|
||||
host::storage::set("document", &change.path).unwrap();
|
||||
host::storage::set("document-project", change.project.as_deref().unwrap_or_default()).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
3d628f747d13d3d2fae9a75adeb951c8af09b1db5fb15523fc71289857d97d99
|
||||
c38f6ca9e44f0a0674b9186ef105e73e0c66a914de92a1aec97b5985f31fc29a
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
43e7552ae0f8b42383cade84924adc81952c78253186a71c2693b11d98f01acd
|
||||
a74d851ebf2cad085b9d0fb56ad26c7b18d737c8cc0ef32a592a8f1b05b9be06
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
373188558b7925b4f9c9f975b0b6aa7b13acdf8da0c622a4ab12f39b69c1f071
|
||||
ce5fc1e202210942f287b593fbb88f2f1d51b573702c476e9f2d96f684d546c6
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
9c91a083fd31e57658f28c34329e061dc17cc08871fe09b3b96fa557bc085c8d
|
||||
a9821d31a040a5b2244e205632bc4edf8ebeae5c34aa5911438b69254f767183
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
1a2182ca4e272d3473084451932a1d8df861ac2e67ad1814c0e01e089584ab3f
|
||||
792cd02805a24a37655629a24da97d82c2cc4f385dea21720167792302a75236
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
d5e8c538e410f480d79454c616bf9b0e7eaa7e502ed0268bf20f75214ca93d17
|
||||
e6235b32744d6e5b3042ff2231e1a30eb4966324e790d01176f88fc9955db638
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
756f2a459f2aa17d6eb1d9dbe089a3d6dc5079012ed68ee47e55d5256c589359
|
||||
c277285eab80d917597ca26bcee94c5bde17cb7d0d38f3bd2866ce75b048f226
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
28327a76a68737fda8ae0b22a439f5bbe86dd53347a7ee2806bb66ae90714238
|
||||
84e2be128daa6dbe04df383fee1250cd2b6d65d90a3de2afdaed98be147599cb
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ac3a564273429fcaad2c443e3463f06694953889ad894c9f68b824e87e291ae0
|
||||
3a492f0664ed153d631ec3c1089e7bdf5dcf31f969cb75654516290ac35cf984
|
||||
Loaded 100 of 331 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача