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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 9a649d77c2 fix(run): detect Spring Boot apps that inherit the plugin or use a meta-annotation
Project detection only treated a module as Spring Boot when its own build file
applied the plugin, so microservice modules that inherit spring-boot-maven-plugin
from the parent POM's <build><plugins> (or Gradle's subprojects block) were missing
from Run configurations and Services until their main class was run once. And only
the literal @SpringBootApplication marked an application class, not
@SpringCloudApplication or a project annotation carrying @SpringBootApplication, so
the gutter's Run created a plain Application configuration.

A module now applies Spring Boot through its own build or a build above it
(pluginManagement alone doesn't apply it). Application classes are recognised by
@SpringBootApplication, @SpringCloudApplication, or a project annotation declared
with either (resolved through imports and the modules' main source roots). The
gutter reuses the Spring Boot kind of the detected configuration with the same id.

Fixes #3916
2026-11-17 20:10:28 +08:00
547 змінених файлів з 4835 додано та 22154 видалено

No files matched your search

-1
Переглянути файл
@@ -9,7 +9,6 @@
"dist",
"target",
"src/bindings.ts",
"docs/snippets/plugin-catalog.jsx",
"evals/*/golden",
"src/editor/core/cm/angular/parser*.ts",
"src/editor/core/cm/jsp/parser*.ts",
Створено
-2
Переглянути файл
@@ -4589,7 +4589,6 @@ version = "0.1.47"
dependencies = [
"blake3",
"criterion",
"dunce",
"ide-core",
"ide-extension",
"ide-text",
@@ -6734,7 +6733,6 @@ dependencies = [
"tracing",
"tracing-appender",
"tracing-subscriber",
"webview2-com",
"windows",
"windows-sys 0.61.2",
]
-80
Переглянути файл
@@ -1,80 +0,0 @@
//! Codex's asynchronous questions are answered by a user message, not a permission response.
use crate::AgentQuestion;
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::collections::BTreeMap;
/// The wire reply and its readable record. Question ids, not wording, associate each answer.
pub(crate) fn reply(questions: &[AgentQuestion], answers: &str) -> IdeResult<(String, String)> {
let answers: BTreeMap<String, Vec<String>> =
serde_json::from_str(answers).map_err(|_| IdeError::invalid("invalid question answers"))?;
if questions.is_empty() || answers.len() != questions.len() {
return Err(IdeError::invalid("answer every question"));
}
let mut replies = Vec::new();
let mut record = Vec::new();
for question in questions {
let key = question.answer_key.as_deref().ok_or_else(|| IdeError::invalid("missing question id"))?;
let values = answers.get(key).ok_or_else(|| IdeError::invalid("missing question answer"))?;
if values.is_empty()
|| (!question.multi_select && values.len() != 1)
|| values.iter().any(|v| v.trim().is_empty())
{
return Err(IdeError::invalid("empty or invalid question answer"));
}
let answer = values.iter().map(|v| v.trim()).collect::<Vec<_>>().join(", ");
let mut title = question.question.clone();
let mut end = title.len().min(512);
while !title.is_char_boundary(end) {
end -= 1;
}
title.truncate(end);
title = title.replace(['\n', '\r'], " ");
replies.push(json!({ "questionItemId": key, "question": title, "answer": answer }));
record.push(format!("{}: {}", question.question, answer));
}
Ok((
format!("<send_user_message_question_reply>\n{}\n</send_user_message_question_reply>", json!(replies)),
record.join("\n"),
))
}
#[cfg(test)]
mod tests {
use super::*;
fn question(key: &str) -> AgentQuestion {
AgentQuestion {
answer_key: Some(key.into()),
header: String::new(),
question: "Which?".into(),
multi_select: false,
options: Vec::new(),
}
}
#[test]
fn identical_wording_keeps_answers_associated_with_ids() {
let (wire, record) =
reply(&[question("first"), question("second")], r#"{"first":[" One "],"second":["Two"]}"#).unwrap();
let body = wire
.strip_prefix("<send_user_message_question_reply>\n")
.unwrap()
.strip_suffix("\n</send_user_message_question_reply>")
.unwrap();
let replies: serde_json::Value = serde_json::from_str(body).unwrap();
assert_eq!(replies[0], json!({"questionItemId":"first","question":"Which?","answer":"One"}));
assert_eq!(replies[1]["answer"], "Two");
assert_eq!(record, "Which?: One\nWhich?: Two");
}
#[test]
fn malformed_missing_and_empty_answers_are_rejected() {
for answers in
["no", "{}", r#"{"other":["One"]}"#, r#"{"first":[]}"#, r#"{"first":[" "]}"#, r#"{"first":["One","Two"]}"#]
{
assert!(reply(&[question("first")], answers).is_err(), "{answers}");
}
}
}
+3 -75
Переглянути файл
@@ -8,7 +8,6 @@
//! next prompt when the agent supports `session/load`.
mod acp;
mod async_questions;
mod catalogs;
mod config;
mod conversation;
@@ -416,15 +415,11 @@ struct Task {
live: Mutex<Option<Live>>,
/// Serializes starting the agent.
connecting: tokio::sync::Mutex<()>,
/// Serializes replies from multiple windows to the same async question.
answering_questions: tokio::sync::Mutex<()>,
/// Unanswered permission requests: where to send the chosen option id.
permissions: Mutex<HashMap<u32, std::sync::mpsc::Sender<Option<String>>>>,
next_permission: AtomicU32,
/// Set while `session/load` replays history we already have.
replaying: AtomicBool,
/// The saved session failed to load and the user was told: the next start opens a new one.
start_fresh: AtomicBool,
/// The current turn is being cancelled to send the first queued message right away.
send_now: AtomicBool,
/// The user stopped the current turn. A stop that reaches the agent before it took the
@@ -1414,53 +1409,6 @@ impl AgentManager {
}
}
/// Replies to a non-blocking question without interrupting the agent's current turn.
pub async fn answer_question(&self, id: &str, question: &str, answer: Option<String>) -> IdeResult<()> {
let task = self.task(id)?;
let _answering = task.answering_questions.lock().await;
let questions = {
let s = task.state.lock();
s.conversation
.main
.entries
.iter()
.find_map(|entry| match entry {
AgentEntry::Question { id, questions, chosen: None, .. } if id == question => {
Some(questions.clone())
}
_ => None,
})
.ok_or_else(|| IdeError::not_found("the question was already answered"))?
};
let chosen = match answer {
None => "Skipped".to_owned(),
Some(answer) => {
let (text, record) = async_questions::reply(&questions, &answer)?;
let prompt = AgentPrompt { text, files: Vec::new(), images: Vec::new() };
if let Err(prompt) = task.steer(prompt).await {
if task.state.lock().busy {
return Err(IdeError::unavailable("the reply could not join the running turn; try again"));
}
self.prompt(id, prompt, false).await?;
}
record
}
};
let changed = {
let mut s = task.state.lock();
s.conversation.main.entries.iter_mut().enumerate().find_map(|(index, entry)| match entry {
AgentEntry::Question { id, chosen: current, .. } if id == question => {
*current = Some(chosen.clone());
Some((None, index))
}
_ => None,
})
};
task.mark_dirty(changed);
task.persist();
Ok(())
}
/// Stops the agent and moves the task to Archived; its worktree stays.
pub fn archive(&self, id: &str) -> IdeResult<()> {
let task = self.task(id)?;
@@ -1759,11 +1707,9 @@ impl Task {
}),
live: Mutex::new(None),
connecting: tokio::sync::Mutex::new(()),
answering_questions: tokio::sync::Mutex::new(()),
permissions: Mutex::new(HashMap::new()),
next_permission: AtomicU32::new(1),
replaying: AtomicBool::new(false),
start_fresh: AtomicBool::new(false),
send_now: AtomicBool::new(false),
cancel_pending: AtomicBool::new(false),
turn_started: AtomicBool::new(false),
@@ -2372,8 +2318,7 @@ impl Task {
let mut tried_auth = false;
let mut session = None;
let start_fresh = self.start_fresh.load(Ordering::Acquire);
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
if let (Some(id), true) = (saved, can_load) {
self.replaying.store(true, Ordering::Release);
let mut params = session_params(&cwd_s, &mcp_servers);
params["sessionId"] = json!(&id);
@@ -2382,23 +2327,7 @@ impl Task {
self.replaying.store(false, Ordering::Release);
match loaded {
Ok(v) => session = Some((id, v)),
// Not silently: a new session would lose the conversation and replace the saved id.
Err(e) => {
tracing::info!("agent task {}: session/load failed: {e}", self.id);
if let Some(message) = self.sign_in_error(&e, Some(&sign_in_message)) {
return Err(SessionOpenError { message, allow_acp_fallback: false });
}
self.start_fresh.store(true, Ordering::Release);
return Err(SessionOpenError {
message: format!(
"Couldn't reopen this conversation's {} session: {}\n\nSend the message again to \
continue in a new session. The agent won't see the earlier conversation.",
spec.name,
self.describe(e)
),
allow_acp_fallback: false,
});
}
Err(e) => tracing::info!("agent task {}: session/load failed, starting a new session: {e}", self.id),
}
}
let resumed = session.is_some();
@@ -2503,7 +2432,6 @@ impl Task {
s.task.config = options;
s.task.capabilities = capabilities;
s.session_id = Some(session_id.clone());
self.start_fresh.store(false, Ordering::Release);
// The (re)started process runs nothing yet: whatever it reports next is all of it.
s.background_tasks = Vec::new();
s.task.background.clear();
@@ -2727,7 +2655,7 @@ impl Task {
let applied = self.state.lock().conversation.apply(session, update, now_ms());
self.mark_dirty(applied);
// A subagent can start or finish after the turn that started it: saved right away.
if matches!(kind, "subagent_update" | "user_question") {
if kind == "subagent_update" {
self.persist();
}
}
-8
Переглянути файл
@@ -469,14 +469,6 @@ pub enum AgentEntry {
Agent {
text: String,
},
/// A question that can be answered while the agent keeps working, or after the turn ends.
Question {
id: String,
title: String,
questions: Vec<AgentQuestion>,
/// The submitted answers, or `Skipped`; `None` while unanswered.
chosen: Option<String>,
},
Thought {
text: String,
},
-5
Переглянути файл
@@ -1028,11 +1028,6 @@ impl CodexShim {
}
Some(t.chunk(kind, &id, &text))
});
if ty == "agentMessage"
&& let Some(update) = translate::question_update(item)
{
self.emit(thread, update);
}
}
"subAgentActivity" => {
let child = item.get("agentThreadId").and_then(Value::as_str).unwrap_or_default();
-50
Переглянути файл
@@ -473,56 +473,6 @@ fn history_replays_turns() {
assert_eq!(updates[4]["status"], "completed");
}
#[test]
fn history_preserves_async_questions_with_stable_answer_ids() {
let updates = history(
&json!({"turns": [{"items": [{
"type": "agentMessage", "id": "call-1", "text": "Which?",
"questions": [{"title": "Which?", "options": ["One", "Two"]}, {"title": "Why?"}]
}]}]}),
None,
);
let asked = updates.iter().find(|u| u["sessionUpdate"] == "user_question").expect("question update");
assert_eq!(asked["id"], "call-1");
assert_eq!(asked["questions"][0]["answerKey"], r#"["request_user_input_async","call-1",0]"#);
assert_eq!(asked["questions"][0]["options"][1]["label"], "Two");
assert_eq!(asked["questions"][1]["options"], json!([]));
}
#[tokio::test]
async fn completing_a_streamed_message_still_delivers_its_async_questions() {
let shim = Arc::new(CodexShim {
runtime: tokio::runtime::Handle::current(),
codex: OnceLock::new(),
client: OnceLock::new(),
state: Mutex::default(),
models: tokio::sync::Mutex::new(None),
skills: tokio::sync::Mutex::new(()),
});
shim.state.lock().threads.insert("thread".into(), Thread::default());
let client = Arc::new(Client::default());
let peer = crate::native::serve(shim.clone(), client.clone());
shim.text("thread", &json!({"itemId":"call-1","delta":"Which?"}), "agent_message_chunk", false);
shim.item(
"thread",
&json!({"type":"agentMessage","id":"call-1","text":"Which?",
"questions":[{"title":"Which?","options":["One","Two"]}]}),
true,
);
tokio::time::timeout(Duration::from_secs(2), async {
while client.of("thread").len() < 2 {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.unwrap();
assert_eq!(client.text("thread", "agent_message_chunk"), "Which?");
assert!(client.of("thread").iter().any(|u| u["sessionUpdate"] == "user_question"));
assert!(client.asked.lock().is_empty(), "an asynchronous question must not block on a permission response");
peer.kill();
shim.client.get().unwrap().kill();
}
// ---- Transcripts ---------------------------------------------------------------------
/// The ACP client: records updates and answers permission requests in order.
-31
Переглянути файл
@@ -871,7 +871,6 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
if !text.is_empty() {
out.push(chunk("agent_message_chunk", text));
}
out.extend(question_update(item));
}
Some("reasoning") => {
let text = reasoning_text(item);
@@ -891,36 +890,6 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
out
}
/// Structured async questions accompany a completed message, even when its text streamed already.
pub(super) fn question_update(item: &Value) -> Option<Value> {
let id = item.get("id")?.as_str().filter(|id| !id.is_empty())?;
let questions: Vec<Value> = item
.get("questions")?
.as_array()?
.iter()
.enumerate()
.filter_map(|(index, q)| {
let title = q.get("title")?.as_str().filter(|title| !title.trim().is_empty())?;
let options: Vec<Value> = q
.get("options")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.filter(|label| !label.trim().is_empty())
.map(|label| json!({ "label": label, "description": "" }))
.collect();
Some(json!({ "answerKey": json!(["request_user_input_async", id, index]).to_string(),
"question": title, "header": "", "multiSelect": false, "options": options }))
})
.collect();
if questions.is_empty() {
return None;
}
Some(json!({ "sessionUpdate": "user_question", "id": id,
"title": questions[0]["question"], "questions": questions }))
}
/// A reasoning item's summary (or, without one, its raw text).
pub(super) fn reasoning_text(item: &Value) -> String {
let parts = |k: &str| -> Vec<String> {
+2 -126
Переглянути файл
@@ -39,8 +39,6 @@ struct FakeAgent {
authenticate_method: Option<String>,
authenticated: AtomicBool,
request_error: Option<(i64, String)>,
/// `session/load` fails with this, as OMP does for a session whose model it can't restore.
load_error: Option<(i64, String)>,
auth_methods: Vec<Value>,
/// Hold the late mode reply until the prompt's permission request is already waiting.
hold_late_mode: bool,
@@ -214,7 +212,6 @@ impl Handler for FakeAgent {
let outcome = if text == "too late" { "promptRequired" } else { "injected" };
Ok(json!({"outcome": outcome, "queue": "steering"}))
}
"session/load" if self.load_error.is_some() => Err(self.load_error.clone().unwrap()),
"session/load" => {
self.say(&session, "replayed history");
Ok(json!({}))
@@ -248,10 +245,6 @@ impl Handler for FakeAgent {
}
"session/prompt" => {
let text = params.pointer("/prompt/0/text").and_then(Value::as_str).unwrap_or_default().to_owned();
if text.starts_with("<send_user_message_question_reply>") {
self.say(&session, "answer received");
return Ok(json!({"stopReason": "end_turn"}));
}
if text == "again" {
self.say(&session, "second turn");
return Ok(json!({"stopReason": "end_turn"}));
@@ -873,7 +866,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
["session/load", "authenticate", "authenticate github_oauth", "session/load", "session/prompt"],
);
// If `authenticate` fails during `session/load`, the sign-in error stands: no new session replaces it.
// If `authenticate` fails during `session/load`, fallback to `session/new` does not try it again.
mgr2.shutdown();
let agent3 = Arc::new(FakeAgent {
auth_on_load: true,
@@ -892,7 +885,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
.iter()
.filter(|c| c.starts_with("session/") || c.starts_with("authenticate"))
.collect::<Vec<_>>(),
["session/load", "authenticate"],
["session/load", "authenticate", "session/new"],
);
mgr3.shutdown();
}
@@ -1157,127 +1150,10 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
assert!(calls.contains(&"session/set_mode \"code\"".to_owned()), "{calls:?}");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_session_that_fails_to_load_is_reported_and_replaced_only_when_sent_again() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let saved = mgr.task(&task.id).unwrap().state.lock().session_id.clone().expect("a session");
mgr.shutdown();
// OMP: "Could not restore model …" for a session saved with a model it can't restore.
let agent = Arc::new(FakeAgent {
load_error: Some((codes::INTERNAL_ERROR, "Could not restore model x".into())),
..Default::default()
});
let mgr = manager(tmp.path(), agent.clone());
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
let calls = |agent: &FakeAgent| -> Vec<String> {
agent.calls.lock().iter().filter(|c| c.starts_with("session/")).cloned().collect()
};
assert_eq!(calls(&agent), ["session/load"], "no new session behind the user's back");
let handle = mgr.task(&task.id).unwrap();
assert_eq!(handle.state.lock().session_id.as_deref(), Some(saved.as_str()));
assert!(mgr.entries(&task.id, None).unwrap().iter().any(|e| matches!(e,
AgentEntry::Error { message } if message.contains("Could not restore model x") && message.contains("Send the message again"))));
// Sending again is the user's choice to continue without the earlier conversation.
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert_eq!(calls(&agent), ["session/load", "session/new", "session/prompt"]);
}
fn text(t: &str) -> AgentPrompt {
AgentPrompt { text: t.into(), ..AgentPrompt::default() }
}
fn asynchronous_question() -> Value {
json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]})
}
#[tokio::test(flavor = "multi_thread")]
async fn async_question_answers_join_the_turn_and_skipping_does_not_cancel_it() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent { session_steering: true, ..Default::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("wait"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
let handle = mgr.task(&task.id).unwrap();
handle.on_update(Some("s1"), &asynchronous_question());
assert!(mgr.answer_question(&task.id, "call-1", Some("{}".into())).await.is_err());
handle.live.lock().as_mut().unwrap().capabilities.steer = false;
assert!(mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.is_err());
assert!(handle.state.lock().task.queue.is_empty());
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
handle.live.lock().as_mut().unwrap().capabilities.steer = true;
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
assert!(
agent.calls.lock().iter().any(|call| call.starts_with("_session/steering ") && call.contains("questionItemId"))
);
assert!(!agent.calls.lock().iter().any(|call| call == "session/cancel"));
assert!(mgr.answer_question(&task.id, "call-1", None).await.is_err());
let mut question = asynchronous_question();
question["id"] = json!("call-2");
handle.on_update(Some("s1"), &question);
mgr.answer_question(&task.id, "call-2", None).await.unwrap();
assert!(
matches!(mgr.entries(&task.id, None).unwrap().last(), Some(AgentEntry::Question { chosen: Some(chosen), .. }) if chosen == "Skipped")
);
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn async_questions_can_be_answered_after_the_turn_ends() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.task(&task.id).unwrap().on_update(Some("s1"), &asynchronous_question());
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert!(
mgr.entries(&task.id, None)
.unwrap()
.iter()
.any(|entry| matches!(entry, AgentEntry::Question { chosen: Some(answer), .. } if answer == "Which?: One"))
);
let entries = mgr.entries(&task.id, None).unwrap();
assert!(
entries.iter().any(|entry| matches!(entry, AgentEntry::User { text, .. } if text.contains("questionItemId")))
);
}
#[tokio::test(flavor = "multi_thread")]
async fn steers_through_session_steering() {
let tmp = tempfile::tempdir().unwrap();
-36
Переглянути файл
@@ -54,23 +54,6 @@ impl Timeline {
let mut out = Applied::default();
let kind = update.get("sessionUpdate").and_then(Value::as_str).unwrap_or_default();
match kind {
"user_question" => {
let id = str_field(update, "id");
let Ok(questions) = serde_json::from_value::<Vec<crate::model::AgentQuestion>>(
update.get("questions").cloned().unwrap_or(Value::Null),
) else {
return out;
};
if id.is_empty()
|| questions.is_empty()
|| self.entries.iter().any(|e| matches!(e, AgentEntry::Question { id: known, .. } if known == &id))
{
return out;
}
let index =
self.push(AgentEntry::Question { id, title: str_field(update, "title"), questions, chosen: None });
out.changed.push(index);
}
"agent_message_chunk" | "agent_thought_chunk" => {
let Some(text) = content_text(update.get("content")) else { return out };
out.changed.push(self.append_text(kind == "agent_thought_chunk", &text));
@@ -405,25 +388,6 @@ mod tests {
use super::*;
use serde_json::json;
#[test]
fn asynchronous_questions_survive_turn_end_restart_and_duplicate_notifications() {
let mut t = Timeline::default();
let update = json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]});
assert_eq!(t.apply(&update).changed, vec![0]);
assert!(t.end_turn(None).is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: None, .. }));
let saved = serde_json::to_string(&t.entries).unwrap();
let mut t = Timeline::from_entries(serde_json::from_str(&saved).unwrap());
assert!(t.apply(&update).changed.is_empty());
assert_eq!(t.entries.len(), 1);
if let AgentEntry::Question { chosen, .. } = &mut t.entries[0] {
*chosen = Some("One".into());
}
assert!(t.apply(&update).changed.is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: Some(answer), .. } if answer == "One"));
}
#[test]
fn chunks_merge_into_one_message_until_another_entry_comes() {
let mut t = Timeline::default();
+3 -3
Переглянути файл
@@ -120,7 +120,7 @@ fn collect(
break;
}
}
let program = process::program_path(&step.program, &step.env, &step.cwd);
let program = process::program_path(&step.program, &step.env);
inputs.push(program.clone());
// Maven installed via a symlink still reads conf from its distribution.
if let Ok(program) = dunce::canonicalize(program)
@@ -131,7 +131,7 @@ fn collect(
}
}
if !environment.contains_key("JAVA_HOME") {
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env, &step.cwd);
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env);
inputs.push(java.clone());
if let Ok(java) = dunce::canonicalize(java)
&& let Some(home) = java.parent().and_then(Path::parent)
@@ -171,7 +171,7 @@ fn collect(
let steps = plan
.steps
.iter()
.map(|s| (process::program_path(&s.program, &s.env, &s.cwd), s.args.clone(), s.cwd.clone(), s.env.clone()))
.map(|s| (process::program_path(&s.program, &s.env), s.args.clone(), s.cwd.clone(), s.env.clone()))
.collect();
// Profiles and plugins can read arbitrary environment variables. Keep a signature
// of the inherited environment without persisting unrelated credentials.
+4 -5
Переглянути файл
@@ -25,9 +25,8 @@ pub(crate) struct Output {
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
/// search path — the login shell's `PATH` plus version-manager shims — since the
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there. The `PATH`
/// of the project holding `cwd` (its direnv `.envrc`) comes first.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &Path) -> std::path::PathBuf {
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std::path::PathBuf {
let path = std::path::Path::new(program);
if !path.is_relative() || path.components().count() > 1 {
return path.to_path_buf();
@@ -36,7 +35,7 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case("PATH"))
.map(|(_, v)| std::ffi::OsString::from(v))
.unwrap_or_else(|| ide_core::tool_path::search_path_in(cwd));
.unwrap_or_else(ide_core::tool_path::search_path);
ide_core::process::find_executable(program, &search).unwrap_or_else(|| path.to_path_buf())
}
@@ -66,7 +65,7 @@ pub(crate) fn run_with_env(
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
let encoding =
ide_core::output_encoding::fix(program, args, env, |k| std::env::var(k).ok(), "UTF-8", cfg!(windows));
let program = program_path(program, env, cwd);
let program = program_path(program, env);
let mut command = Command::new(&program);
command.args(args).current_dir(cwd).envs(env).envs(encoding.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
command.stdout(Stdio::piped()).stderr(Stdio::piped());
-20
Переглянути файл
@@ -47,12 +47,6 @@ pub enum IdeEvent {
root: crate::IpcPath,
trusted: bool,
},
/// The project's direnv environment (`.envrc`) could not be loaded, or a file it is read
/// from changed and it can be reloaded.
Direnv {
root: crate::IpcPath,
status: DirenvStatus,
},
/// Files or directories changed on disk (after debouncing, ignore rules applied).
FsChanged {
created: Vec<crate::IpcPath>,
@@ -234,20 +228,6 @@ pub enum AskpassKind {
Confirm,
}
/// See [`IdeEvent::Direnv`].
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum DirenvStatus {
/// `direnv` is not installed (on the search path).
NotInstalled,
/// direnv refuses the `.envrc` until the user approves it with `direnv allow`.
Blocked,
/// `direnv export` failed or took too long: what it printed last.
Failed { message: String },
/// `.envrc`, `flake.nix` or `flake.lock` (a file name in the project root) changed.
Changed { file: String },
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum ServerStatus {
-1
Переглянути файл
@@ -19,7 +19,6 @@ pub mod output_encoding;
pub mod platform;
pub mod process;
pub mod project_dir;
pub mod project_env;
pub mod project_roots;
pub mod proxy_settings;
pub mod real_path;
+12 -95
Переглянути файл
@@ -1,7 +1,6 @@
//! Child-process helpers shared by every crate that spawns tools.
use std::ffi::{OsStr, OsString};
use std::path::Path;
#[cfg(windows)]
use std::process::Stdio;
use std::process::{Child, Command};
@@ -19,8 +18,7 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
/// console child flashes a `cmd` window.
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
///
/// Variables the call site has already set are kept; call it before `env_clear` and after
/// `current_dir`, which picks the project environment.
/// Variables the call site has already set are kept; call it before `env_clear`.
pub fn prepare(cmd: &mut Command) -> &mut Command {
#[cfg(windows)]
{
@@ -518,13 +516,10 @@ mod windows_job {
/// those of a manual HTTP proxy ([`crate::proxy_settings::ProxySettings::child_env`]),
/// and the login shell's variables this process lacks ([`shell_env`]: an app started from
/// Finder/Dock doesn't have what rc files export, such as `GOPATH`, `JAVA_HOME` or
/// `MAVEN_OPTS`). A child whose `current_dir` is inside a project also gets the project's
/// environment ([`crate::project_env`]), so set it first. Variables the call site has
/// already set are kept.
/// `MAVEN_OPTS`). Variables the call site has already set are kept.
pub fn host_env(cmd: &mut Command) -> &mut Command {
let dir = cmd.get_current_dir().map(Path::to_path_buf);
let fixes = child_env_changes(dir.as_deref());
let shell: Vec<_> = shell_env_for(dir.as_deref()).collect();
let fixes = child_env_changes();
let shell: Vec<_> = shell_env().collect();
if fixes.is_empty() && shell.is_empty() {
return cmd;
}
@@ -545,40 +540,22 @@ pub fn host_env(cmd: &mut Command) -> &mut Command {
/// that are not a `std::process::Command` (a PTY `CommandBuilder`). Apply before the call
/// site's own variables. Empty outside an AppImage without an overlay.
pub fn host_env_fixes() -> Vec<(OsString, Option<OsString>)> {
child_env_changes(None)
}
/// [`host_env_fixes`] for a child started in `dir`, the environment of the project holding it included.
pub fn host_env_fixes_in(dir: &Path) -> Vec<(OsString, Option<OsString>)> {
child_env_changes(Some(dir))
child_env_changes()
}
/// This process's environment as a child should inherit it (see [`host_env`]), for call
/// sites that build a child's environment from the IDE's own instead of inheriting it.
pub fn host_vars() -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes(None)).into_iter()
}
/// [`host_vars`] for a child started in `dir`.
pub fn host_vars_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes(Some(dir))).into_iter()
apply_changes(std::env::vars_os().collect(), &child_env_changes()).into_iter()
}
/// [`std::env::var_os`] as a child should see it (see [`host_env`]), the login shell's value
/// included when this process lacks the variable.
pub fn host_var_os(key: impl AsRef<OsStr>) -> Option<OsString> {
host_var_os_for(None, key.as_ref())
}
/// [`host_var_os`] for a child started in `dir`.
pub fn host_var_os_in(dir: &Path, key: impl AsRef<OsStr>) -> Option<OsString> {
host_var_os_for(Some(dir), key.as_ref())
}
fn host_var_os_for(dir: Option<&Path>, key: &OsStr) -> Option<OsString> {
match child_env_changes(dir).into_iter().find(|(k, _)| k == key) {
let key = key.as_ref();
match child_env_changes().into_iter().find(|(k, _)| k == key) {
Some((_, fixed)) => fixed,
None => std::env::var_os(key).or_else(|| shell_env_for(dir).find(|(k, _)| k == key).map(|(_, v)| v)),
None => std::env::var_os(key).or_else(|| shell_env().find(|(k, _)| k == key).map(|(_, v)| v)),
}
}
@@ -601,9 +578,8 @@ fn apply_changes(
vars
}
/// The AppImage fixes, the overlay, the manual proxy's, then those of the project holding
/// `dir` (a later one wins); one entry per name.
fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
/// The AppImage fixes, the overlay, then the manual proxy's (a later one wins); one entry per name.
fn child_env_changes() -> Vec<(OsString, Option<OsString>)> {
let mut changes = appimage_fixes();
let overlay = env_overlay();
changes.retain(|(k, _)| !overlay.iter().any(|(o, _)| o == k));
@@ -612,11 +588,6 @@ fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
let proxy = crate::proxy_settings::proxy().child_env();
changes.retain(|(k, _)| !proxy.iter().any(|(p, _)| p == k));
changes.extend(proxy);
if let Some(dir) = dir {
let project = crate::project_env::for_dir(dir);
changes.retain(|(k, _)| !project.iter().any(|(p, _)| p == k));
changes.extend(project.iter().cloned());
}
changes
}
@@ -696,26 +667,11 @@ pub fn login_env() -> Option<Vars> {
/// Apply before a call site's own variables so those win. Empty until the shell has been read.
/// Names the overlay sets are left out: [`host_env`] gives them their value.
pub fn shell_env() -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(None)
}
/// [`shell_env`] for a child started in `dir`: names the environment of the project holding
/// it sets are left out too.
pub fn shell_env_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(Some(dir))
}
fn shell_env_for(dir: Option<&Path>) -> impl Iterator<Item = (OsString, OsString)> {
let overlay = env_overlay();
let project = dir.map(crate::project_env::for_dir).unwrap_or_default();
let vars = login_env().unwrap_or_default();
let lacking: Vec<_> = vars
.iter()
.filter(|(k, _)| {
std::env::var_os(k).is_none()
&& !overlay.iter().any(|(o, _)| o == k)
&& !project.iter().any(|(p, _)| p == k)
})
.filter(|(k, _)| std::env::var_os(k).is_none() && !overlay.iter().any(|(o, _)| o == k))
.cloned()
.collect();
lacking.into_iter()
@@ -1059,45 +1015,6 @@ mod tests {
set_env_overlay(Vec::new());
}
#[test]
fn a_child_inside_a_project_gets_its_environment() {
let root = std::path::Path::new("/openidea-test-process/project");
crate::project_env::set(
root,
vec![
("OPENIDEA_PROJECT_VAR".into(), Some("devshell".into())),
("PATH".into(), Some("/nix/store/x-devshell/bin".into())),
("OPENIDEA_PROJECT_UNSET".into(), None),
],
);
let get = |cmd: &Command, k: &str| cmd.get_envs().find(|(n, _)| *n == k).map(|(_, v)| v.map(OsStr::to_owned));
let mut inside = Command::new("true");
inside.current_dir(root.join("src")).env("OPENIDEA_PROJECT_VAR", "call site");
host_env(&mut inside);
assert_eq!(get(&inside, "PATH"), Some(Some("/nix/store/x-devshell/bin".into())));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_UNSET"), Some(None));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_VAR"), Some(Some("call site".into())), "the call site's value wins");
let mut outside = Command::new("true");
outside.current_dir("/openidea-test-process/other");
host_env(&mut outside);
assert_eq!(get(&outside, "OPENIDEA_PROJECT_VAR"), None);
let mut no_dir = Command::new("true");
host_env(&mut no_dir);
assert_eq!(get(&no_dir, "OPENIDEA_PROJECT_VAR"), None);
// Spawners that build the environment themselves (PTYs, runs) and `PATH` lookups.
assert!(host_env_fixes_in(root).iter().any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v.is_some()));
assert!(host_vars_in(root).any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v == "devshell"));
assert_eq!(host_var_os_in(root, "OPENIDEA_PROJECT_VAR"), Some("devshell".into()));
assert_eq!(host_var_os("OPENIDEA_PROJECT_VAR"), None);
let search = crate::tool_path::search_path_in(root);
assert_eq!(std::env::split_paths(&search).next(), Some("/nix/store/x-devshell/bin".into()));
crate::project_env::remove(root);
assert!(host_vars_in(root).all(|(k, _)| k != "OPENIDEA_PROJECT_VAR"));
}
#[test]
fn changes_apply_in_order() {
let vars = apply_changes(
-138
Переглянути файл
@@ -1,138 +0,0 @@
//! Environments of project folders (a project's direnv `.envrc`), for the children started
//! inside them. One process can hold several projects (desktop windows), so unlike the
//! process-wide overlay ([`crate::process::set_env_overlay`]) these are kept per root and
//! found from a child's working directory: see [`crate::process::host_env`] and the `_in`
//! variants next to it.
use crate::CancellationToken;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
use std::time::Duration;
pub type Changes = Arc<Vec<(OsString, Option<OsString>)>>;
struct Entry {
root: PathBuf,
changes: Changes,
loading: bool,
}
static ENTRIES: Mutex<Vec<Entry>> = Mutex::new(Vec::new());
static SETTLED: Condvar = Condvar::new();
fn entries() -> MutexGuard<'static, Vec<Entry>> {
ENTRIES.lock().unwrap_or_else(|e| e.into_inner())
}
/// `root`'s environment is being read: [`wait`] blocks until [`set`] or [`remove`]. Children
/// started meanwhile keep getting the last one read.
pub fn begin_loading(root: &Path) {
let mut entries = entries();
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => entry.loading = true,
None => entries.push(Entry { root: root.to_path_buf(), changes: Changes::default(), loading: true }),
}
}
/// What children started in `root` (or below it) get on top of the IDE's own environment
/// (`None`: removed). Ends a [`begin_loading`].
pub fn set(root: &Path, changes: Vec<(OsString, Option<OsString>)>) {
let mut entries = entries();
let changes = Arc::new(changes);
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => {
entry.changes = changes;
entry.loading = false;
}
None => entries.push(Entry { root: root.to_path_buf(), changes, loading: false }),
}
SETTLED.notify_all();
}
/// Ends a [`begin_loading`] that read nothing new (an error): the last environment stays.
pub fn settle(root: &Path) {
if let Some(entry) = entries().iter_mut().find(|e| e.root == root) {
entry.loading = false;
}
SETTLED.notify_all();
}
/// `root` has no environment of its own any more (closed, or not trusted).
pub fn remove(root: &Path) {
entries().retain(|e| e.root != root);
SETTLED.notify_all();
}
/// The innermost root holding `dir`.
fn find<'a>(entries: &'a [Entry], dir: &Path) -> Option<&'a Entry> {
entries.iter().filter(|e| dir.starts_with(&e.root)).max_by_key(|e| e.root.components().count())
}
/// The environment of the project holding `dir` (empty outside every project, or before it was read).
pub fn for_dir(dir: &Path) -> Changes {
find(&entries(), dir).map(|e| e.changes.clone()).unwrap_or_default()
}
/// Whether the environment of the project holding `dir` is being read.
pub fn is_loading(dir: &Path) -> bool {
find(&entries(), dir).is_some_and(|e| e.loading)
}
/// Blocks while the environment of the project holding `dir` is being read, or until `cancel`.
/// For what must not start without it: language servers.
pub fn wait(dir: &Path, cancel: &CancellationToken) {
let mut entries = entries();
while !cancel.is_cancelled() && find(&entries, dir).is_some_and(|e| e.loading) {
entries = SETTLED.wait_timeout(entries, Duration::from_millis(200)).unwrap_or_else(|e| e.into_inner()).0;
}
}
#[cfg(test)]
mod tests {
use super::*;
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn the_innermost_project_holding_a_folder_applies() {
let outer = Path::new("/openidea-test-env/outer");
let inner = Path::new("/openidea-test-env/outer/inner");
set(outer, vec![change("A", Some("outer"))]);
set(inner, vec![change("A", Some("inner")), change("B", None)]);
assert_eq!(*for_dir(&outer.join("src")), [change("A", Some("outer"))]);
assert_eq!(*for_dir(&inner.join("src/deep")), [change("A", Some("inner")), change("B", None)]);
assert!(for_dir(Path::new("/openidea-test-env/outer-sibling")).is_empty(), "whole components only");
remove(inner);
assert_eq!(*for_dir(inner), [change("A", Some("outer"))]);
remove(outer);
assert!(for_dir(inner).is_empty());
}
#[test]
fn waiting_ends_once_the_environment_is_read() {
let root = Path::new("/openidea-test-env/waiting");
set(root, vec![change("OLD", Some("1"))]);
begin_loading(root);
assert!(is_loading(&root.join("src")));
assert_eq!(*for_dir(root), [change("OLD", Some("1"))], "the last one read stays until then");
let reader = std::thread::spawn(|| {
std::thread::sleep(Duration::from_millis(100));
set(Path::new("/openidea-test-env/waiting"), vec![change("NEW", Some("2"))]);
});
wait(&root.join("src"), &CancellationToken::new());
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
reader.join().unwrap();
begin_loading(root);
let cancel = CancellationToken::new();
cancel.cancel();
wait(root, &cancel);
settle(root);
assert!(!is_loading(root));
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
remove(root);
}
}
-30
Переглянути файл
@@ -783,35 +783,6 @@ pub struct AppearanceSettings {
pub main_toolbar: Option<MainToolbarSettings>,
/// Appearance › Background Image: an image shown through the IDE window.
pub background_image: BackgroundImageSettings,
/// Appearance › Presentation Assistant: the name and shortcut of each action run.
pub presentation_assistant: PresentationAssistantSettings,
}
/// Appearance › Presentation Assistant: shows the name and shortcut of each action the user runs.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct PresentationAssistantSettings {
pub enabled: bool,
/// `small` | `medium` | `large`.
pub size: String,
/// How long each popup stays, in seconds.
pub duration_seconds: u32,
/// `top-left`, `top`, `top-right`, `bottom-left`, `bottom` or `bottom-right` of the window.
pub position: String,
/// Also show the shortcut of the other platform's keymap (macOS ⇄ Windows/Linux).
pub alternate_keymap: bool,
}
impl Default for PresentationAssistantSettings {
fn default() -> Self {
Self {
enabled: false,
size: "medium".into(),
duration_seconds: 4,
position: "bottom".into(),
alternate_keymap: false,
}
}
}
/// Appearance › Background Image. An empty `path` shows no image.
@@ -904,7 +875,6 @@ impl Default for AppearanceSettings {
status_bar_widgets: BTreeMap::new(),
main_toolbar: None,
background_image: BackgroundImageSettings::default(),
presentation_assistant: PresentationAssistantSettings::default(),
}
}
}
+2 -16
Переглянути файл
@@ -2,7 +2,7 @@
//! their settings come from, installers. An app started from the desktop gets a
//! minimal `PATH`, and version managers set theirs up in shell rc files.
use crate::process::{host_var_os, host_var_os_in, login_env};
use crate::process::{host_var_os, login_env};
use crate::version_managers;
use std::collections::HashSet;
use std::ffi::{OsStr, OsString};
@@ -14,16 +14,6 @@ use std::path::{Path, PathBuf};
/// launchers, their settings hooks and tool detection all look here, so a settings
/// hook finds the executable its server is launched from.
pub fn search_path() -> OsString {
search_path_for(None)
}
/// [`search_path`] for a child started in `dir`: the `PATH` of the project holding it
/// ([`crate::project_env`], e.g. a Nix devshell's) comes first.
pub fn search_path_in(dir: &Path) -> OsString {
search_path_for(Some(dir))
}
fn search_path_for(dir: Option<&Path>) -> OsString {
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from);
let shell_path = login_env().and_then(|env| env.iter().find(|(k, _)| k == "PATH").map(|(_, v)| v.clone()));
let shims: Vec<PathBuf> = version_managers::managers().iter().map(|m| m.shims()).collect();
@@ -31,11 +21,7 @@ fn search_path_for(dir: Option<&Path>) -> OsString {
// entries after the inherited ones so missing user tools still resolve.
let user_path = crate::process::user_path();
let dirs = search_dirs(
match dir {
Some(dir) => host_var_os_in(dir, "PATH"),
None => host_var_os("PATH"),
}
.as_deref(),
host_var_os("PATH").as_deref(),
shell_path.as_deref(),
user_path.as_deref(),
home.as_deref(),
-3
Переглянути файл
@@ -135,8 +135,6 @@ pub struct CommitSettings {
/// `Settings::default()`, or `SettingsStore::set` rejects the key as unknown.
#[specta(optional)]
pub double_click_opens_diff: Option<bool>,
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
pub agent_instructions: String,
}
impl Default for CommitSettings {
@@ -158,7 +156,6 @@ impl Default for CommitSettings {
wrap_at_margin: false,
disabled_plugin_checks: Vec::new(),
double_click_opens_diff: None,
agent_instructions: String::new(),
}
}
}
+2 -1
Переглянути файл
@@ -214,8 +214,9 @@ pub fn collect(spec: &CoverageReportSpec) -> IdeResult<CoverageSuite> {
CoverageReportSpec::Exported { runner, argv, cwd, env, lcov } => {
let (program, args) =
argv.split_first().ok_or_else(|| IdeError::invalid("empty coverage export command"))?;
let out = ide_core::process::prepare(Command::new(program).current_dir(cwd))
let out = ide_core::process::prepare(&mut Command::new(program))
.args(args)
.current_dir(cwd)
.envs(env)
.output()
.map_err(|e| IdeError::unavailable(format!("cannot run {program}: {e}")))?;
+14 -17
Переглянути файл
@@ -281,16 +281,15 @@ fn managed_dirs(root: &Path) -> Vec<PathBuf> {
/// The `PATH` an adapter runs with, unless its launch sets one: the search path language servers
/// get, so what it starts in turn (js-debug's wrapper runs `node`, Delve runs `go build`) is
/// found like Run finds it, even when the login shell's `PATH` didn't reach the app.
fn adapter_path(env: &[(String, String)], cwd: &Path) -> Option<std::ffi::OsString> {
fn adapter_path(env: &[(String, String)]) -> Option<std::ffi::OsString> {
let own = env.iter().any(|(k, _)| if cfg!(windows) { k.eq_ignore_ascii_case("PATH") } else { k == "PATH" });
(!own).then(|| ide_core::tool_path::search_path_in(cwd))
(!own).then(ide_core::tool_path::search_path)
}
/// Directories searched for adapter binaries: managed tools first, then `PATH` (the project's
/// holding `cwd` first) and the usual install spots.
fn search_dirs(cwd: &Path) -> Vec<PathBuf> {
/// Directories searched for adapter binaries: managed tools first, then `PATH` and the usual install spots.
fn search_dirs() -> Vec<PathBuf> {
let mut dirs: Vec<PathBuf> = tools_root().map(|r| managed_dirs(&r)).unwrap_or_default();
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path_in(cwd)));
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path()));
if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
for rel in [".cargo/bin", ".local/bin", "go/bin", ".dotnet/tools", ".bun/bin", ".npm-global/bin", ".volta/bin"]
{
@@ -319,7 +318,7 @@ fn is_executable(path: &Path, windows: bool) -> bool {
/// extensionless script next to a shim is never started as a program.
pub fn find_binary(command: &str, cwd: &Path) -> Option<PathBuf> {
let pathext = std::env::var("PATHEXT").ok();
find_binary_in(command, cwd, &search_dirs(cwd), cfg!(windows), pathext.as_deref())
find_binary_in(command, cwd, &search_dirs(), cfg!(windows), pathext.as_deref())
}
fn find_binary_in(
@@ -378,10 +377,10 @@ pub async fn prepare_debugpy(spec: &mut AdapterSpec) -> IdeResult<()> {
return Ok(()); // Reported as a missing adapter when it is started.
};
let mut probe = Command::new(&python);
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.args(["-c", "import debugpy.adapter"])
.current_dir(&spec.cwd)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
@@ -453,13 +452,13 @@ pub fn parse_gdb_version(output: &str) -> Option<(u32, u32)> {
/// Probe the already resolved and verified executable with its launch environment.
async fn gdb_version(binary: &Path, spec: &AdapterSpec) -> IdeResult<Option<(u32, u32)>> {
let mut probe = Command::new(binary);
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
if let Some(path) = adapter_path(&spec.env) {
probe.env("PATH", path);
}
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.arg("--version")
.current_dir(&spec.cwd)
.envs(spec.env.iter().cloned())
.stdin(Stdio::null())
.stdout(Stdio::piped())
@@ -691,11 +690,9 @@ async fn spawn_adapter(
) -> IdeResult<AdapterIo> {
let stderr = Arc::new(parking_lot::Mutex::new(Vec::new()));
let mut cmd = Command::new(binary);
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
if let Some(path) = adapter_path(&spec.env) {
cmd.env("PATH", path);
}
// The working directory first: it picks the project's environment.
cmd.current_dir(&spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
// Every adapter leads its own process group: the program an adapter launches itself
// (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
@@ -703,6 +700,7 @@ async fn spawn_adapter(
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.envs(spec.env.iter().map(|(k, v)| (k, v)))
.current_dir(&spec.cwd)
.stdin(if port.is_some() { Stdio::null() } else { Stdio::piped() })
.stdout(Stdio::piped())
.stderr(Stdio::piped())
@@ -845,11 +843,10 @@ mod tests {
#[test]
fn adapters_run_on_the_tool_search_path() {
let search = ide_core::tool_path::search_path();
let cwd = Path::new("/openidea-test-no-project");
assert_eq!(adapter_path(&[], cwd), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())], cwd), Some(search));
assert_eq!(adapter_path(&[]), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())]), Some(search));
// A launch that sets its own (a selected Go SDK's bin first) keeps it.
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())], cwd), None);
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())]), None);
// The search path reaches the usual install spots even when this process's `PATH` doesn't.
#[cfg(unix)]
{
+1 -1
Переглянути файл
@@ -55,10 +55,10 @@ pub async fn build(
) -> IdeResult<PathBuf> {
let cargo = find_binary("cargo", cwd).ok_or_else(|| IdeError::unavailable("`cargo` not found on PATH"))?;
let mut cmd = tokio::process::Command::new(cargo);
cmd.current_dir(cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(args)
.arg("--message-format=json-render-diagnostics")
.current_dir(cwd)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
+1 -15
Переглянути файл
@@ -216,21 +216,7 @@ pub(crate) async fn serve(
}
}
if holding {
let (disable, command) = call("Fetch.disable", json!({}));
if write.send(command).await.is_ok() {
// Wait until the proxy has disabled interception before closing the
// socket. Dropping it with unread replies can reset the connection.
let _ = tokio::time::timeout(REQUEST_TIMEOUT, async {
while let Some(Ok(message)) = read.next().await {
let Ok(text) = message.to_text() else { continue };
let Ok(reply) = serde_json::from_str::<Value>(text) else { continue };
if reply.get("id").and_then(Value::as_u64) == Some(disable) {
break;
}
}
})
.await;
}
let _ = write.send(call("Fetch.disable", json!({})).1).await;
}
let _ = write.close().await;
}
+8 -6
Переглянути файл
@@ -979,18 +979,20 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
let mut cmd = CommandBuilder::new(program);
// CodeLLDB's launcher clears the terminal first; the console keeps the session's earlier output.
cmd.args(rest.iter().filter(|a| *a != "--clear-screen"));
let cwd = args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()).map_or(s.spec.cwd.as_path(), Path::new);
for (k, v) in ide_core::process::host_env_fixes_in(cwd) {
for (k, v) in ide_core::process::host_env_fixes() {
match v {
Some(v) => cmd.env(k, v),
None => cmd.env_remove(k),
}
}
for (k, v) in ide_core::process::shell_env_in(cwd) {
for (k, v) in ide_core::process::shell_env() {
cmd.env(k, v);
}
cmd.env("TERM", "xterm-256color");
cmd.cwd(cwd);
match args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {
Some(cwd) => cmd.cwd(cwd),
None => cmd.cwd(&s.spec.cwd),
}
if let Some(env) = args.get("env").and_then(Value::as_object) {
for (k, v) in env {
match v.as_str() {
@@ -1161,7 +1163,6 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
let classpath =
std::env::join_paths(strings("classPaths")).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
let mut cmd = tokio::process::Command::new(java);
cmd.current_dir(&s.spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(kotlin_jvm_args(strings("vmArguments"), cfg!(windows)))
// Let the JVM pick its own port (`:0`) and report it below: pre-picking a free
@@ -1180,7 +1181,8 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
.ok_or_else(|| ide_core::IdeError::invalid("Missing Kotlin main class"))?,
)
.args(strings("programArgs"))
.envs(ide_core::process::shell_env_in(&s.spec.cwd))
.current_dir(&s.spec.cwd)
.envs(ide_core::process::shell_env())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
+4 -4
Переглянути файл
@@ -812,16 +812,16 @@ impl DbManager {
let password = self.password(&source).await;
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
let prepared = tools::prepare(job, executable, &target, password.as_deref())?;
tools::run(executable, &prepared.args, &prepared.env, prepared.input.as_deref(), cancel, on_output).await
let prepared = tools::prepare(job, &target, password.as_deref());
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
}
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
/// own host and port (not a tunnel's local end), and no password.
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
let source = self.source(id)?;
let prepared = tools::prepare(job, executable, &source, None)?;
Ok(tools::command_line(executable, &prepared.args, job.input()))
let prepared = tools::prepare(job, &source, None);
Ok(tools::command_line(executable, &prepared.args))
}
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
+4 -215
Переглянути файл
@@ -2,7 +2,6 @@
//! The connection arguments come from [`super::connection`]; these are the rest.
use super::DbTool;
use ide_core::{IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
@@ -59,8 +58,6 @@ pub struct DbPgDumpOptions {
pub struct DbPgRestoreOptions {
pub content: DbDumpContent,
pub schemas: Vec<String>,
/// Creates the database the archive names; the target is only connected to.
pub create: bool,
pub clean: bool,
pub if_exists: bool,
pub no_owner: bool,
@@ -78,40 +75,6 @@ pub struct DbPsqlOptions {
pub stop_on_error: bool,
}
/// Switches that `mysqldump` turns on by default (`--opt`) only take a flag when turned off.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqldumpOptions {
/// Empty: every database.
pub databases: Vec<String>,
/// Only with exactly one database.
pub tables: Vec<String>,
pub add_drop_table: bool,
pub disable_keys: bool,
pub add_locks: bool,
pub add_drop_trigger: bool,
pub no_data: bool,
pub complete_insert: bool,
pub create_options: bool,
pub routines: bool,
pub events: bool,
/// A consistent InnoDB snapshot without locks; needs no RELOAD privilege.
pub single_transaction: bool,
/// Wins over `single_transaction`.
pub lock_all_tables: bool,
/// `None`: the client has no `--masking-policies`.
pub masking_policies: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqlOptions {
/// Empty: the databases the dump names.
pub database: String,
/// Runs the remaining statements after an error.
pub force: bool,
}
/// A run of a client tool: which one, the file it writes or reads, and its options.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "tool", rename_all = "camelCase")]
@@ -129,15 +92,6 @@ pub enum DbToolJob {
file: String,
options: DbPsqlOptions,
},
Mysqldump {
file: String,
options: DbMysqldumpOptions,
},
/// `file` goes to the standard input.
Mysql {
file: String,
options: DbMysqlOptions,
},
}
impl DbToolJob {
@@ -146,38 +100,15 @@ impl DbToolJob {
DbToolJob::PgDump { .. } => DbTool::PgDump,
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
DbToolJob::Psql { .. } => DbTool::Psql,
DbToolJob::Mysqldump { .. } => DbTool::Mysqldump,
DbToolJob::Mysql { .. } => DbTool::Mysql,
}
}
/// The file piped to the tool's standard input.
pub fn input(&self) -> Option<&str> {
match self {
DbToolJob::Mysql { file, .. } if !file.is_empty() => Some(file),
_ => None,
}
}
/// Refuses names that the tool would read as options: `mysqldump` takes databases and tables
/// as plain arguments.
pub fn check(&self) -> IdeResult<()> {
if let DbToolJob::Mysqldump { options, .. } = self
&& let Some(name) = options.databases.iter().chain(&options.tables).find(|n| n.trim().starts_with('-'))
{
return Err(IdeError::invalid(format!("mysqldump cannot dump a database or table named {name}")));
}
Ok(())
}
/// The arguments after the connection ones.
pub fn args(&self) -> Vec<String> {
match self {
DbToolJob::PgDump { file, options } => pg_dump(options, file),
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
DbToolJob::Psql { file, options } => psql(options, file),
DbToolJob::Mysqldump { file, options } => mysqldump(options, file),
DbToolJob::Mysql { options, .. } => mysql(options),
}
}
}
@@ -231,7 +162,6 @@ fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
let mut args: Vec<String> = content(o.content).into_iter().collect();
args.extend(each(&o.schemas, "schema"));
args.extend(flag(o.create, "--create"));
args.extend(flag(o.clean, "--clean"));
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
args.extend(flag(o.no_owner, "--no-owner"));
@@ -257,53 +187,8 @@ fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
args
}
fn names(list: &[String]) -> impl Iterator<Item = String> {
list.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(str::to_owned)
}
fn mysqldump(o: &DbMysqldumpOptions, file: &str) -> Vec<String> {
let skip = |on: bool, option: &str| (!on).then(|| format!("--skip-{option}"));
let mut args = vec![format!("--result-file={file}")];
args.extend(skip(o.add_drop_table, "add-drop-table"));
args.extend(skip(o.disable_keys, "disable-keys"));
args.extend(skip(o.add_locks, "add-locks"));
args.extend(skip(o.create_options, "create-options"));
args.extend(flag(o.add_drop_trigger, "--add-drop-trigger"));
args.extend(flag(o.no_data, "--no-data"));
args.extend(flag(o.complete_insert, "--complete-insert"));
args.extend(flag(o.routines, "--routines"));
args.extend(flag(o.events, "--events"));
args.extend(flag(o.lock_all_tables, "--lock-all-tables"));
args.extend(flag(!o.lock_all_tables && o.single_transaction, "--single-transaction"));
// On by default where it exists; reading the policies needs privileges most users lack.
args.extend(flag(o.masking_policies == Some(false), "--skip-masking-policies"));
// Tablespace statements need the PROCESS privilege and rarely matter in a dump.
args.push("--no-tablespaces".into());
args.push("--verbose".into());
let databases: Vec<String> = names(&o.databases).collect();
match databases.as_slice() {
[] => args.push("--all-databases".into()),
[one] => {
args.push(one.clone());
args.extend(names(&o.tables));
}
_ => {
args.push("--databases".into());
args.extend(databases);
}
}
args
}
fn mysql(o: &DbMysqlOptions) -> Vec<String> {
let database = o.database.trim();
let mut args: Vec<String> = (!database.is_empty()).then(|| format!("--database={database}")).into_iter().collect();
args.extend(flag(o.force, "--force"));
args
}
/// The command as a shell would need it typed: the dialogs' preview. `input` is piped in.
pub fn command_line(program: &Path, args: &[String], input: Option<&str>) -> String {
/// The command as a shell would need it typed: the dialogs' preview.
pub fn command_line(program: &Path, args: &[String]) -> String {
let quote = |s: &str| {
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
s.to_owned()
@@ -311,15 +196,11 @@ pub fn command_line(program: &Path, args: &[String], input: Option<&str>) -> Str
format!("'{}'", s.replace('\'', "'\\''"))
}
};
let line = std::iter::once(program.to_string_lossy().into_owned())
std::iter::once(program.to_string_lossy().into_owned())
.chain(args.iter().cloned())
.map(|a| quote(&a))
.collect::<Vec<_>>()
.join(" ");
match input {
Some(file) => format!("{line} < {}", quote(file)),
None => line,
}
.join(" ")
}
#[cfg(test)]
@@ -347,7 +228,6 @@ mod tests {
DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
@@ -428,13 +308,6 @@ mod tests {
);
}
#[test]
fn creates_the_database_of_the_archive_when_asked() {
let options = DbPgRestoreOptions { create: true, ..restore() };
let a = args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options });
assert_eq!(a, ["--create", "--exit-on-error", "--verbose", "/tmp/shop.dump"]);
}
#[test]
fn leaves_out_an_archive_not_chosen_yet() {
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
@@ -455,92 +328,8 @@ mod tests {
let line = command_line(
Path::new("/usr/bin/pg_dump"),
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
None,
);
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
let line = command_line(Path::new("mysql"), &["--force".into()], Some("/tmp/my dump.sql"));
assert_eq!(line, "mysql --force < '/tmp/my dump.sql'");
}
fn mysqldump_options() -> DbMysqldumpOptions {
DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
}
}
#[test]
fn mysqldump_flags_only_what_differs_from_its_defaults() {
let job = DbToolJob::Mysqldump { file: "/tmp/shop.sql".into(), options: mysqldump_options() };
assert_eq!(
args(job),
["--result-file=/tmp/shop.sql", "--single-transaction", "--no-tablespaces", "--verbose", "shop"]
);
let options = DbMysqldumpOptions {
add_drop_table: false,
create_options: false,
routines: true,
lock_all_tables: true,
masking_policies: Some(false),
..mysqldump_options()
};
let a = args(DbToolJob::Mysqldump { file: "/tmp/x.sql".into(), options });
for expected in ["--skip-add-drop-table", "--skip-create-options", "--routines", "--lock-all-tables"] {
assert!(a.contains(&expected.to_owned()), "{expected} missing from {a:?}");
}
assert!(a.contains(&"--skip-masking-policies".to_owned()), "{a:?}");
assert!(!a.contains(&"--single-transaction".to_owned()), "{a:?}");
}
#[test]
fn mysqldump_names_tables_only_of_a_single_database() {
let tables = vec!["orders".to_owned(), "items".to_owned()];
let one = DbMysqldumpOptions { tables: tables.clone(), ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: one }).ends_with(&[
"shop".into(),
"orders".into(),
"items".into()
]));
let two = DbMysqldumpOptions { databases: vec!["a".into(), "b".into()], tables, ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: two }).ends_with(&[
"--databases".into(),
"a".into(),
"b".into()
]));
let all = DbMysqldumpOptions { databases: vec![], ..mysqldump_options() };
assert_eq!(args(DbToolJob::Mysqldump { file: "f".into(), options: all }).last().unwrap(), "--all-databases");
}
#[test]
fn mysqldump_refuses_names_it_would_read_as_options() {
let options = DbMysqldumpOptions { tables: vec!["--result-file=/etc/x".into()], ..mysqldump_options() };
assert!(DbToolJob::Mysqldump { file: "f".into(), options }.check().is_err());
assert!(DbToolJob::Mysqldump { file: "f".into(), options: mysqldump_options() }.check().is_ok());
}
#[test]
fn mysql_reads_the_dump_from_its_standard_input() {
let job = DbToolJob::Mysql {
file: "/tmp/shop.sql".into(),
options: DbMysqlOptions { database: " shop ".into(), force: true },
};
assert_eq!(args(job.clone()), ["--database=shop", "--force"]);
assert_eq!(job.input(), Some("/tmp/shop.sql"));
let none =
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: String::new(), force: false } };
assert!(args(none.clone()).is_empty() && none.input().is_none());
}
#[test]
+48 -336
Переглянути файл
@@ -1,6 +1,5 @@
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`, `mysqldump`, `mysql`): finding
//! installed copies, the arguments and environment that connect them like the data source, and
//! running them.
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
//! arguments and environment that connect them like the data source, and running them.
mod jobs;
pub use jobs::*;
@@ -21,8 +20,6 @@ pub enum DbTool {
PgDump,
PgRestore,
Psql,
Mysqldump,
Mysql,
}
impl DbTool {
@@ -30,25 +27,20 @@ impl DbTool {
self.programs()[0]
}
/// Executable names, MariaDB's own after MySQL's.
/// Executable names.
pub fn programs(self) -> &'static [&'static str] {
match self {
DbTool::PgDump => &["pg_dump"],
DbTool::PgRestore => &["pg_restore"],
DbTool::Psql => &["psql"],
DbTool::Mysqldump => &["mysqldump", "mariadb-dump"],
DbTool::Mysql => &["mysql", "mariadb"],
}
}
pub fn driver(self) -> DbDriver {
match self {
DbTool::PgDump | DbTool::PgRestore | DbTool::Psql => DbDriver::Postgres,
DbTool::Mysqldump | DbTool::Mysql => DbDriver::Mysql,
}
DbDriver::Postgres
}
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`, `mariadb-dump`…).
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
/// The data source's password is handed only to such a program.
pub fn is_program(self, path: &Path) -> bool {
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
@@ -61,12 +53,6 @@ impl DbTool {
}
}
/// Whether `executable` is MariaDB's client (`mariadb`, `mariadb-dump`), whose SSL options differ
/// from MySQL's.
fn is_mariadb(executable: &Path) -> bool {
executable.file_stem().and_then(OsStr::to_str).is_some_and(|s| s.starts_with("mariadb"))
}
/// An installed copy of a tool.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
@@ -84,41 +70,28 @@ pub struct ToolLine {
pub text: String,
}
/// Directories holding the tools of `driver` that are often missing from `PATH`, by platform.
fn known_dirs(driver: DbDriver) -> Vec<PathBuf> {
let mysql = driver == DbDriver::Mysql;
/// Directories holding the tools that are often missing from `PATH`, by platform.
fn known_dirs() -> Vec<PathBuf> {
let mut dirs = Vec::new();
if cfg!(target_os = "macos") {
for prefix in ["/opt/homebrew", "/usr/local"] {
dirs.push(PathBuf::from(format!("{prefix}/bin")));
let opt = PathBuf::from(format!("{prefix}/opt"));
let kegs: &[&str] = if mysql { &["mysql-client", "mysql", "mariadb"] } else { &["libpq", "postgresql"] };
for keg in kegs {
for keg in ["libpq", "postgresql"] {
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
}
}
if mysql {
dirs.push(PathBuf::from("/usr/local/mysql/bin"));
} else {
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "")
.into_iter()
.map(|d| d.join("bin")),
);
}
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
);
} else if cfg!(windows) {
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
if let Some(base) = std::env::var_os(var) {
let base = PathBuf::from(base);
// MySQL installs to `MySQL\MySQL Server 8.4`, MariaDB to `MariaDB 11.4`.
let roots: &[(&str, &str)] =
if mysql { &[("MySQL", "MySQL"), ("", "MariaDB")] } else { &[("PostgreSQL", "")] };
for (dir, prefix) in roots {
dirs.extend(children(&base.join(dir), prefix).into_iter().map(|d| d.join("bin")));
}
let root = PathBuf::from(base).join("PostgreSQL");
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
}
}
} else if !mysql {
} else {
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
}
@@ -148,7 +121,7 @@ fn version_key(text: &str) -> Vec<u32> {
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
dirs.extend(known_dirs(tool.driver()));
dirs.extend(known_dirs());
let mut seen = Vec::new();
let mut out = Vec::new();
for dir in dirs {
@@ -177,29 +150,6 @@ pub fn version_of(path: &Path) -> IdeResult<String> {
}
}
/// The long options `path --help` lists (`masking-policies` for `--masking-policies`), so a
/// dialog offers only options this copy knows. Blocking.
pub fn options_of(path: &Path) -> IdeResult<Vec<String>> {
let (_, text) = capture(path, "--help")?;
Ok(help_options(&text))
}
fn help_options(help: &str) -> Vec<String> {
let mut out: Vec<String> = help
.lines()
.filter(|l| l.starts_with(' ') && l.trim_start().starts_with('-'))
.filter_map(|l| {
let at = l.find("--")?;
let name: String =
l[at + 2..].chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_').collect();
(!name.is_empty()).then_some(name)
})
.collect();
out.sort();
out.dedup();
out
}
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
if !path.is_file() {
@@ -239,41 +189,23 @@ pub enum DbDumpKind {
PostgresArchive,
/// Plain SQL from `pg_dump`: `psql`.
PostgresSql,
/// `mysqldump` / `mariadb-dump`: `mysql`.
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
MysqlSql,
Unknown,
}
/// What a restore needs to know about a dump before it runs.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbDumpInfo")]
pub struct DumpInfo {
pub kind: DbDumpKind,
/// An SQL dump that runs `CREATE DATABASE` itself: `mysqldump --databases` / `--all-databases`,
/// or `pg_dump --create`. Archives say `false`; `pg_restore --create` decides for them.
pub creates_database: bool,
}
/// Blocking: reads at most the first 64 KiB, where both tools write their `CREATE DATABASE`.
pub fn dump_info(path: &Path) -> IdeResult<DumpInfo> {
/// Blocking: reads at most the first 4 KiB.
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
use std::io::Read;
if path.is_dir() {
let kind = if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown };
return Ok(DumpInfo { kind, creates_database: false });
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
}
let mut head = Vec::with_capacity(64 * 1024);
let mut head = Vec::with_capacity(4096);
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
.take(64 * 1024)
.take(4096)
.read_to_end(&mut head)?;
Ok(info_of(&head))
}
fn info_of(head: &[u8]) -> DumpInfo {
let kind = kind_of(head);
let sql = matches!(kind, DbDumpKind::PostgresSql | DbDumpKind::MysqlSql);
let creates_database = sql && String::from_utf8_lossy(head).lines().any(|l| l.starts_with("CREATE DATABASE "));
DumpInfo { kind, creates_database }
Ok(kind_of(&head))
}
fn kind_of(head: &[u8]) -> DbDumpKind {
@@ -292,12 +224,9 @@ fn kind_of(head: &[u8]) -> DbDumpKind {
}
}
/// Arguments and environment that connect `tool` at `executable` to `source` (already resolved,
/// through its tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, executable: &Path, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
if tool.driver() == DbDriver::Mysql {
return (mysql_connection(tool, executable, source), Vec::new());
}
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
/// tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
@@ -342,50 +271,6 @@ pub fn connection(tool: DbTool, executable: &Path, source: &DataSource) -> (Vec<
(args, env)
}
/// The database is the job's: a dump may name several.
fn mysql_connection(tool: DbTool, executable: &Path, source: &DataSource) -> Vec<String> {
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
args.push(format!("--host={host}"));
}
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(3306)));
if !source.user.trim().is_empty() {
args.push(format!("--user={}", source.user.trim()));
}
// `localhost` would otherwise mean the Unix socket, not the port or the tunnel.
args.push("--protocol=TCP".into());
if is_mariadb(executable) {
let flags: &[&str] = match source.ssl {
DbSslMode::Disable => &["--skip-ssl"],
DbSslMode::Prefer => &["--skip-ssl-verify-server-cert"],
DbSslMode::Require => &["--ssl", "--skip-ssl-verify-server-cert"],
DbSslMode::VerifyCa | DbSslMode::VerifyFull => &["--ssl", "--ssl-verify-server-cert"],
};
args.extend(flags.iter().map(|f| f.to_string()));
} else {
let mode = match source.ssl {
DbSslMode::Disable => "DISABLED",
DbSslMode::Prefer => "PREFERRED",
DbSslMode::Require => "REQUIRED",
DbSslMode::VerifyCa => "VERIFY_CA",
DbSslMode::VerifyFull => "VERIFY_IDENTITY",
};
args.push(format!("--ssl-mode={mode}"));
}
for (flag, file) in
[("--ssl-ca", &source.ssl_ca_file), ("--ssl-cert", &source.ssl_cert_file), ("--ssl-key", &source.ssl_key_file)]
{
if !file.trim().is_empty() {
args.push(format!("{flag}={}", ide_ssh::expand(file.trim()).to_string_lossy()));
}
}
if tool == DbTool::Mysql && source.read_only {
args.push("--init-command=SET SESSION TRANSACTION READ ONLY".into());
}
args
}
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
fn dbname_arg(name: &str) -> String {
@@ -396,88 +281,36 @@ fn dbname_arg(name: &str) -> String {
}
}
/// A MySQL client option file holding the password, readable by the user only; deleted on drop.
struct SecretFile(PathBuf);
impl SecretFile {
fn mysql_password(password: &str) -> IdeResult<Self> {
use std::io::Write;
let path = std::env::temp_dir().join(format!("openidea-mysql-{}.cnf", uuid::Uuid::new_v4()));
let mut options = std::fs::OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let mut file = options.open(&path)?;
let secret = SecretFile(path);
let escaped = password.replace('\\', "\\\\").replace('"', "\\\"");
writeln!(file, "[client]\npassword=\"{escaped}\"")?;
Ok(secret)
}
/// `mysqldump` / `mysql` accept it only as their first argument.
fn arg(&self) -> String {
format!("--defaults-extra-file={}", self.0.display())
}
}
impl Drop for SecretFile {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.0);
}
}
/// How a tool is started: connection arguments, then the job's, the environment, and the file
/// piped to its standard input. Keep it until the tool exits: it owns the password file.
/// How a tool is started: connection arguments, then the job's, and the environment.
pub struct Prepared {
pub args: Vec<String>,
pub env: Vec<(String, String)>,
pub input: Option<PathBuf>,
_secret: Option<SecretFile>,
}
/// The command for `job` at `executable` against `source`. The password goes in `PGPASSWORD` or
/// a MySQL option file, never in the arguments, which other users of the machine can read in the
/// process list.
pub fn prepare(job: &DbToolJob, executable: &Path, source: &DataSource, password: Option<&str>) -> IdeResult<Prepared> {
job.check()?;
let tool = job.tool();
let (mut args, mut env) = connection(tool, executable, source);
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
/// arguments, which other users of the machine can read in the process list.
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
let (mut args, mut env) = connection(job.tool(), source);
args.extend(job.args());
let mut secret = None;
match password.filter(|p| !p.is_empty()) {
Some(p) if tool.driver() == DbDriver::Mysql => {
let file = SecretFile::mysql_password(p)?;
args.insert(0, file.arg());
secret = Some(file);
}
Some(p) => env.push(("PGPASSWORD".into(), p.to_owned())),
None => {}
if let Some(p) = password.filter(|p| !p.is_empty()) {
env.push(("PGPASSWORD".into(), p.to_owned()));
}
Ok(Prepared { args, env, input: job.input().map(PathBuf::from), _secret: secret })
Prepared { args, env }
}
/// Runs `program` until it exits, passing its output in batches; `input` is piped to its standard
/// input. Returns the exit code (`None`: ended by a signal). Cancelling kills it and everything it
/// started.
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
pub async fn run(
program: &Path,
args: &[String],
env: &[(String, String)],
input: Option<&Path>,
cancel: &CancellationToken,
mut on_output: impl FnMut(Vec<ToolLine>),
) -> IdeResult<Option<i32>> {
let stdin = match input {
Some(path) => Stdio::from(
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?,
),
None => Stdio::null(),
};
let mut cmd = tokio::process::Command::new(program);
cmd.args(args)
.envs(env.iter().map(|(k, v)| (k, v)))
.stdin(stdin)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
@@ -575,7 +408,7 @@ mod tests {
#[test]
fn connects_like_the_data_source_without_prompting() {
let (args, env) = connection(DbTool::PgDump, Path::new("pg_dump"), &pg());
let (args, env) = connection(DbTool::PgDump, &pg());
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
@@ -588,8 +421,7 @@ mod tests {
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
] {
let (args, _) =
connection(DbTool::PgDump, Path::new("pg_dump"), &DataSource { database: name.into(), ..pg() });
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
assert!(args.contains(&arg.to_owned()), "{args:?}");
}
}
@@ -597,14 +429,14 @@ mod tests {
#[test]
fn default_port_and_optional_fields() {
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
let (args, _) = connection(DbTool::Psql, Path::new("psql"), &source);
let (args, _) = connection(DbTool::Psql, &source);
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
}
#[test]
fn read_only_sources_refuse_writes() {
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
let (_, env) = connection(DbTool::PgRestore, Path::new("pg_restore"), &source);
let (_, env) = connection(DbTool::PgRestore, &source);
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
}
@@ -619,77 +451,6 @@ mod tests {
}
}
#[test]
fn mysql_tools_accept_mariadb_names_only_for_themselves() {
assert!(DbTool::Mysqldump.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(DbTool::Mysql.is_program(Path::new("/opt/homebrew/opt/mysql-client/bin/mysql")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mysqldump")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(!DbTool::Mysqldump.is_program(Path::new("/usr/bin/mysqlpump")));
}
#[test]
fn mysql_connects_over_tcp_with_the_ssl_flags_of_its_client() {
let source = DataSource {
driver: DbDriver::Mysql,
host: "localhost".into(),
port: None,
user: "app".into(),
read_only: true,
..DataSource::default()
};
let (args, env) = connection(DbTool::Mysql, Path::new("/usr/bin/mysql"), &source);
assert_eq!(
args,
[
"--host=localhost",
"--port=3306",
"--user=app",
"--protocol=TCP",
"--ssl-mode=PREFERRED",
"--init-command=SET SESSION TRANSACTION READ ONLY"
]
);
assert!(env.is_empty());
let (args, _) = connection(DbTool::Mysqldump, Path::new("/usr/bin/mariadb-dump"), &source);
assert!(args.contains(&"--skip-ssl-verify-server-cert".to_owned()));
assert!(!args.iter().any(|a| a.starts_with("--ssl-mode") || a.starts_with("--init-command")));
}
#[test]
fn the_password_file_is_private_and_removed() {
let file = SecretFile::mysql_password(r#"p"a\ss"#).unwrap();
let path = file.arg().trim_start_matches("--defaults-extra-file=").to_owned();
let text = std::fs::read_to_string(&path).unwrap();
assert_eq!(text, "[client]\npassword=\"p\\\"a\\\\ss\"\n");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
}
drop(file);
assert!(!Path::new(&path).exists());
}
#[test]
fn reads_long_options_from_help() {
let help = "Usage: mysqldump [OPTIONS]\n -A, --all-databases Dump all.\n --masking-policies Dump masking\n policies (--not-an-option).\n -y, --no-tablespaces \n -f, --file=FILENAME output file\n";
assert_eq!(help_options(help), ["all-databases", "file", "masking-policies", "no-tablespaces"]);
}
#[cfg(unix)]
#[tokio::test]
async fn pipes_the_input_file() {
let file = std::env::temp_dir().join(format!("openidea-input-{}", uuid::Uuid::new_v4()));
std::fs::write(&file, "from the file\n").unwrap();
let mut lines = Vec::new();
run(Path::new("/bin/cat"), &[], &[], Some(&file), &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
std::fs::remove_file(&file).unwrap();
assert_eq!(lines, [ToolLine { stderr: false, text: "from the file".into() }]);
}
#[test]
fn tells_dumps_apart_by_their_header() {
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
@@ -700,17 +461,6 @@ mod tests {
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
}
#[test]
fn sees_a_dump_that_creates_its_own_database() {
let one = b"-- MySQL dump 10.13\n--\n-- Host: localhost Database: shop\nCREATE TABLE `items` (id int);\n";
assert!(!info_of(one).creates_database);
let several = b"-- MySQL dump 10.13\n--\n-- Current Database: `shop`\n--\n\nCREATE DATABASE /*!32312 IF NOT EXISTS*/ `shop`;\nUSE `shop`;\n";
assert!(info_of(several).creates_database);
let pg = b"--\n-- PostgreSQL database dump\n--\nSET client_encoding = 'UTF8';\nCREATE DATABASE shop WITH TEMPLATE = template0;\n\\connect shop\n";
assert_eq!(info_of(pg), DumpInfo { kind: DbDumpKind::PostgresSql, creates_database: true });
assert!(!info_of(b"CREATE DATABASE x;\n").creates_database, "only for a dump the tools wrote");
}
#[test]
fn newer_versions_sort_first() {
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
@@ -724,7 +474,6 @@ mod tests {
Path::new("/bin/sh"),
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
&[],
None,
&CancellationToken::new(),
|batch| lines.extend(batch),
)
@@ -744,25 +493,19 @@ mod tests {
tokio::time::sleep(Duration::from_millis(100)).await;
stop.cancel();
});
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], None, &cancel, |_| {}).await;
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
assert!(result.is_err());
}
/// A stand-in for `tool` that prints each argument on a line, then whether it got a password
/// from `PGPASSWORD` or a MySQL option file.
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
/// holds the expected password.
#[cfg(unix)]
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = dir.join(tool.program());
std::fs::write(
&path,
concat!(
"#!/bin/sh\n",
"for a in \"$@\"; do echo \"arg:$a\"; case \"$a\" in --defaults-extra-file=*)\n",
" grep -q '^password=' \"${a#*=}\" && echo env:set;; esac; done\n",
"[ -n \"$PGPASSWORD\" ] && echo env:set\n",
"exit 0\n",
),
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
)
.unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
@@ -798,48 +541,17 @@ mod tests {
file: file.clone(),
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
},
DbToolJob::Mysqldump {
file: file.clone(),
options: DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
},
},
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: "shop".into(), force: false } },
];
for job in jobs {
let mysql = job.tool().driver() == DbDriver::Mysql;
let source = if mysql { DataSource { driver: DbDriver::Mysql, ..pg() } } else { pg() };
let program = echo_tool(&dir, job.tool());
let prepared = prepare(&job, &program, &source, Some(SECRET)).unwrap();
let prepared = prepare(&job, &pg(), Some(SECRET));
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
assert!(!mysql || prepared.env.is_empty(), "{:?}", prepared.env);
let mut lines = Vec::new();
run(&program, &prepared.args, &prepared.env, None, &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
let database = if mysql { "shop" } else { "--dbname=shop" };
assert!(text.iter().any(|l| l.strip_prefix("arg:").is_some_and(|a| a.ends_with(database))), "{text:?}");
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password: {text:?}");
if mysql {
let file = prepared.args[0].trim_start_matches("--defaults-extra-file=").to_owned();
drop(prepared);
assert!(!Path::new(&file).exists(), "the password file outlives the run");
}
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
}
std::fs::remove_dir_all(&dir).unwrap();
}
-67
Переглянути файл
@@ -231,70 +231,3 @@ async fn servers_that_advertise_deprecate_eof_but_send_legacy_eof_packets() -> I
assert_eq!(r.rows, vec![vec![Some("a".into())], vec![Some("b".into())]]);
Ok(())
}
/// `mysqldump` into a file and `mysql` reading it back, with the data source's password.
#[tokio::test]
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
use ide_db::tools::{DbMysqlOptions, DbMysqldumpOptions, DbTool, DbToolJob, find_installs};
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp, "").await else { return Ok(()) };
let (Some(dump), Some(client)) =
(find_installs(DbTool::Mysqldump).into_iter().next(), find_installs(DbTool::Mysql).into_iter().next())
else {
return Ok(());
};
let c = CancellationToken::new();
for stmt in [
"DROP DATABASE IF EXISTS oi_dump_src",
"DROP DATABASE IF EXISTS oi_dump_dst",
"CREATE DATABASE oi_dump_src",
"CREATE DATABASE oi_dump_dst",
"CREATE TABLE oi_dump_src.items (id INT PRIMARY KEY, tag VARCHAR(20))",
"INSERT INTO oi_dump_src.items VALUES (1, 'dumped')",
] {
db.execute("m", stmt, 1, &c).await?;
}
let file = tmp.path().join("src.sql").to_string_lossy().into_owned();
let run = |executable: String, job: DbToolJob| {
let db = &db;
async move {
let mut lines = Vec::new();
let code =
db.run_tool("m", executable.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
IdeResult::Ok(())
}
};
let masking = ide_db::tools::options_of(dump.path.as_ref())?.iter().any(|o| o == "masking-policies");
let options = DbMysqldumpOptions {
databases: vec!["oi_dump_src".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: masking.then_some(false),
};
run(dump.path.clone(), DbToolJob::Mysqldump { file: file.clone(), options: options.clone() }).await?;
assert!(!ide_db::tools::dump_info(file.as_ref())?.creates_database, "one database: restored into a chosen one");
let both = tmp.path().join("both.sql").to_string_lossy().into_owned();
let two = DbMysqldumpOptions { databases: vec!["oi_dump_src".into(), "oi_dump_dst".into()], ..options };
run(dump.path, DbToolJob::Mysqldump { file: both.clone(), options: two }).await?;
assert!(ide_db::tools::dump_info(both.as_ref())?.creates_database, "several databases: created by the dump");
let restore = DbMysqlOptions { database: "oi_dump_dst".into(), force: false };
run(client.path, DbToolJob::Mysql { file, options: restore }).await?;
let r = db.execute("m", "SELECT tag FROM oi_dump_dst.items", 1, &c).await?;
assert_eq!(r.rows[0][0].as_deref(), Some("dumped"));
for stmt in ["DROP DATABASE oi_dump_src", "DROP DATABASE oi_dump_dst"] {
db.execute("m", stmt, 1, &c).await?;
}
Ok(())
}
-1
Переглянути файл
@@ -282,7 +282,6 @@ async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
let restore = DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
+1 -1
Переглянути файл
@@ -142,7 +142,7 @@ pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
}
const FMT: &str = "{{json .}}";
let (containers, images, volumes, networks) = std::thread::scope(|s| {
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", PS_FORMAT], QUICK));
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", FMT], QUICK));
let i = s.spawn(|| run(ep, &["image", "ls", "--no-trunc", "--format", FMT], QUICK));
let v = s.spawn(|| run(ep, &["volume", "ls", "--format", FMT], QUICK));
let n = s.spawn(|| run(ep, &["network", "ls", "--no-trunc", "--format", FMT], QUICK));
+1 -11
Переглянути файл
@@ -226,16 +226,6 @@ fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> +
})
}
/// The `docker ps --format` template: only the fields [`RawContainer`] reads. `{{json .}}`
/// would also include `Size`, which makes the daemon compute every container's writable
/// layer and can take tens of seconds.
pub const PS_FORMAT: &str = concat!(
r#"{"ID":{{json .ID}},"Names":{{json .Names}},"Image":{{json .Image}},"#,
r#""Command":{{json .Command}},"State":{{json .State}},"Status":{{json .Status}},"#,
r#""Ports":{{json .Ports}},"CreatedAt":{{json .CreatedAt}},"Labels":{{json .Labels}},"#,
r#""Mounts":{{json .Mounts}},"Networks":{{json .Networks}}}"#,
);
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct RawContainer {
@@ -257,7 +247,7 @@ fn split_csv(raw: &str) -> Vec<String> {
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
}
/// `docker ps -a --no-trunc --format` [`PS_FORMAT`] (or `'{{json .}}'`).
/// `docker ps -a --no-trunc --format '{{json .}}'`.
pub fn parse_containers(text: &str) -> Vec<DockerContainer> {
let mut out: Vec<DockerContainer> = lines::<RawContainer>(text)
.map(|r| {
+2 -23
Переглянути файл
@@ -1,8 +1,8 @@
//! Parsing of recorded `docker … --format '{{json .}}'` output.
use ide_docker::{
PS_FORMAT, parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images,
parse_networks, parse_volumes,
parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images, parse_networks,
parse_volumes,
};
const PS: &str = include_str!("fixtures/ps.jsonl");
@@ -10,27 +10,6 @@ const IMAGES: &str = include_str!("fixtures/images.jsonl");
const VOLUMES: &str = include_str!("fixtures/volumes.jsonl");
const NETWORKS: &str = include_str!("fixtures/networks.jsonl");
/// Fills `{{json .Field}}` placeholders of a `--format` template from a `{{json .}}` line.
fn render(template: &str, line: &str) -> String {
let fields: serde_json::Map<String, serde_json::Value> = serde_json::from_str(line).unwrap();
let mut out = template.to_owned();
while let Some(start) = out.find("{{json .") {
let end = start + out[start..].find("}}").unwrap() + 2;
let key = &out[start + "{{json .".len()..end - 2];
let value = fields.get(key).unwrap_or_else(|| panic!("fixture lacks {key}"));
out.replace_range(start..end, &value.to_string());
}
out
}
#[test]
fn ps_format_carries_everything_the_parser_reads_but_size() {
assert!(!PS_FORMAT.contains("Size"), "Size makes the daemon compute container sizes");
let rendered: Vec<String> = PS.lines().filter(|l| l.starts_with('{')).map(|l| render(PS_FORMAT, l)).collect();
assert_eq!(rendered.len(), 2);
assert_eq!(parse_containers(&rendered.join("\n")), parse_containers(PS));
}
#[test]
fn containers_with_compose_labels() {
let c = parse_containers(PS);
+1 -12
Переглянути файл
@@ -38,8 +38,6 @@ pub enum Capability {
InputEvents,
/// The system clipboard, from the plugin's web views.
Clipboard,
/// Read the clipboard from commands and view actions the user ran (API 1.11).
ClipboardRead,
/// HTTPS (and loopback HTTP) to one host (`*.example.com` matches subdomains).
Net(String),
/// Ask the user when the first request goes to an HTTPS (or loopback) host
@@ -90,8 +88,7 @@ impl Capability {
| Self::NetHttp(_)
| Self::Secrets
| Self::InputEvents
| Self::Clipboard
| Self::ClipboardRead => Risk::Medium,
| Self::Clipboard => Risk::Medium,
// A trusted project's own files name the programs the IDE starts (its settings, its
// build scripts), so writing them is running code.
Self::ProjectWrite
@@ -130,7 +127,6 @@ impl Capability {
Self::Clipboard => {
"Copy to the clipboard from its commands, and read and write it from its web views".into()
}
Self::ClipboardRead => "Read the clipboard's text and images when you run one of its commands".into(),
Self::Net(host) => format!("Connect to {host} (from the machine the project is on)"),
Self::NetAsk => {
"Ask to connect to a host that is not on the list the first time it tries; you allow or refuse each host, and can revoke the allowed ones"
@@ -266,7 +262,6 @@ impl fmt::Display for Capability {
Self::Events => f.write_str("events"),
Self::InputEvents => f.write_str("events.input"),
Self::Clipboard => f.write_str("clipboard"),
Self::ClipboardRead => f.write_str("clipboard.read"),
Self::Net(h) => write!(f, "net:{h}"),
Self::NetAsk => f.write_str("net:ask"),
Self::NetHttp(h) => write!(f, "net.http:{h}"),
@@ -353,7 +348,6 @@ impl FromStr for Capability {
"events" => Self::Events,
"events.input" => Self::InputEvents,
"clipboard" => Self::Clipboard,
"clipboard.read" => Self::ClipboardRead,
"java.agent" => Self::JavaAgent,
_ => return Err(format!("unknown capability {s:?}")),
})
@@ -404,7 +398,6 @@ mod tests {
"project.write",
"vcs.write",
"build.read",
"clipboard.read",
"storage",
"secrets",
"events",
@@ -446,10 +439,6 @@ mod tests {
assert_eq!(Capability::InputEvents.risk(), Risk::Medium);
assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
// Reading is its own grant: neither clipboard capability covers the other.
assert_eq!(Capability::ClipboardRead.risk(), Risk::Medium);
assert!(!Capability::Clipboard.covers(&Capability::ClipboardRead));
assert!(!Capability::ClipboardRead.covers(&Capability::Clipboard));
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
+1 -12
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.11.0";
pub const ENGINE_VERSION: &str = "1.10.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -363,9 +363,6 @@ impl Manifest {
if matches!(cap, Capability::BuildRead) {
self.needs_api(&format!("capability `{cap}`"), 10)?;
}
if matches!(cap, Capability::ClipboardRead) {
self.needs_api(&format!("capability `{cap}`"), 11)?;
}
if matches!(cap, Capability::JavaAgent) {
return Err(
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
@@ -749,14 +746,6 @@ required = [\"lsp:phoxite\"]
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
}
#[test]
fn the_clipboard_read_capability_needs_api_1_11() {
let caps = "[capabilities]\noptional = [\"clipboard.read\"]\n";
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("new in plugin API 1.11"));
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.11"))).unwrap();
assert_eq!(m.capabilities.optional, [Capability::ClipboardRead]);
}
#[test]
fn java_agent_capability_is_not_declared() {
for list in ["required", "optional"] {
-426
Переглянути файл
@@ -1,426 +0,0 @@
//! The project's direnv environment: when the project root has an `.envrc`, `direnv export
//! json` runs there and every child started in the project gets what it exports
//! ([`ide_core::project_env`]): terminals, runs, language servers (which wait for it), build
//! tools and debuggers, locally and on a remote host alike. An `.envrc` with `use flake`
//! loads a Nix flake's devshell this way.
//!
//! `.envrc` is project code: it runs in trusted projects only, and only once the user
//! allowed it with `direnv allow`, which the IDE never does for them.
use ide_core::event::DirenvStatus;
use ide_core::{CancellationToken, IdeEvent, SharedSink, TaskId};
use std::collections::BTreeMap;
use std::ffi::OsString;
use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::mpsc::RecvTimeoutError;
use std::time::{Duration, Instant};
pub(crate) const ENVRC: &str = ".envrc";
/// Files in the project root whose change offers a reload: the `.envrc` and the flake
/// `use flake` evaluates.
const WATCHED: [&str; 3] = [ENVRC, "flake.nix", "flake.lock"];
/// A cold `use flake` builds or downloads the devshell: minutes, not seconds.
pub(crate) const TIMEOUT: Duration = Duration::from_secs(10 * 60);
/// Output lines kept for a failure's notification.
const TAIL_LINES: usize = 12;
pub(crate) type Changes = Vec<(OsString, Option<OsString>)>;
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Failure {
/// The user hasn't allowed this `.envrc` (`direnv allow`).
Blocked,
Failed(String),
Cancelled,
}
pub(crate) fn has_envrc(root: &Path) -> bool {
root.join(ENVRC).is_file()
}
/// `direnv` on the IDE's search path.
pub(crate) fn program() -> Option<PathBuf> {
ide_core::process::find_executable("direnv", &ide_core::tool_path::search_path())
}
/// The watched file among `paths` (changed or removed below `root`), when the project has an
/// `.envrc` or just lost it: what a reload would pick up.
pub(crate) fn reload_offer<'a>(root: &Path, paths: impl IntoIterator<Item = &'a PathBuf>) -> Option<String> {
let file = paths
.into_iter()
.filter(|p| p.parent() == Some(root))
.filter_map(|p| p.file_name()?.to_str())
.find(|name| WATCHED.contains(name))?;
(file == ENVRC || has_envrc(root)).then(|| file.to_owned())
}
/// Runs `program export json` in `root` from the environment children outside any project
/// get (not the project's last one: a reload must not see its own result), reporting
/// direnv's progress lines to `on_line`. Gives up after `timeout` or once `cancel` fires,
/// stopping what direnv started (`nix`) too.
pub(crate) fn export(
program: &Path,
root: &Path,
timeout: Duration,
cancel: &CancellationToken,
on_line: &dyn Fn(&str),
) -> Result<Changes, Failure> {
let mut cmd = Command::new(program);
ide_core::process::prepare(ide_core::process::own_group(&mut cmd));
let mut child = cmd
.args(["export", "json"])
.current_dir(root)
.env_clear()
.envs(ide_core::process::host_vars())
.envs(ide_core::process::shell_env())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| Failure::Failed(format!("cannot start {}: {e}", program.display())))?;
let mut stdout = child.stdout.take().expect("piped");
let out = std::thread::spawn(move || {
let mut buf = Vec::new();
stdout.read_to_end(&mut buf).map(|_| buf)
});
let (tx, rx) = std::sync::mpsc::channel::<String>();
let stderr = child.stderr.take().expect("piped");
std::thread::spawn(move || {
for line in BufReader::new(stderr).split(b'\n').map_while(Result::ok) {
let line = ide_core::output_encoding::decode_tool_output(&line).trim_end_matches('\r').to_owned();
if tx.send(line).is_err() {
break;
}
}
});
let deadline = Instant::now() + timeout;
let mut tail: Vec<String> = Vec::new();
let mut keep = |line: String| {
on_line(&line);
tail.push(line);
let excess = tail.len().saturating_sub(TAIL_LINES);
tail.drain(..excess);
};
loop {
if cancel.is_cancelled() {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Cancelled);
}
if Instant::now() > deadline {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Failed(format!(
"direnv did not finish within {} minutes.\n\n{}",
timeout.as_secs() / 60,
tail.join("\n")
)));
}
match rx.recv_timeout(Duration::from_millis(50)) {
Ok(line) => keep(line),
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => break,
}
}
let status = child.wait().map_err(|e| Failure::Failed(e.to_string()))?;
let stdout = out.join().ok().and_then(Result::ok).unwrap_or_default();
if tail.iter().any(|l| l.contains("is blocked") || l.contains("is not allowed")) {
return Err(Failure::Blocked);
}
if !status.success() {
let tail = tail.join("\n");
return Err(Failure::Failed(if tail.is_empty() { format!("direnv exited with {status}") } else { tail }));
}
parse(&stdout).map_err(Failure::Failed)
}
/// `direnv export json`'s output: the variables to set, `null` for those to unset; nothing
/// when there is nothing to change.
fn parse(stdout: &[u8]) -> Result<Changes, String> {
if stdout.iter().all(u8::is_ascii_whitespace) {
return Ok(Changes::new());
}
let vars: BTreeMap<String, Option<String>> =
serde_json::from_slice(stdout).map_err(|e| format!("unexpected output from direnv: {e}"))?;
Ok(vars.into_iter().map(|(k, v)| (k.into(), v.map(Into::into))).collect())
}
/// Loads `root`'s environment with `program` (`None`: direnv isn't installed) into
/// [`ide_core::project_env`], as a cancellable background task; what went wrong is a
/// [`IdeEvent::Direnv`]. `current` says whether this load still owns `root` (not closed or
/// superseded by a newer one meanwhile) and is checked again before anything is applied.
pub(crate) fn load(
root: &Path,
program: Option<&Path>,
sink: &SharedSink,
cancel: &CancellationToken,
timeout: Duration,
hint_missing: bool,
current: &dyn Fn(&dyn Fn()),
) {
let report = |status: DirenvStatus| sink.emit(IdeEvent::Direnv { root: root.to_path_buf().into(), status });
let Some(program) = program else {
current(&|| ide_core::project_env::settle(root));
if hint_missing {
report(DirenvStatus::NotInstalled);
}
return;
};
let task = TaskId::next();
let _cancel_handle = ide_core::task::on_cancel(task, {
let cancel = cancel.clone();
move || cancel.cancel()
});
let progress = |message: Option<String>, done: bool| {
sink.emit(IdeEvent::Task {
id: task,
title: "Loading the direnv environment".into(),
message,
fraction: None,
done,
cancellable: !done,
});
};
progress(Some(format!("{} export json", program.display())), false);
let result = export(program, root, timeout, cancel, &|line| progress(Some(line.to_owned()), false));
progress(None, true);
match result {
Ok(changes) => {
tracing::info!("direnv: {} variables for {}", changes.len(), root.display());
current(&|| ide_core::project_env::set(root, changes.clone()));
}
Err(Failure::Blocked) => {
// As in a shell: a blocked `.envrc` isn't loaded.
current(&|| ide_core::project_env::set(root, Changes::new()));
report(DirenvStatus::Blocked);
}
Err(Failure::Failed(message)) => {
tracing::warn!("direnv in {}: {message}", root.display());
current(&|| ide_core::project_env::settle(root));
report(DirenvStatus::Failed { message });
}
// Closed or superseded (that one settles), or stopped from the task list.
Err(Failure::Cancelled) => current(&|| ide_core::project_env::settle(root)),
}
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use ide_core::EventSink;
use parking_lot::Mutex;
use std::os::unix::fs::PermissionsExt;
use std::sync::Arc;
/// A stand-in `direnv`: checks its arguments, then prints `stderr` and `out.json` of the
/// folder it runs in and exits with `code`, or blocks like direnv on an `.envrc` not allowed.
fn fake_direnv(dir: &Path) -> PathBuf {
let program = dir.join("direnv");
std::fs::write(
&program,
r#"#!/bin/sh
[ "$1 $2" = "export json" ] || { echo "direnv: unexpected arguments $*" >&2; exit 2; }
echo "direnv: loading $PWD/.envrc" >&2
[ -f slow ] && sleep 30
[ -f blocked ] && { echo "direnv: error $PWD/.envrc is blocked. Run \`direnv allow\` to approve its content" >&2; exit 1; }
[ -f stderr ] && cat stderr >&2
[ -f out.json ] && cat out.json
echo "direnv: export +NIX_DEV" >&2
exit "$(cat code 2>/dev/null || echo 0)"
"#,
)
.unwrap();
std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o755)).unwrap();
program
}
fn project() -> (tempfile::TempDir, PathBuf, PathBuf) {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
std::fs::write(root.join(ENVRC), "use flake\n").unwrap();
let program = fake_direnv(tmp.path());
(tmp, root, program)
}
fn run(program: &Path, root: &Path) -> (Result<Changes, Failure>, Vec<String>) {
let lines = Mutex::new(Vec::new());
let result = export(program, root, Duration::from_secs(20), &CancellationToken::new(), &|l| {
lines.lock().push(l.to_owned())
});
(result, lines.into_inner())
}
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn exported_variables_are_set_and_unset() {
let (_tmp, root, program) = project();
std::fs::write(
root.join("out.json"),
r#"{"PATH":"/nix/store/abc-devshell/bin:/usr/bin","IN_NIX_SHELL":"impure","OLD":null}"#,
)
.unwrap();
let (result, lines) = run(&program, &root);
assert_eq!(
result.unwrap(),
[
change("IN_NIX_SHELL", Some("impure")),
change("OLD", None),
change("PATH", Some("/nix/store/abc-devshell/bin:/usr/bin")),
]
);
assert_eq!(lines, [format!("direnv: loading {}/.envrc", root.display()), "direnv: export +NIX_DEV".into()]);
}
#[test]
fn nothing_to_export_changes_nothing() {
let (_tmp, root, program) = project();
assert_eq!(run(&program, &root).0, Ok(Changes::new()));
}
#[test]
fn a_blocked_envrc_is_reported_as_such() {
let (_tmp, root, program) = project();
std::fs::write(root.join("blocked"), "").unwrap();
assert_eq!(run(&program, &root).0, Err(Failure::Blocked));
}
#[test]
fn a_failure_reports_the_end_of_the_output() {
let (_tmp, root, program) = project();
std::fs::write(root.join("stderr"), "error: flake 'path:/p' does not provide attribute 'devShells'\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.contains("does not provide attribute 'devShells'"), "{message}");
std::fs::remove_file(root.join("code")).unwrap();
std::fs::write(root.join("out.json"), "not json").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.starts_with("unexpected output from direnv"), "{message}");
}
#[test]
fn a_slow_direnv_times_out_or_is_cancelled() {
let (_tmp, root, program) = project();
std::fs::write(root.join("slow"), "").unwrap();
let started = Instant::now();
let result = export(&program, &root, Duration::from_secs(2), &CancellationToken::new(), &|_| {});
let Err(Failure::Failed(message)) = result else { panic!("a timeout") };
assert!(message.starts_with("direnv did not finish within"), "{message}");
assert!(message.contains("direnv: loading"), "{message}");
let cancel = CancellationToken::new();
let c = cancel.clone();
std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
assert_eq!(export(&program, &root, Duration::from_secs(60), &cancel, &|_| {}), Err(Failure::Cancelled));
assert!(started.elapsed() < Duration::from_secs(20));
}
#[test]
fn missing_program_is_a_start_failure() {
let (_tmp, root, _) = project();
let Err(Failure::Failed(message)) = run(Path::new("/openidea-no-such/direnv"), &root).0 else { panic!() };
assert!(message.starts_with("cannot start"), "{message}");
}
#[derive(Default)]
struct Events(Mutex<Vec<IdeEvent>>);
impl EventSink for Events {
fn emit(&self, e: IdeEvent) {
self.0.lock().push(e);
}
}
fn statuses(events: &Events) -> Vec<DirenvStatus> {
events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Direnv { status, .. } => Some(status.clone()),
_ => None,
})
.collect()
}
fn load_with(root: &Path, program: Option<&Path>, hint: bool) -> Arc<Events> {
let events = Arc::new(Events::default());
let sink: SharedSink = events.clone();
ide_core::project_env::begin_loading(root);
load(root, program, &sink, &CancellationToken::new(), Duration::from_secs(20), hint, &|apply| apply());
events
}
#[test]
fn children_in_the_project_get_what_direnv_exported() {
let (_tmp, root, program) = project();
std::fs::write(root.join("out.json"), r#"{"OPENIDEA_TEST_DEVSHELL":"1"}"#).unwrap();
let events = load_with(&root, Some(&program), true);
assert!(statuses(&events).is_empty());
assert!(!ide_core::project_env::is_loading(&root));
let mut cmd = Command::new("true");
cmd.current_dir(root.join("src"));
ide_core::process::host_env(&mut cmd);
assert!(cmd.get_envs().any(|(k, v)| k == "OPENIDEA_TEST_DEVSHELL" && v == Some("1".as_ref())));
// A task shows the progress, and ends.
let tasks: Vec<_> = events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Task { message, done, .. } => Some((message.clone(), *done)),
_ => None,
})
.collect();
assert!(tasks.iter().any(|(m, _)| m.as_deref() == Some("direnv: export +NIX_DEV")), "{tasks:?}");
assert_eq!(tasks.last(), Some(&(None, true)));
// Blocked after an edit: the environment goes, as in a shell.
std::fs::write(root.join("blocked"), "").unwrap();
let events = load_with(&root, Some(&program), true);
assert_eq!(statuses(&events), [DirenvStatus::Blocked]);
assert!(ide_core::project_env::for_dir(&root).is_empty());
// A failure keeps the last environment and says why.
std::fs::remove_file(root.join("blocked")).unwrap();
load_with(&root, Some(&program), true);
std::fs::write(root.join("stderr"), "error: syntax error in flake.nix\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let events = load_with(&root, Some(&program), true);
let [DirenvStatus::Failed { message }] = &statuses(&events)[..] else { panic!("{:?}", statuses(&events)) };
assert!(message.contains("syntax error in flake.nix"), "{message}");
assert!(!ide_core::project_env::for_dir(&root).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn direnv_not_installed_is_hinted_once_and_does_not_block() {
let (_tmp, root, _) = project();
let events = load_with(&root, None, true);
assert_eq!(statuses(&events), [DirenvStatus::NotInstalled]);
assert!(!ide_core::project_env::is_loading(&root), "language servers start anyway");
assert!(statuses(&load_with(&root, None, false)).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn changes_to_the_envrc_or_flake_offer_a_reload() {
let (_tmp, root, _) = project();
let paths = |names: &[&str]| names.iter().map(|n| root.join(n)).collect::<Vec<_>>();
assert_eq!(reload_offer(&root, &paths(&["src/main.rs", "flake.lock"])), Some("flake.lock".into()));
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()));
assert_eq!(reload_offer(&root, &paths(&["sub/flake.nix", "src/main.rs"])), None, "the project root's only");
std::fs::remove_file(root.join(ENVRC)).unwrap();
assert_eq!(reload_offer(&root, &paths(&["flake.nix"])), None, "no .envrc: nothing loads the flake");
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()), "removed: reload unloads");
}
}
+11 -92
Переглянути файл
@@ -1,11 +1,9 @@
//! The environment child processes get beyond this process's own: the login shell's as
//! re-read by Reload Environment, (remote server) the project's `devcontainer.json`
//! `remoteEnv`, plus its `postStartCommand` once per server start, and each trusted
//! project's direnv `.envrc` ([`crate::direnv`]).
//! re-read by Reload Environment, and (remote server) the project's
//! `devcontainer.json` `remoteEnv`, plus its `postStartCommand` once per server start.
//!
//! The first two reach every child through `ide_core::process::set_env_overlay`, a project's
//! direnv environment the children started inside it (`ide_core::project_env`): terminals,
//! runs, language servers, debug adapters, build tools and git all spawn through
//! Both reach every child through `ide_core::process::set_env_overlay`: terminals, runs,
//! language servers, debug adapters, build tools and git all spawn through
//! `ide_core::process::prepare` / `host_env`.
use ide_core::event::NotifyLevel;
@@ -20,7 +18,6 @@ use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::Duration;
type Changes = Vec<(OsString, Option<OsString>)>;
@@ -54,87 +51,18 @@ struct State {
post_commands: std::collections::HashMap<PathBuf, CancellationToken>,
}
/// Project roots whose direnv environment is loaded or loading, with the load that owns
/// each (a generation) and what stops it.
type DirenvLoads = Arc<Mutex<std::collections::HashMap<PathBuf, (u64, CancellationToken)>>>;
pub struct Environment {
/// Whether the open project's `devcontainer.json` applies (the remote server: one project per process).
project_env: bool,
data_dir: PathBuf,
state: Mutex<State>,
/// Stops running `postStartCommand`s and direnv loads when the host shuts down.
/// Stops running `postStartCommand`s when the host shuts down.
cancel: CancellationToken,
direnv: DirenvLoads,
/// "direnv is not installed" is said once per process.
direnv_hinted: AtomicBool,
}
impl Environment {
pub(crate) fn new(project_env: bool, data_dir: PathBuf) -> Self {
Self {
project_env,
data_dir,
state: Mutex::default(),
cancel: CancellationToken::new(),
direnv: DirenvLoads::default(),
direnv_hinted: AtomicBool::new(false),
}
}
/// A trusted project at `root` opened or became trusted: loads its direnv environment in
/// the background, unless another window of it already did. Its language servers wait.
pub(crate) fn direnv_opened(&self, root: &Path, sink: &SharedSink) {
if !self.direnv.lock().contains_key(root) {
self.load_direnv(root, sink, true);
}
}
/// The project at `root` closed in its last window, or is no longer trusted.
pub(crate) fn direnv_closed(&self, root: &Path) {
if let Some((_, cancel)) = self.direnv.lock().remove(root) {
cancel.cancel();
}
ide_core::project_env::remove(root);
}
/// (Re)loads `root`'s direnv environment, replacing a load still running; on this thread
/// unless `background`. Without an `.envrc` the project has none.
fn load_direnv(&self, root: &Path, sink: &SharedSink, background: bool) {
static GENERATION: AtomicU64 = AtomicU64::new(0);
let generation = GENERATION.fetch_add(1, Ordering::Relaxed);
let cancel = self.cancel.child_token();
{
let mut loads = self.direnv.lock();
if let Some((_, previous)) = loads.insert(root.to_path_buf(), (generation, cancel.clone())) {
previous.cancel();
}
if !crate::direnv::has_envrc(root) {
ide_core::project_env::remove(root);
return;
}
// Before this returns: a language server starting next waits for it.
ide_core::project_env::begin_loading(root);
}
let program = crate::direnv::program();
let hint = program.is_none() && !self.direnv_hinted.swap(true, Ordering::AcqRel);
let (loads, dir, sink) = (self.direnv.clone(), root.to_path_buf(), sink.clone());
let run = move || {
let current = |apply: &dyn Fn()| {
let loads = loads.lock();
if loads.get(&dir).is_some_and(|(g, _)| *g == generation) {
apply();
}
};
crate::direnv::load(&dir, program.as_deref(), &sink, &cancel, crate::direnv::TIMEOUT, hint, &current);
};
if !background {
run();
} else if let Err(e) = std::thread::Builder::new().name("openidea-direnv".into()).spawn(run) {
tracing::warn!("direnv: {e}");
// Language servers must not wait for a load that never runs.
ide_core::project_env::settle(root);
}
Self { project_env, data_dir, state: Mutex::default(), cancel: CancellationToken::new() }
}
pub(crate) fn shutdown(&self) {
@@ -190,17 +118,11 @@ impl Environment {
ide_core::process::set_env_overlay(merge(&state.login, &state.project));
}
/// Reload Environment: reads the login shell again, re-applies the project's `remoteEnv`
/// and loads its direnv environment again (`root`, a trusted project). Blocking (it runs
/// the shell and direnv); children already running keep their environment.
/// Reload Environment: reads the login shell again and re-applies the project's
/// `remoteEnv` (`root`). Blocking (it runs the shell); children already running keep
/// their environment.
pub fn reload(&self, root: Option<&Path>, sink: &SharedSink) -> IdeResult<EnvReloaded> {
let vars = || -> Vec<_> {
match root {
Some(root) => ide_core::process::host_vars_in(root).collect(),
None => ide_core::process::host_vars().collect(),
}
};
let before = vars();
let before: Vec<_> = ide_core::process::host_vars().collect();
let fresh = crate::shell_env::read_login_env_now().map_err(IdeError::unavailable)?;
let shell_read = fresh.is_some();
if let Some(fresh) = fresh {
@@ -224,10 +146,7 @@ impl Environment {
None
}
};
if let Some(root) = root {
self.load_direnv(root, sink, false);
}
let after = vars();
let after: Vec<_> = ide_core::process::host_vars().collect();
Ok(EnvReloaded { changed: changed_names(&before, &after), devcontainer, shell_read })
}
-4
Переглянути файл
@@ -7,7 +7,6 @@ pub mod agent_secrets;
pub mod catalogue;
pub mod data_dirs;
pub mod diagnostics_store;
mod direnv;
pub mod environment;
mod formatter;
mod java_runtime;
@@ -319,9 +318,6 @@ impl Host {
}
if !project.light {
self.environment.project_closed();
if self.windows_for_root(&project.root).is_empty() {
self.environment.direnv_closed(&project.root);
}
}
if let Some(bridge) = &project.kotlin_bridge {
bridge.stop();
-1
Переглянути файл
@@ -40,7 +40,6 @@ fn tools() -> Vec<tool::Tool> {
tools.push(check::check_files());
tools.push(symbols::get_symbol_info());
tools.push(symbols::find_references());
tools.push(symbols::get_call_hierarchy());
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
+1 -1
Переглянути файл
@@ -280,7 +280,7 @@ fn context(call: &Call) -> IdeResult<(u32, u32)> {
/// `line`, or when longer than [`MAX_LINE_TEXT`] UTF-16 units, the part from [`SNIPPET_AROUND`]
/// units before 0-based UTF-16 column `start` to as many after `end`, with `…` where it was cut.
pub(super) fn snippet(line: &str, start: usize, end: usize) -> String {
fn snippet(line: &str, start: usize, end: usize) -> String {
let units: usize = line.chars().map(char::len_utf16).sum();
if units <= MAX_LINE_TEXT {
return line.to_owned();
+22 -422
Переглянути файл
@@ -1,13 +1,10 @@
//! Quick Documentation through the project's language services.
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::error::ErrorKind;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Pos, Range, RequestId, SymbolKind};
use ide_lsp::types::{CallHierarchy, GotoKind, HierarchyDirection, HierarchyItem, ReferencesIncomplete};
use ide_core::{IdeError, IdeResult, Pos, Range};
use ide_lsp::types::GotoKind;
use serde::Serialize;
use serde_json::json;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Duration;
use std::path::Path;
pub fn get_symbol_info() -> Tool {
Tool::new("get_symbol_info", "Retrieves information about the symbol at the specified position in the specified file.
@@ -215,10 +212,26 @@ pub fn find_references() -> Tool {
let path = call.resolve_readable(&call.str("filePath")?).await?;
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
let dir = super::scope::Scope::of(&call)?;
let opened = open_at(&call, path).await?;
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
let (doc, text) = call.host.blocking(move || {
let text = project.text_of(&path)?;
let doc = project.documents.open(&path)?;
Ok((doc.id, text))
}).await?;
struct Close(std::sync::Arc<crate::Project>, ide_core::DocId);
impl Drop for Close { fn drop(&mut self) { self.0.documents.close(self.1); } }
let _close = Close(call.project.clone(), doc);
let pos = mcp_position(&text, line, column)?;
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, opened.doc, opened.pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
let result = race(&call, request, work, "references timed out; retry when analysis finishes").await?;
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, doc, pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
tokio::pin!(work);
let result = tokio::select! {
result = &mut work => result?,
_ = call.cancel.cancelled() => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::cancelled()); }
_ = tokio::time::sleep(std::time::Duration::from_secs(60)) => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::unavailable("references timed out; retry when analysis finishes")); }
};
let mut value = serde_json::to_value(&result).map_err(|e| IdeError::internal(e.to_string()))?;
// Convert every Location range at this boundary, including declarations.
fn positions(value: &mut serde_json::Value) {
@@ -261,266 +274,6 @@ pub fn find_references() -> Tool {
/// References `find_references` lists by default.
const REFERENCES_LIMIT: usize = 100;
/// A document a tool opened for the language services and the position it asked about;
/// dropping it closes the document.
#[must_use]
struct Opened {
project: Arc<crate::Project>,
doc: DocId,
pos: Pos,
}
impl Drop for Opened {
fn drop(&mut self) {
self.project.documents.close(self.doc);
}
}
/// Opens `path` at the call's 1-based `line` and `column`.
async fn open_at(call: &Call, path: PathBuf) -> IdeResult<Opened> {
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
let (doc, text) = call
.host
.blocking(move || {
let text = project.text_of(&path)?;
let doc = project.documents.open(&path)?;
Ok((doc.id, text))
})
.await?;
let mut opened = Opened { project: call.project.clone(), doc, pos: Pos::default() };
opened.pos = mcp_position(&text, line, column)?;
Ok(opened)
}
/// How long a tool waits for a language service request.
const LANGUAGE_SERVICE_TIMEOUT: Duration = Duration::from_secs(60);
/// `work`, the language service `request`, until it ends; when the client cancels or
/// [`LANGUAGE_SERVICE_TIMEOUT`] passes first, the request is cancelled and `work` runs to its end.
async fn race<T>(
call: &Call,
request: RequestId,
work: impl Future<Output = IdeResult<T>>,
timed_out: &'static str,
) -> IdeResult<T> {
tokio::pin!(work);
tokio::select! {
result = &mut work => result,
_ = call.cancel.cancelled() => {
call.host.cancel_request(request);
let _ = work.await;
Err(IdeError::cancelled())
}
_ = tokio::time::sleep(LANGUAGE_SERVICE_TIMEOUT) => {
call.host.cancel_request(request);
let _ = work.await;
Err(IdeError::unavailable(timed_out))
}
}
}
pub fn get_call_hierarchy() -> Tool {
Tool::new(
"get_call_hierarchy",
"Callers (incoming) or callees (outgoing) of the function or method at the position, from \
the language server's call hierarchy. A position inside a function body means that function. \
One level per call: to go deeper, call again with an item's filePath, startLine and startColumn \
(items in libraries show a URI as filePath and cannot be expanded). \
Positions are 1-based UTF-16. `root` is the symbol the hierarchy is for; each item's callSites \
are where the call happens. Reports incomplete results when analysis is still running.",
call_hierarchy,
)
.param(Param::required("filePath", ParamType::String, "Path relative to the project root"))
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("direction", ParamType::String, "incoming (callers, default) or outgoing (callees)"))
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
/// Items `get_call_hierarchy` lists by default.
const CALLS_LIMIT: usize = 100;
/// Call sites shown per item; `callSiteCount` gives the total when there are more.
const MAX_CALL_SITES: usize = 20;
const CALLS_TIMED_OUT: &str = "call hierarchy timed out; retry when analysis finishes";
async fn call_hierarchy(call: Call) -> IdeResult<Output> {
let direction = match call.opt_str("direction")?.as_deref() {
None | Some("incoming") => HierarchyDirection::Incoming,
Some("outgoing") => HierarchyDirection::Outgoing,
Some(_) => return Err(IdeError::invalid("direction must be incoming or outgoing")),
};
let page = super::page::Page::of(&call, CALLS_LIMIT)?;
let scope = super::scope::Scope::of(&call)?;
let path = call.resolve_readable(&call.str("filePath")?).await?;
let opened = open_at(&call, path).await?;
let hierarchy_at = |pos| {
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_call_hierarchy(&call.host, &call.window, request, opened.doc, pos, direction);
race(&call, request, work, CALLS_TIMED_OUT)
};
let mut found = match hierarchy_at(opened.pos).await {
// IDEA: inside a function body the hierarchy is the enclosing function's.
Err(e) if e.kind == ErrorKind::NotFound => {
let outline = tokio::select! {
outline = crate::ops::doc::doc_outline(&call.host, &call.window, opened.doc) => outline?,
_ = call.cancel.cancelled() => return Err(IdeError::cancelled()),
};
let at = enclosing_callable(&outline, opened.pos).map(|f| f.selection_range.start);
let Some(at) = at.filter(|at| *at != opened.pos) else {
let Pos { line, col } = opened.pos;
return Err(IdeError::not_found(format!("no function or method at {}:{}", line + 1, col + 1)));
};
hierarchy_at(at).await?
}
result => result?,
};
if scope.dir().is_some() {
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
}
let incomplete = found.incomplete;
let (mut root, items) = call_items(found, |p| call.display(p));
let mut out = serde_json::Map::new();
let mut items = page.take(items, &mut out);
// One file in memory at a time, as `search::fill_lines` reads them.
let mut places: Vec<&mut Place> = root
.iter_mut()
.chain(&mut items)
.flat_map(|i| std::iter::once(&mut i.at).chain(&mut i.call_sites))
.filter(|place| place.file.is_some())
.collect();
places.sort_by(|a, b| a.file.cmp(&b.file));
for in_file in places.chunk_by_mut(|a, b| a.file == b.file) {
if call.cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Some(path) = in_file[0].file.clone() else { continue };
if let Ok(text) = crate::ops::fs::fs_read_text(&call.host, call.window(), path).await {
fill_line_texts(in_file, &text);
}
}
Output::json(CallHierarchyOutput { root, items, page: out, incomplete })
}
#[derive(Serialize)]
struct CallHierarchyOutput {
#[serde(skip_serializing_if = "Option::is_none")]
root: Option<CallItem>,
items: Vec<CallItem>,
/// `total`, and `more` and `nextOffset` when items follow.
#[serde(flatten)]
page: serde_json::Map<String, serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
incomplete: Option<ReferencesIncomplete>,
}
/// A function or method in the call hierarchy, at its name.
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
struct CallItem {
name: String,
kind: SymbolKind,
#[serde(skip_serializing_if = "Option::is_none")]
detail: Option<String>,
#[serde(flatten)]
at: Place,
#[serde(skip_serializing_if = "Vec::is_empty")]
call_sites: Vec<Place>,
#[serde(skip_serializing_if = "Option::is_none")]
call_site_count: Option<usize>,
}
/// A range as the tools show it: 1-based UTF-16, with the text of its first line.
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
struct Place {
file_path: String,
start_line: u32,
start_column: u32,
end_line: u32,
end_column: u32,
#[serde(skip_serializing_if = "Option::is_none")]
line_text: Option<String>,
/// The file `line_text` is read from; none in a library.
#[serde(skip)]
file: Option<PathBuf>,
}
/// The root and the items of `h`, sorted by file and position, with call sites in source
/// order, at most [`MAX_CALL_SITES`] per item. Library items show their URI.
fn call_items(h: CallHierarchy, display: impl Fn(&Path) -> String) -> (Option<CallItem>, Vec<CallItem>) {
let CallHierarchy { root, items, .. } = h;
// A file path, or the URI of a virtual document, which has no lines to read here.
let target = |path: &Path, uri: Option<&String>| match uri {
Some(uri) => (None, uri.clone()),
None => (Some(path.to_path_buf()), display(path)),
};
let place = |(file, file_path): (Option<PathBuf>, String), r: Range| Place {
file_path,
start_line: r.start.line + 1,
start_column: r.start.col + 1,
end_line: r.end.line + 1,
end_column: r.end.col + 1,
line_text: None,
file,
};
let convert = |i: HierarchyItem| {
let at = target(&i.path.0, i.uri.as_ref());
let sites_in = match &i.from_path {
Some(p) => {
let shown = p.0.to_string_lossy();
target(&p.0, ide_core::is_virtual_uri(&shown).then(|| shown.into_owned()).as_ref())
}
None => at.clone(),
};
let mut sites = i.from_ranges;
sites.sort();
sites.dedup();
let count = sites.len();
CallItem {
call_sites: sites.into_iter().take(MAX_CALL_SITES).map(|r| place(sites_in.clone(), r)).collect(),
call_site_count: (count > MAX_CALL_SITES).then_some(count),
at: place(at, i.selection_range),
name: i.name,
kind: i.kind,
detail: i.detail,
}
};
let mut items: Vec<CallItem> = items.into_iter().map(&convert).collect();
items.sort_by(|a, b| {
(&a.at.file_path, a.at.start_line, a.at.start_column).cmp(&(
&b.at.file_path,
b.at.start_line,
b.at.start_column,
))
});
(root.map(convert), items)
}
/// Fills `lineText` of `places`, which are all in the file whose text is `text`.
fn fill_line_texts(places: &mut [&mut Place], text: &str) {
let lines: Vec<&str> = text.split('\n').collect();
for place in places {
let Some(line) = lines.get(place.start_line as usize - 1) else { continue };
let line = line.strip_suffix('\r').unwrap_or(line);
let start = place.start_column as usize - 1;
let end = if place.end_line == place.start_line { place.end_column as usize - 1 } else { start };
place.line_text = Some(super::search::snippet(line, start, end));
}
}
/// The innermost function, method or constructor of `outline` whose extent holds `pos`,
/// as the IDE's Call Hierarchy finds it.
fn enclosing_callable(outline: &[OutlineItem], pos: Pos) -> Option<&OutlineItem> {
let item = outline.iter().find(|i| i.range.start <= pos && pos <= i.range.end)?;
enclosing_callable(&item.children, pos).or_else(|| {
matches!(item.kind, SymbolKind::Function | SymbolKind::Method | SymbolKind::Constructor).then_some(item)
})
}
fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
if line < 1 || line > u32::MAX as i64 || column < 1 || column > u32::MAX as i64 {
return Err(IdeError::invalid("line and column must be positive 1-based positions"));
@@ -531,156 +284,3 @@ fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
}
Ok(Pos::new((line - 1) as u32, (column - 1) as u32))
}
#[cfg(test)]
mod tests {
use super::*;
fn range(line: u32, col: u32, end_line: u32, end_col: u32) -> Range {
Range::new(Pos::new(line, col), Pos::new(end_line, end_col))
}
fn item(name: &str, path: &str, line: u32, from_ranges: Vec<Range>) -> HierarchyItem {
HierarchyItem {
name: name.into(),
kind: SymbolKind::Function,
detail: Some(format!("fn {name}()")),
path: PathBuf::from(path).into(),
uri: None,
range: range(line, 0, line + 2, 1),
selection_range: range(line, 3, line, 3 + name.len() as u32),
from_ranges,
from_path: None,
}
}
fn shown(path: &Path) -> String {
path.strip_prefix("/p").unwrap_or(path).to_string_lossy().into_owned()
}
fn hierarchy(root: HierarchyItem, items: Vec<HierarchyItem>) -> CallHierarchy {
CallHierarchy { root: Some(root), items, incomplete: None }
}
#[test]
fn incoming_call_sites_are_in_the_callers_file_one_based() {
let h = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![item("main", "/p/src/main.rs", 2, vec![range(4, 8, 4, 13)])],
);
let (root, items) = call_items(h, shown);
let root = serde_json::to_value(root.unwrap()).unwrap();
assert_eq!(
root,
json!({"name":"price","kind":"function","detail":"fn price()","filePath":"src/lib.rs",
"startLine":11,"startColumn":4,"endLine":11,"endColumn":9})
);
assert_eq!(
serde_json::to_value(&items).unwrap(),
json!([{"name":"main","kind":"function","detail":"fn main()","filePath":"src/main.rs",
"startLine":3,"startColumn":4,"endLine":3,"endColumn":8,
"callSites":[{"filePath":"src/main.rs","startLine":5,"startColumn":9,"endLine":5,"endColumn":14}]}])
);
}
#[test]
fn outgoing_call_sites_are_in_the_file_ide_lsp_names() {
let mut price = item("price", "/p/src/lib.rs", 10, vec![range(4, 8, 4, 13)]);
price.from_path = Some(PathBuf::from("/p/src/main.rs").into());
let (_, items) = call_items(hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![price]), shown);
assert_eq!(items[0].at.file_path, "src/lib.rs");
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
assert_eq!(items[0].call_sites[0].file.as_deref(), Some(Path::new("/p/src/main.rs")));
}
#[test]
fn library_items_show_their_uri() {
let mut library = item("len", "/virtual", 0, vec![range(4, 8, 4, 11)]);
library.uri = Some("jar:file:///lib.jar!/Str.class".into());
library.from_path = Some(PathBuf::from("/p/src/main.rs").into());
let mut called_from_library = item("parse", "/p/src/a.rs", 3, vec![range(1, 0, 1, 4)]);
called_from_library.from_path = Some(PathBuf::from("jdt://contents/lib.jar/Caller.class").into());
let h = hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![library, called_from_library]);
let (_, items) = call_items(h, shown);
assert_eq!(items[0].at.file_path, "jar:file:///lib.jar!/Str.class");
assert_eq!(items[0].at.file, None, "no line text for a library item");
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
assert_eq!(items[1].call_sites[0].file_path, "jdt://contents/lib.jar/Caller.class");
assert_eq!(items[1].call_sites[0].file, None);
}
#[test]
fn call_items_are_sorted_by_file_and_line() {
let h = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![
item("c", "/p/src/main.rs", 9, Vec::new()),
item("b", "/p/src/main.rs", 2, Vec::new()),
item("a", "/p/src/a.rs", 5, Vec::new()),
],
);
let (_, items) = call_items(h, shown);
assert_eq!(items.iter().map(|i| i.name.as_str()).collect::<Vec<_>>(), ["a", "b", "c"]);
}
#[test]
fn call_sites_are_capped_with_their_count() {
let sites = (0..MAX_CALL_SITES as u32 + 5).map(|l| range(l, 0, l, 1)).collect();
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
let (_, items) = call_items(h, shown);
assert_eq!(items[0].call_sites.len(), MAX_CALL_SITES);
assert_eq!(items[0].call_site_count, Some(MAX_CALL_SITES + 5));
let one = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![item("main", "/p/a.rs", 0, vec![range(1, 0, 1, 1)])],
);
assert_eq!(call_items(one, shown).1[0].call_site_count, None);
}
#[test]
fn call_sites_are_in_source_order_without_duplicates() {
let sites = vec![range(5, 0, 5, 1), range(1, 4, 1, 5), range(5, 0, 5, 1), range(1, 2, 1, 3)];
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
let (_, items) = call_items(h, shown);
let at: Vec<_> = items[0].call_sites.iter().map(|s| (s.start_line, s.start_column)).collect();
assert_eq!(at, [(2, 3), (2, 5), (6, 1)]);
assert_eq!(items[0].call_site_count, None);
}
#[test]
fn line_text_is_cut_from_the_line_of_each_place() {
let h = hierarchy(item("price", "/p/src/lib.rs", 3, vec![range(0, 4, 0, 9), range(1, 0, 3, 1)]), Vec::new());
let mut root = call_items(h, shown).0.unwrap();
let mut places: Vec<&mut Place> = std::iter::once(&mut root.at).chain(&mut root.call_sites).collect();
fill_line_texts(&mut places, " price();\r\nfn other() {\n\nfn price() {}");
assert_eq!(root.at.line_text.as_deref(), Some("fn price() {}"));
assert_eq!(root.call_sites[0].line_text.as_deref(), Some(" price();"));
assert_eq!(root.call_sites[1].line_text.as_deref(), Some("fn other() {"), "a range over lines");
}
#[test]
fn enclosing_callable_is_the_innermost_function() {
let outline = |name: &str, kind, range, children| OutlineItem {
name: name.into(),
detail: None,
kind,
range,
selection_range: Range::new(range.start, range.start),
children,
visibility: None,
};
let method = outline(
"total",
SymbolKind::Method,
range(2, 4, 8, 5),
vec![outline("add", SymbolKind::Function, range(3, 8, 5, 9), Vec::new())],
);
let items = vec![outline("Cart", SymbolKind::Struct, range(0, 0, 9, 1), vec![method])];
let name = |pos| enclosing_callable(&items, pos).map(|i| i.name.as_str());
assert_eq!(name(Pos::new(4, 0)), Some("add"));
assert_eq!(name(Pos::new(5, 9)), Some("add"), "the end is inside");
assert_eq!(name(Pos::new(7, 0)), Some("total"));
assert_eq!(name(Pos::new(0, 3)), None, "a struct is not callable");
assert_eq!(name(Pos::new(12, 0)), None);
}
}
-14
Переглянути файл
@@ -268,19 +268,6 @@ pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: Agent
host.project(window)?.agents.prompt(&task, prompt, now).await
}
/// Answers a non-blocking question, without cancelling the current turn.
#[command(trust = trusted)]
pub async fn agent_answer_question(
host: &Host,
window: &str,
task: String,
question: String,
answer: Option<String>,
) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.answer_question(&task, &question, answer).await
}
/// Drops a queued message and returns it (to edit it).
#[command(trust = always)]
pub fn agent_unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
@@ -1028,7 +1015,6 @@ mod tests {
ide_command::domain!(
agent:
agent_accept_changes,
agent_answer_question,
agent_archive,
agent_base_text,
agent_cancel,
+2 -5
Переглянути файл
@@ -141,11 +141,8 @@ impl DependencyVersionSource for GoModules {
}
fn fetch(&self, package: &str, cancel: &CancellationToken) -> IdeResult<Vec<String>> {
let search = self
.env
.get("PATH")
.map(std::ffi::OsString::from)
.unwrap_or_else(|| ide_core::tool_path::search_path_in(&self.root));
let search =
self.env.get("PATH").map(std::ffi::OsString::from).unwrap_or_else(ide_core::tool_path::search_path);
let go = ide_core::tool_path::find_command("go", &search, &self.root)
.ok_or_else(|| IdeError::unavailable("Go SDK is unavailable"))?;
// A partially edited go.mod is often invalid. Query outside it while
+6 -120
Переглянути файл
@@ -93,13 +93,12 @@ fn detected_and_saved(
.linked_projects
.as_ref()
.map(|_| ide_build::gradle::load_linked(root, &settings.languages.java.gradle));
let mut detected = ide_run::detect_with_profiles(root, &excluded_poms, settings.cmake.profiles.as_deref());
detected.extend(ide_run::detect_builds(root, &linked_build_dirs(root, settings, gradle.as_deref(), &detected)));
let mut all: Vec<RunConfig> = detected
.into_iter()
.filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id))
.filter(|d| linked_config(root, gradle.as_deref(), &excluded_poms, d))
.collect();
let mut all: Vec<RunConfig> =
ide_run::detect_with_profiles(root, &excluded_poms, settings.cmake.profiles.as_deref())
.into_iter()
.filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id))
.filter(|d| linked_config(root, gradle.as_deref(), &excluded_poms, d))
.collect();
all.extend(saved.iter().cloned());
for config in all.iter_mut().filter(|c| !matches!(c.kind.as_str(), "gradle" | "maven")) {
ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(config), root, settings);
@@ -107,30 +106,6 @@ fn detected_and_saved(
all
}
/// Folders of the Maven / Gradle builds linked explicitly (Add Maven Projects, linked Gradle
/// builds) that detection did not reach: deeper than its folder search and outside the builds
/// it found, which own their nested folders.
fn linked_build_dirs(
root: &Path,
settings: &ide_core::settings::Settings,
gradle: Option<&[ide_build::GradleModel]>,
detected: &[RunConfig],
) -> Vec<std::path::PathBuf> {
let found: Vec<_> = detected
.iter()
.filter(|c| matches!(c.kind.as_str(), "maven" | "gradle"))
.map(|c| ide_core::project_roots::resolve(root, c.cwd.as_deref().unwrap_or(Path::new(""))))
.collect();
let poms = settings.languages.java.maven.linked_projects.iter().filter_map(|pom| {
let pom = root.join(pom.trim());
pom.is_file().then(|| pom.parent().map(Path::to_path_buf)).flatten()
});
poms.chain(gradle.unwrap_or_default().iter().map(|build| root.join(&build.dir)))
.map(|dir| ide_core::project_roots::resolve(root, &dir))
.filter(|dir| !found.iter().any(|build| dir.starts_with(build)))
.collect()
}
fn linked_config(
root: &std::path::Path,
gradle: Option<&[ide_build::GradleModel]>,
@@ -630,95 +605,6 @@ mod ownership_tests {
let configs = detected_and_saved(root, &settings, &[], &[]);
assert!(configs.is_empty(), "{configs:?}");
}
/// #4066: a build linked explicitly is detected beyond the folder search depth.
#[test]
fn linked_builds_are_detected_at_any_depth() {
const BOOT_POM: &str = "<project><build><plugins><plugin><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>";
const APP: &str = "package com.example;\n@SpringBootApplication public class DemoApplication { public static void main(String[] a) {} }";
let deep = "site/service/03_src/demo-monitor";
let tool = "a/b/c/tool";
type Case =
(&'static str, Vec<(String, &'static str)>, Vec<&'static str>, Option<Vec<&'static str>>, Vec<String>);
let cases: Vec<Case> = vec![
(
"reporter: Maven module four levels deep, no root POM, linked",
vec![
(format!("{deep}/pom.xml"), BOOT_POM),
(format!("{deep}/src/main/java/com/example/DemoApplication.java"), APP),
],
vec!["site/service/03_src/demo-monitor/pom.xml"],
None,
vec![
format!("maven:package:{deep}"),
format!("maven:test:{deep}"),
format!("maven:spring-boot:run:{deep}"),
format!("application:{deep}:com.example.DemoApplication"),
],
),
(
"the same module, not linked: depth limit unchanged",
vec![(format!("{deep}/pom.xml"), BOOT_POM)],
vec![],
None,
vec![],
),
(
"Gradle build four levels deep, linked",
vec![(format!("{tool}/build.gradle.kts"), "plugins {\n application\n}")],
vec![],
Some(vec![tool]),
vec![format!("gradle:build:{tool}"), format!("gradle:test:{tool}"), format!("gradle:run:{tool}")],
),
(
"linked module inside the root reactor belongs to the reactor",
vec![("pom.xml".into(), "<project></project>"), (format!("{deep}/pom.xml"), BOOT_POM)],
vec!["site/service/03_src/demo-monitor/pom.xml"],
None,
vec!["maven:package".into(), "maven:test".into()],
),
(
"linked module within the search depth is not detected twice",
vec![("svc/pom.xml".into(), "<project></project>")],
vec!["svc/pom.xml"],
None,
vec!["maven:package:svc".into(), "maven:test:svc".into()],
),
];
for (name, files, maven, gradle, expected) in cases {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
for (path, text) in &files {
std::fs::create_dir_all(root.join(path).parent().unwrap()).unwrap();
std::fs::write(root.join(path), text).unwrap();
}
let mut settings = ide_core::settings::Settings::default();
settings.languages.java.maven.linked_projects = maven.into_iter().map(String::from).collect();
settings.languages.java.gradle.linked_projects = gradle.map(|d| d.into_iter().map(String::from).collect());
let configs = detected_and_saved(root, &settings, &[], &[]);
let mut ids: Vec<_> = configs.iter().map(|c| c.id.clone()).collect();
let mut expected = expected;
ids.sort();
expected.sort();
assert_eq!(ids, expected, "{name}");
for config in configs.iter().filter(|c| matches!(c.kind.as_str(), "maven" | "gradle")) {
let cwd = config.cwd.as_deref().map(|p| p.to_string_lossy().replace('\\', "/"));
assert!(config.id.ends_with(cwd.as_deref().unwrap_or("")), "{name}: {config:?}");
}
}
// A POM linked from outside the project folder (an extra content root).
let (temp, outside) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
let external = dunce::canonicalize(outside.path()).unwrap().join("svc");
std::fs::create_dir_all(&external).unwrap();
std::fs::write(external.join("pom.xml"), BOOT_POM).unwrap();
let mut settings = ide_core::settings::Settings::default();
settings.languages.java.maven.linked_projects = vec![external.join("pom.xml").to_string_lossy().into_owned()];
let configs = detected_and_saved(temp.path(), &settings, &[], &[]);
let package =
configs.iter().find(|c| c.id == format!("maven:package:{}", external.to_string_lossy().replace('\\', "/")));
assert_eq!(package.and_then(|c| c.cwd.as_deref()), Some(external.as_path()), "{configs:?}");
}
}
ide_command::domain!(
-27
Переглянути файл
@@ -48,10 +48,6 @@ impl ReplaceHost for DocumentsHost<'_> {
/// update live and undo the whole file's replacements in one step. Unsaved
/// editor buffers are replaced in place and left unsaved; files that were not
/// open are opened transiently, saved and closed.
///
/// With `all_in_scope` (Replace All after the search hit its match limit) the
/// scope is searched again without the limit and every match in it is replaced,
/// as IDEA does: `targets` then only carry the `skip` positions of their files.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn replace_in_files(
@@ -62,15 +58,12 @@ pub async fn replace_in_files(
replacement: String,
preserve_case: bool,
targets: Vec<ReplaceTarget>,
all_in_scope: bool,
on_event: Channel<ReplaceEvent>,
) -> IdeResult<()> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let events = on_event.clone();
let syntax = host.syntax();
let summary = tokio::task::spawn_blocking(move || {
let targets = if all_in_scope { scope_targets(&project, &syntax, &query, targets, &cancel)? } else { targets };
let host = DocumentsHost(&project.documents);
ide_search::replace_files(&host, &query, &replacement, preserve_case, &targets, &cancel, &|e| {
let _ = events.send(e);
@@ -84,26 +77,6 @@ pub async fn replace_in_files(
Ok(())
}
/// Every file of `query`'s scope with a match (no match limit), sorted, each
/// keeping the `skip` positions `listed` gives it.
fn scope_targets(
project: &crate::project::Project,
syntax: &ide_language::Syntax,
query: &SearchQuery,
listed: Vec<ReplaceTarget>,
cancel: &ide_core::CancellationToken,
) -> IdeResult<Vec<ReplaceTarget>> {
let mut query = query.clone();
query.max_matches = u32::MAX;
query.exclude.extend(project.search_excludes());
let found = std::sync::Mutex::new(Vec::new());
super::search_project(project, syntax, &query, cancel, &|file| found.lock().unwrap().push(file.path))?;
let mut skip: std::collections::HashMap<_, _> = listed.into_iter().map(|t| (t.path, t.skip)).collect();
let mut paths = found.into_inner().unwrap();
paths.sort();
Ok(paths.into_iter().map(|path| ReplaceTarget { skip: skip.remove(&path).flatten(), path, only: None }).collect())
}
/// Before / after text of `path` for Replace › Preview (unsaved buffer included).
#[command(trust = trusted)]
pub async fn replace_preview(
-84
Переглянути файл
@@ -285,36 +285,6 @@ pub(super) enum Waiter {
Prompt(std::sync::mpsc::SyncSender<Option<Vec<String>>>),
Commit(std::sync::mpsc::SyncSender<CommitAnswer>),
Command(std::sync::mpsc::SyncSender<super::CommandAnswer>),
Clipboard(std::sync::mpsc::SyncSender<super::ClipboardAnswer>),
}
/// What a window read from its clipboard, as `ui.read-clipboard` returns it. Oversized text
/// or images fail here, before the base64 is decoded.
fn clipboard_content(answer: super::ClipboardAnswer) -> Result<ide_plugin::ClipboardContent, HostError> {
use base64::Engine;
let (text, png) = match answer {
super::ClipboardAnswer::Content { text, png } => (text, png),
super::ClipboardAnswer::Refused => return Err(HostError::Denied("clipboard.read (the user refused)".into())),
super::ClipboardAnswer::Failed { message } => return Err(HostError::Failed(message)),
};
let max = ide_plugin::MAX_CLIPBOARD_BYTES;
let too_large = || HostError::Failed(format!("the clipboard holds more than {} MiB", max >> 20));
// The longest base64 of `max` bytes.
if text.as_ref().is_some_and(|t| t.len() > max) || png.as_ref().is_some_and(|p| p.len() > max.div_ceil(3) * 4) {
return Err(too_large());
}
let image = match png.filter(|p| !p.is_empty()) {
Some(png) => Some(
base64::engine::general_purpose::STANDARD
.decode(png)
.map_err(|e| HostError::Failed(format!("the clipboard image is not valid base64: {e}")))?,
),
None => None,
};
if image.as_ref().is_some_and(|i| i.len() > max) {
return Err(too_large());
}
Ok(ide_plugin::ClipboardContent { text: text.filter(|t| !t.is_empty()), image })
}
/// A process a plugin started and has not released (API 1.3 `process.start`).
@@ -983,17 +953,6 @@ impl Shared {
tx.try_send(answer).is_ok()
}
/// The window a [`PluginEvent::ClipboardRequested`] went to answered it.
pub fn answer_clipboard(&self, client: &str, id: u64, answer: super::ClipboardAnswer) -> bool {
let mut prompts = self.prompts.lock();
if !matches!(prompts.get(&id), Some(PromptEntry { client: window, answer: Waiter::Clipboard(_), .. }) if window == client)
{
return false;
}
let Some(PromptEntry { answer: Waiter::Clipboard(tx), .. }) = prompts.remove(&id) else { return false };
tx.try_send(answer).is_ok()
}
pub fn answer_commit(&self, id: u64, answer: CommitAnswer) -> bool {
let mut prompts = self.prompts.lock();
if !matches!(prompts.get(&id), Some(PromptEntry { answer: Waiter::Commit(_), .. })) {
@@ -1929,49 +1888,6 @@ impl HostApi for PluginApi {
Ok(())
}
fn read_clipboard(
&self,
client: &str,
cancel: &CancellationToken,
) -> Result<ide_plugin::ClipboardContent, HostError> {
let id = self.shared.next_prompt.fetch_add(1, Ordering::Relaxed);
let (answer, answers) = std::sync::mpsc::sync_channel(1);
{
let closed = self.shared.closed_clients.lock();
let blocked = self.shared.prompts_blocked.lock();
if closed.contains(client) || blocked.contains(self.id()) {
return Err(HostError::Cancelled);
}
self.shared.prompts.lock().insert(
id,
PromptEntry {
plugin: self.id().to_owned(),
client: client.to_owned(),
answer: Waiter::Clipboard(answer),
},
);
}
let request_id = id.to_string();
self.shared.sink.emit(
Some(client),
PluginEvent::ClipboardRequested { plugin_id: self.id().to_owned(), request_id: request_id.clone() },
);
// A remote window asks the user first, so there is no deadline: the call's own
// cancellation, the plugin stopping or the window closing ends the wait.
let answer = loop {
match answers.recv_timeout(Duration::from_millis(100)) {
Ok(answer) => break answer,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) if !cancel.is_cancelled() => {}
Err(_) => {
self.shared.prompts.lock().remove(&id);
self.shared.sink.emit(Some(client), PluginEvent::PromptClosed { prompt_id: request_id });
return Err(HostError::Cancelled);
}
}
};
clipboard_content(answer)
}
fn open_url(&self, client: Option<&str>, url: String) -> Result<(), HostError> {
let client = from_window(client, "open a URL")?;
self.shared.sink.emit(Some(client), PluginEvent::OpenUrl { plugin_id: self.id().to_owned(), url });
+2 -15
Переглянути файл
@@ -1,8 +1,8 @@
//! Plugin window commands shared by local IPC and remote RPC.
use super::{
ClipboardAnswer, CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost,
PluginInfo, PluginStatusItem, WorkbenchEvent,
CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost, PluginInfo,
PluginStatusItem, WorkbenchEvent,
};
use crate::Host;
use ide_command::command;
@@ -127,18 +127,6 @@ pub fn plugin_answer_command(
Ok(plugins.answer_command(window, &request_id, answer))
}
/// This window's clipboard for a plugin's `clipboardRequested`; false when the call no
/// longer waits or asked another window.
#[command(trust = trusted)]
pub fn plugin_answer_clipboard(
plugins: &Arc<PluginHost>,
window: &str,
request_id: String,
answer: ClipboardAnswer,
) -> IdeResult<bool> {
Ok(plugins.answer_clipboard(window, &request_id, answer))
}
/// The project root a `scope` setting applies to (`None`: global).
fn scope_root(host: &Host, window: &str, scope: SettingsScope) -> IdeResult<Option<PathBuf>> {
Ok(match scope {
@@ -290,7 +278,6 @@ pub async fn plugin_debug_attach_target(
ide_command::domain!(
plugins_commands:
plugin_answer_clipboard,
plugin_answer_command,
plugin_answer_commit,
plugin_answer_prompt,
+28 -41
Переглянути файл
@@ -5,7 +5,7 @@ use ide_extension::Capability;
use ide_plugin::{EventKind, HostError, WorkbenchEvent};
use std::{
collections::{BTreeSet, HashMap},
path::{Path, PathBuf},
path::Path,
};
#[derive(Clone, Default)]
@@ -136,14 +136,32 @@ impl PluginHost {
if !path.is_absolute() {
return None;
}
let root = file_project(workspace.as_deref()?, client, path)?;
let workspace = workspace.as_ref()?;
let real = ide_plugin::resolve_real(path);
// The file's own project, not the invoking window's: annotations follow
// the file, so a plugin hears about a file another window has open.
let root = match client {
Some(client) => workspace
.project_of(client)
.filter(|r| real.starts_with(ide_plugin::resolve_real(r)))
.or_else(|| {
workspace
.projects()
.into_iter()
.filter(|r| real.starts_with(ide_plugin::resolve_real(r)))
.max_by_key(|r| r.components().count())
}),
None => workspace
.projects()
.into_iter()
.filter(|r| real.starts_with(ide_plugin::resolve_real(r)))
.max_by_key(|r| r.components().count()),
}?;
if plugin.dev_root.as_deref().is_some_and(|r| r != root) {
return None;
}
if let WorkbenchEvent::DocumentChanged(_) = event {
if let WorkbenchEvent::DocumentChanged(change) = event {
// Typed text: only for plugins that may read editors, and only for paths they named.
// The path stays absolute until delivery (`relativize_documents`): the batch is
// filtered again then, against the grants and subscriptions of that moment.
let filter = filters.and_then(|filters| filters.get(event.kind().name()))?;
let granted = &plugin.meta.lock().granted;
if !granted.contains(&Capability::ProjectRead)
@@ -152,7 +170,11 @@ impl PluginHost {
{
return None;
}
return Some(event.clone());
let real = ide_plugin::resolve_real(path);
let relative = real.strip_prefix(ide_plugin::resolve_real(&root)).ok()?;
let mut change = change.clone();
change.path = relative.to_string_lossy().replace('\\', "/");
return Some(WorkbenchEvent::DocumentChanged(change));
}
filters
.and_then(|filters| filters.get(event.kind().name()))
@@ -161,41 +183,6 @@ impl PluginHost {
})
.collect()
}
/// 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>,
events: Vec<WorkbenchEvent>,
) -> Vec<WorkbenchEvent> {
let workspace = shared.workspace();
events
.into_iter()
.filter_map(|event| {
let WorkbenchEvent::DocumentChanged(mut change) = event else { return Some(event) };
let path = Path::new(&change.path);
let root = file_project(workspace.as_deref()?, client, path)?;
let relative = ide_plugin::resolve_real(path)
.strip_prefix(ide_plugin::resolve_real(&root))
.ok()?
.to_string_lossy()
.replace('\\', "/");
change.path = relative;
Some(WorkbenchEvent::DocumentChanged(change))
})
.collect()
}
}
/// The open project an absolute `path` belongs to: the invoking window's when the file is in
/// it, else the innermost open project containing it. Annotations follow the file, so a
/// plugin hears about a file another window has open.
fn file_project(workspace: &dyn super::api::PluginWorkspace, client: Option<&str>, path: &Path) -> Option<PathBuf> {
let real = ide_plugin::resolve_real(path);
let contains = |r: &PathBuf| real.starts_with(ide_plugin::resolve_real(r));
client
.and_then(|client| workspace.project_of(client).filter(contains))
.or_else(|| workspace.projects().into_iter().filter(contains).max_by_key(|r| r.components().count()))
}
#[cfg(test)]
+3 -7
Переглянути файл
@@ -33,10 +33,10 @@ struct Decl {
}
#[derive(Clone, Debug)]
pub(super) struct Agent {
struct Agent {
/// The jar, resolved inside the package.
pub(super) jar: PathBuf,
pub(super) args: Option<String>,
jar: PathBuf,
args: Option<String>,
}
/// Agents of enabled plugins.
@@ -47,10 +47,6 @@ pub struct JavaAgents {
}
impl JavaAgents {
pub(super) fn for_plugin(&self, plugin: &str) -> Option<Agent> {
self.items.read().iter().find(|(_, id, _)| id == plugin).map(|(_, _, agent)| agent.clone())
}
fn add(self: &Arc<Self>, plugin: String, agent: Agent) -> Disposable {
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
self.items.write().push((seq, plugin, agent));
-27
Переглянути файл
@@ -1806,12 +1806,6 @@ impl PluginHost {
request.parse().is_ok_and(|id| self.shared.answer_command(client, id, answer))
}
/// A window answered a plugin's `ClipboardRequested`; false when the call no longer
/// waits or asked another window.
pub fn answer_clipboard(&self, client: &str, request_id: &str, answer: ClipboardAnswer) -> bool {
request_id.parse().is_ok_and(|id| self.shared.answer_clipboard(client, id, answer))
}
pub fn answer_commit(&self, request_id: &str, answer: CommitAnswer) -> bool {
request_id.parse().is_ok_and(|id| self.shared.answer_commit(id, answer))
}
@@ -2220,7 +2214,6 @@ impl PluginHost {
if events.is_empty() {
return Ok(());
}
let events = Self::relativize_documents(&shared, invocation.client.as_deref(), events);
rt.handle_events(events, invocation)
},
move |result| {
@@ -3094,26 +3087,6 @@ impl PluginHost {
homepage: m.homepage.clone(),
change_notes: m.change_notes.clone(),
icon: p.icon.clone(),
java_agent: self.java_agents.for_plugin(&m.id).map(|agent| {
let pin = self
.ledger
.lock()
.get(&p.subject())
.filter(|grant| grant.has(&Capability::JavaAgent))
.and_then(|grant| grant.binaries.get(&Capability::JavaAgent.to_string()).cloned());
let approved = pin.as_ref().is_some_and(|pin| {
pin.path == agent.jar && ledger::file_hash(&pin.path).is_ok_and(|hash| hash == pin.hash)
});
PluginJavaAgent {
file_name: agent
.jar
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| agent.jar.display().to_string()),
args: agent.args,
approved,
}
}),
source: p.source,
path: p.dir().to_path_buf().into(),
enabled: !self.state.lock().disabled.contains(&m.id),
-1
Переглянути файл
@@ -169,7 +169,6 @@ pub fn forwarded(event: &PluginEvent) -> bool {
| PluginEvent::PromptWaiting { .. }
| PluginEvent::RevealView { .. }
| PluginEvent::CommitRequested { .. }
| PluginEvent::ClipboardRequested { .. }
| PluginEvent::EndpointsChanged { .. }
)
}
-30
Переглянути файл
@@ -55,18 +55,6 @@ impl PluginStatus {
}
}
/// The Java agent a plugin contributes, for Settings › Plugins.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct PluginJavaAgent {
/// The jar's file name.
pub file_name: String,
/// The optional argument passed after `=`.
pub args: Option<String>,
/// The jar still has the hash recorded when `java.agent` was granted.
pub approved: bool,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct PluginInfo {
@@ -78,8 +66,6 @@ pub struct PluginInfo {
pub homepage: Option<String>,
pub change_notes: Option<String>,
pub icon: Option<PluginIcon>,
/// The Java agent this plugin declares, and whether it is still approved.
pub java_agent: Option<PluginJavaAgent>,
pub source: PluginSource,
/// Package directory.
pub path: ide_core::IpcPath,
@@ -352,10 +338,6 @@ pub enum PluginEvent {
/// `plugin_answer_commit(request_id, …)`. Closed like a prompt (`PromptClosed`).
#[serde(rename_all = "camelCase")]
CommitRequested { plugin_id: String, request_id: String, request: CommitRequest },
/// A command the user ran reads the clipboard (`ui.read-clipboard`): answer with
/// `plugin_answer_clipboard(request_id, …)`. Closed like a prompt (`PromptClosed`).
#[serde(rename_all = "camelCase")]
ClipboardRequested { plugin_id: String, request_id: String },
}
/// What a plugin asks of a window's Commit view.
@@ -493,18 +475,6 @@ pub struct PluginCommitCheckResult {
pub error: Option<String>,
}
/// A window's answer to `ClipboardRequested`: its machine's clipboard.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum ClipboardAnswer {
/// `None` for a kind the clipboard doesn't hold; `png` is base64.
Content { text: Option<String>, png: Option<String> },
/// The user refused (a remote window asks first).
Refused,
/// The window could not read the clipboard.
Failed { message: String },
}
/// The invoking window's response to a command request.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(tag = "kind", content = "value", rename_all = "camelCase")]
-83
Переглянути файл
@@ -108,9 +108,6 @@ impl Host {
let trusted = Arc::new(AtomicBool::new(self.trust.window_trusted(&root)?));
let post_start =
trusted.load(Ordering::Acquire).then(|| self.environment.project_opened(&root, &sink)).flatten();
if trusted.load(Ordering::Acquire) {
self.environment.direnv_opened(&root, &sink);
}
let settings = SettingsStore::load(&self.config_dir, Some(&root));
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
@@ -183,14 +180,7 @@ impl Host {
ide_sdk::apply::server_launch_overrides(cfg, &effective);
ide_sdk::apply::configure_server(cfg, root, server_root, &effective);
ide_sdk::apply::configure_vue_module_resolution(cfg, &data_dir);
let container_python = effective.languages.python.run_target().is_some();
crate::ops::sdk::container_python::configure_server(cfg, &data_dir, root, &effective);
// Attached dependency projects are source, so basedpyright/Pyright should
// resolve imports into them. A container target already supplies its own
// `extraPaths` (the site-packages snapshot); don't mix local sources into it.
if !container_python {
ide_sdk::apply::configure_python_extra_paths(cfg, &python_dependency_roots(&effective, root));
}
if cfg.name == "jdtls" {
// A workspace member keeps its build model under its own key (Build Project).
let cache = match &member {
@@ -397,14 +387,6 @@ impl Host {
if composer_changed(&root, changed.iter().chain(&batch.removed)) {
lsp.reconfigure_soon();
}
// Not while loading: a first `use flake` may write `flake.lock` itself.
if trusted.load(Ordering::Acquire)
&& !ide_core::project_env::is_loading(&root)
&& let Some(file) = crate::direnv::reload_offer(&root, changed.iter().chain(&batch.removed))
{
let status = ide_core::event::DirenvStatus::Changed { file };
sink.emit(IdeEvent::Direnv { root: root.clone().into(), status });
}
// Atomic saves by external tools surface as `created`.
documents.on_disk_changed(&[&changed[..], &ignored].concat());
if let Some(plugins) = crate::plugins::editor_plugin_host() {
@@ -1501,30 +1483,6 @@ fn member_dependencies_for<'a>(map: &'a BTreeMap<String, Vec<String>>, own_key:
map.iter().find(|(key, _)| ide_core::ipc_path::to_ipc(&PathBuf::from(key)) == own_key).map(|(_, deps)| deps)
}
/// Dependency roots of `root`, for a Python language server's `analysis.extraPaths`.
/// In a workspace a member depends only on the roots picked for it in Project
/// Structure › Dependencies; outside one, the project-level `dependencies` list applies.
fn python_dependency_roots(settings: &ide_core::settings::Settings, root: &Path) -> Vec<PathBuf> {
let own_key = ide_core::ipc_path::to_ipc(root);
let configured = if ide_workspace::workspace::Workspace::load(root).ok().flatten().is_some() {
member_dependencies_for(&settings.project_structure.member_dependencies, &own_key).cloned().unwrap_or_default()
} else {
settings.project_structure.dependencies.clone()
};
configured
.into_iter()
.map(|p| PathBuf::from(p.trim()))
.filter(|p| p.is_absolute() && p.is_dir())
// A `src` layout keeps its packages one level down; basedpyright searches a
// project's own `src` by itself, but not an extra path's.
.flat_map(|p| {
let src = p.join("src");
let src = src.is_dir().then_some(src);
std::iter::once(p).chain(src)
})
.collect()
}
fn extra_content_roots(
settings: &ide_core::settings::Settings,
root: &Path,
@@ -2259,47 +2217,6 @@ mod content_roots_tests {
assert_eq!(roots, vec![shared, dep]);
}
#[test]
fn python_dependency_roots_use_project_dependencies_outside_a_workspace() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("app");
let dep = tmp.path().join("lib");
let missing = tmp.path().join("gone");
std::fs::create_dir_all(&root).unwrap();
std::fs::create_dir_all(&dep).unwrap();
let src_layout = tmp.path().join("pkg");
std::fs::create_dir_all(src_layout.join("src/pkg")).unwrap();
let mut settings = ide_core::settings::Settings::default();
settings.project_structure.dependencies = vec![
dep.to_string_lossy().into_owned(),
missing.to_string_lossy().into_owned(),
"relative".into(),
src_layout.to_string_lossy().into_owned(),
];
assert_eq!(
super::python_dependency_roots(&settings, &root),
vec![dep, src_layout.clone(), src_layout.join("src")]
);
}
#[test]
fn python_dependency_roots_use_the_members_own_picks_inside_a_workspace() {
let tmp = tempfile::tempdir().unwrap();
let ws = dunce::canonicalize(tmp.path()).unwrap();
let (app, lib, other) = (ws.join("app"), ws.join("lib"), ws.join("other"));
for dir in [&app, &lib, &other] {
std::fs::create_dir_all(dir).unwrap();
}
ide_workspace::workspace::Workspace::attach(&app, "ws", vec![app.clone(), lib.clone(), other.clone()]).unwrap();
let mut settings = ide_core::settings::Settings::default();
let key = |p: &std::path::Path| ide_core::ipc_path::to_ipc(p);
settings.project_structure.member_dependencies.insert(key(&app), vec![key(&lib)]);
settings.project_structure.member_dependencies.insert(key(&other), vec![key(&app)]);
// Project-level dependencies are ignored: inside a workspace, members pick their own.
settings.project_structure.dependencies = vec![key(&other)];
assert_eq!(super::python_dependency_roots(&settings, &app), vec![lib]);
}
#[test]
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
let tmp = tempfile::tempdir().unwrap();
-1
Переглянути файл
@@ -184,7 +184,6 @@ pub fn client_accepts(event: &IdeEvent) -> bool {
| IdeEvent::UpdateAvailable { .. } => false,
IdeEvent::DbSourcesChanged
| IdeEvent::ProjectTrustChanged { .. }
| IdeEvent::Direnv { .. }
| IdeEvent::FsChanged { .. }
| IdeEvent::ExcludedDirsChanged { .. }
| IdeEvent::DocPatched { .. }
-2
Переглянути файл
@@ -275,12 +275,10 @@ impl crate::Host {
if let Some(cmd) = self.environment.project_opened(&project.root, &project.sink) {
self.environment.spawn_post_start(cmd, project.root.clone(), project.sink.clone());
}
self.environment.direnv_opened(&project.root, &project.sink);
project.lsp.set_execution_allowed(true);
project.lsp.prewarm_java_configuration();
} else {
self.environment.project_closed();
self.environment.direnv_closed(&project.root);
project.agents.shutdown();
self.processes.kill_project(&project.root);
project.notebooks.restrict().await;
-130
Переглянути файл
@@ -1,130 +0,0 @@
//! A project's direnv environment through the host, with a stand-in `direnv` on `PATH`: it
//! runs in trusted projects only, reaches the children started in the project, loads again
//! on Reload Environment and goes with trust or the project.
//! One test in its own binary: it changes this process's `PATH`.
#![cfg(unix)]
use ide_core::event::DirenvStatus;
use ide_core::{EventSink, IdeEvent, SharedSink};
use ide_host::{Host, HostConfig};
use parking_lot::Mutex;
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
use std::process::Command;
use std::sync::Arc;
use std::time::{Duration, Instant};
#[derive(Default)]
struct Events(Mutex<Vec<IdeEvent>>);
impl EventSink for Events {
fn emit(&self, e: IdeEvent) {
self.0.lock().push(e);
}
}
/// What a child started in `dir` now sees for `name`.
fn child_var(dir: &Path, name: &str) -> String {
let out = ide_core::process::prepare(Command::new("/bin/sh").current_dir(dir))
.args(["-c", &format!("printf %s \"${name}\"")])
.output()
.unwrap();
String::from_utf8(out.stdout).unwrap()
}
fn wait_for(what: &str, mut done: impl FnMut() -> bool) {
let deadline = Instant::now() + Duration::from_secs(20);
while !done() {
assert!(Instant::now() < deadline, "timed out waiting for {what}");
std::thread::sleep(Duration::from_millis(20));
}
}
#[test]
fn direnv_runs_in_trusted_projects_and_reaches_their_children() {
let tmp = tempfile::tempdir().unwrap();
let tmp = dunce::canonicalize(tmp.path()).unwrap();
let bin = tmp.join("bin");
std::fs::create_dir_all(&bin).unwrap();
// Logs each run to `runs` and prints `out.json`, or blocks like direnv on `.envrc` not allowed.
let direnv = bin.join("direnv");
std::fs::write(
&direnv,
"#!/bin/sh\necho run >> runs\n[ -f blocked ] && { echo \"direnv: error $PWD/.envrc is blocked. Run \\`direnv allow\\` to approve its content\" >&2; exit 1; }\ncat out.json\n",
)
.unwrap();
std::fs::set_permissions(&direnv, std::fs::Permissions::from_mode(0o755)).unwrap();
let path =
std::env::join_paths(std::iter::once(bin).chain(std::env::split_paths(&std::env::var_os("PATH").unwrap())))
.unwrap();
// SAFETY: no other thread runs yet.
unsafe {
std::env::set_var("PATH", path);
// Reload Environment must not read this machine's login shell.
std::env::set_var("OPENIDEA_SKIP_SHELL_ENV", "1");
}
let project = tmp.join("flake-project");
std::fs::create_dir_all(project.join("src")).unwrap();
std::fs::write(project.join(".envrc"), "use flake\n").unwrap();
std::fs::write(project.join("out.json"), r#"{"OPENIDEA_DEVSHELL":"one"}"#).unwrap();
let runs = || std::fs::read_to_string(project.join("runs")).unwrap_or_default().lines().count();
let runtime = tokio::runtime::Builder::new_multi_thread().worker_threads(2).enable_all().build().unwrap();
let events = Arc::new(Events::default());
let sink_events = events.clone();
let base = tmp.join("host");
let host = Arc::new(Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(move |_| sink_events.clone() as SharedSink),
owner: |w| w,
runtime: runtime.handle().clone(),
// The desktop: several projects in one process.
project_environment: false,
}));
// Restricted Mode: `.envrc` is project code and doesn't run.
host.trust.decide(&project, false, false).unwrap();
runtime.block_on(ide_host::ops::project::open(&host, "main", &project)).unwrap();
std::thread::sleep(Duration::from_millis(300));
assert_eq!(runs(), 0);
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
// Trusted: it loads, for children started in the project only.
runtime.block_on(host.set_project_trust(&project, true, false)).unwrap();
wait_for("the direnv environment", || child_var(&project.join("src"), "OPENIDEA_DEVSHELL") == "one");
assert_eq!(runs(), 1);
assert_eq!(child_var(&tmp, "OPENIDEA_DEVSHELL"), "", "outside the project");
// Reload Environment loads it again.
std::fs::write(project.join("out.json"), r#"{"OPENIDEA_DEVSHELL":"two"}"#).unwrap();
let reloaded = runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
assert!(reloaded.changed.iter().any(|c| c == "OPENIDEA_DEVSHELL"), "{:?}", reloaded.changed);
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "two");
// Blocked after an edit: said so, never allowed by the IDE, and the environment goes.
std::fs::write(project.join("blocked"), "").unwrap();
runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
assert!(
events.0.lock().iter().any(|e| matches!(e, IdeEvent::Direnv { status: DirenvStatus::Blocked, .. })),
"a blocked notice"
);
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
std::fs::remove_file(project.join("blocked")).unwrap();
runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "two");
// Revoking trust drops it; so does closing the project.
runtime.block_on(host.set_project_trust(&project, false, false)).unwrap();
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
runtime.block_on(host.set_project_trust(&project, true, false)).unwrap();
wait_for("the reloaded environment", || child_var(&project, "OPENIDEA_DEVSHELL") == "two");
host.close_project("main");
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
runtime.block_on(host.shutdown());
}
-243
Переглянути файл
@@ -662,34 +662,6 @@ async fn rust_references_and_rename_through_mcp() {
assert!(std::time::Instant::now() < deadline, "language server did not find format_price references");
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
}
// Its callers, the callees of one of them, and the hierarchy at a call.
let callers = h.json("get_call_hierarchy", args.clone()).await;
assert_eq!(callers["root"]["name"], "format_price", "{callers}");
let main = callers["items"].as_array().unwrap().iter().find(|i| i["name"] == "main").expect("main calls it");
assert_eq!(main["filePath"], "src/main.rs");
let call = main["callSites"]
.as_array()
.unwrap()
.iter()
.find(|s| s["lineText"].as_str().unwrap().contains("format_price("))
.expect("the call in main");
assert_eq!(call["filePath"], "src/main.rs");
let callees = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs", "line":main["startLine"], "column":main["startColumn"], "direction":"outgoing"}))
.await;
// rust-analyzer leaves out the calls inside macro arguments, such as `format_price` in `println!`.
let parse = callees["items"].as_array().unwrap().iter().find(|i| i["name"] == "parse").expect("main calls parse");
assert_eq!(
(&parse["filePath"], &parse["callSites"][0]["filePath"]),
(&json!("src/parser.rs"), &json!("src/main.rs"))
);
let at_call = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs", "line":call["startLine"], "column":call["startColumn"], "direction":"outgoing"}))
.await;
assert_eq!(
(&at_call["root"]["name"], &at_call["root"]["filePath"]),
(&json!("format_price"), &json!("src/lib.rs"))
);
let result = h.json("rename_refactoring", json!({"pathInProject":"src/lib.rs", "symbolName":"format_price", "newName":"format_amount", "line":line + 1, "column":column})).await;
assert_eq!(result["applied"], true, "{result}");
assert!(project.documents.text_snapshot(doc.id).unwrap().text.contains("format_amount"));
@@ -1007,218 +979,3 @@ async fn http_list_and_run_require_confirmation() {
assert!(result.get("headers").is_none(), "{result}");
assert!(result.get("request").is_none(), "{result}");
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_is_listed_for_untrusted_projects() {
let h = Harness::new();
let tools = Registry::new(h.host.clone()).tools(&h.root).unwrap();
assert!(tools.iter().any(|t| t.name == "get_call_hierarchy"));
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_without_a_language_server_says_it_is_unsupported() {
let h = Harness::new();
let error = h.error("get_call_hierarchy", json!({"filePath":"src/a.txt","line":1,"column":1})).await;
assert!(error.contains("call hierarchy"), "{error}");
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_rejects_an_unknown_direction() {
let h = Harness::new();
let args = json!({"filePath":"src/a.txt","line":1,"column":1,"direction":"up"});
assert_eq!(h.error("get_call_hierarchy", args).await, "direction must be incoming or outgoing");
}
/// `src/lib.rs`: `price` calls `double`; `src/main.rs`: `main` calls `price` and `show`;
/// `other/c.rs`: `helper` calls `price`; a library class calls it too.
const LIB_RS: &str = "pub fn price(cents: u64) -> u64 {\n double(cents)\n}\nfn double(v: u64) -> u64 { v * 2 }\n";
const MAIN_RS: &str = "fn main() {\n let a = price(1);\n show(a);\n}\nfn show(v: u64) {}\n";
const C_RS: &str = "fn helper() {\n price(2);\n}\n";
const LIBRARY_URI: &str = "jar:file:///lib.jar!/Caller.class";
/// A language server for `rust` that knows the call hierarchy of the files above.
struct CallServer {
root: PathBuf,
}
impl CallServer {
fn uri(&self, path: &str) -> String {
ide_lsp::path_to_uri_string(&self.root.join(path))
}
fn item(&self, name: &str) -> Value {
let r = |l, c, l2, c2| json!({"start":{"line":l,"character":c},"end":{"line":l2,"character":c2}});
let (uri, range, selection) = match name {
"price" => (self.uri("src/lib.rs"), r(0, 0, 2, 1), r(0, 7, 0, 12)),
"double" => (self.uri("src/lib.rs"), r(3, 0, 3, 34), r(3, 3, 3, 9)),
"main" => (self.uri("src/main.rs"), r(0, 0, 3, 1), r(0, 3, 0, 7)),
"show" => (self.uri("src/main.rs"), r(4, 0, 4, 18), r(4, 3, 4, 7)),
"helper" => (self.uri("other/c.rs"), r(0, 0, 2, 1), r(0, 3, 0, 9)),
_ => (LIBRARY_URI.to_owned(), r(0, 0, 9, 1), r(2, 4, 2, 10)),
};
json!({"name":name,"kind":12,"uri":uri,"range":range,"selectionRange":selection})
}
fn call(&self, name: &str, key: &str, sites: &[(u32, u32, u32)]) -> Value {
let sites: Vec<Value> = sites
.iter()
.map(|(l, c, c2)| json!({"start":{"line":l,"character":c},"end":{"line":l,"character":c2}}))
.collect();
json!({key: self.item(name), "fromRanges": sites})
}
/// The item named at `p`: on a declaration's name or on a call.
fn prepare(&self, p: &Value) -> Value {
let uri = p["textDocument"]["uri"].as_str().unwrap();
let (line, col) = (p["position"]["line"].as_u64().unwrap(), p["position"]["character"].as_u64().unwrap());
let on =
|path: &str, l: u64, from: u64, to: u64| uri == self.uri(path) && line == l && (from..=to).contains(&col);
let name = if on("src/lib.rs", 0, 7, 12) || on("src/main.rs", 1, 12, 17) {
"price"
} else if on("src/main.rs", 0, 3, 7) {
"main"
} else {
return Value::Null;
};
json!([self.item(name)])
}
}
impl ide_jsonrpc::Handler for CallServer {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
let item = p["item"]["name"].as_str().unwrap_or_default();
Ok(match method {
"initialize" => json!({"capabilities": {
"textDocumentSync": {"openClose": true, "change": 1},
"callHierarchyProvider": true,
"documentSymbolProvider": true,
}}),
"textDocument/prepareCallHierarchy" => self.prepare(&p),
"callHierarchy/incomingCalls" if item == "price" => json!([
self.call("main", "from", &[(1, 12, 17)]),
self.call("helper", "from", &[(1, 4, 9)]),
self.call("Caller", "from", &[(2, 8, 13)]),
]),
"callHierarchy/outgoingCalls" if item == "price" => json!([self.call("double", "to", &[(1, 4, 10)])]),
"callHierarchy/outgoingCalls" if item == "main" => {
json!([self.call("show", "to", &[(2, 4, 8)]), self.call("price", "to", &[(1, 12, 17)])])
}
"textDocument/documentSymbol" if p["textDocument"]["uri"] == self.uri("src/main.rs") => {
let symbol = |name| {
let item = self.item(name);
json!({"name":name,"kind":12,"range":item["range"],"selectionRange":item["selectionRange"]})
};
json!([symbol("main"), symbol("show")])
}
"callHierarchy/incomingCalls" | "callHierarchy/outgoingCalls" | "textDocument/documentSymbol" => json!([]),
_ => Value::Null,
})
}
}
/// The harness with the files above and [`CallServer`] serving them.
async fn call_hierarchy_harness() -> (Harness, tokio::task::JoinHandle<()>) {
let h = Harness::new();
h.trust().await;
for (path, text) in [("src/lib.rs", LIB_RS), ("src/main.rs", MAIN_RS), ("other/c.rs", C_RS)] {
std::fs::create_dir_all(h.root.join(path).parent().unwrap()).unwrap();
std::fs::write(h.root.join(path), text).unwrap();
}
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let port = listener.local_addr().unwrap().port();
let server = Arc::new(CallServer { root: h.root.clone() });
let accept = tokio::spawn(async move {
let mut peers = Vec::new();
while let Ok((stream, _)) = listener.accept().await {
let (r, w) = stream.into_split();
peers.push(ide_jsonrpc::Peer::connect(r, w, server.clone()));
}
});
let cfg: ide_language::LanguageServerConfig =
toml::from_str(&format!("name='calls'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
h.host.project("main").unwrap().lsp.set_servers_hook(Box::new(move |language, _| {
if language.as_str() == "rust" { vec![cfg.clone()] } else { Vec::new() }
}));
(h, accept)
}
fn names(result: &Value) -> Vec<&str> {
result["items"].as_array().unwrap().iter().map(|i| i["name"].as_str().unwrap()).collect()
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_lists_callers_with_their_call_sites() {
let (h, _server) = call_hierarchy_harness().await;
let callers = h.json("get_call_hierarchy", json!({"filePath":"src/lib.rs","line":1,"column":9})).await;
assert_eq!(callers["root"]["name"], "price");
assert_eq!(callers["root"]["filePath"], "src/lib.rs");
assert_eq!(callers["root"]["lineText"], "pub fn price(cents: u64) -> u64 {");
assert_eq!(callers["total"], 3);
let main = callers["items"].as_array().unwrap().iter().find(|i| i["name"] == "main").unwrap();
assert_eq!(
main,
&json!({"name":"main","kind":"function","filePath":"src/main.rs",
"startLine":1,"startColumn":4,"endLine":1,"endColumn":8,"lineText":"fn main() {",
"callSites":[{"filePath":"src/main.rs","startLine":2,"startColumn":13,"endLine":2,"endColumn":18,
"lineText":" let a = price(1);"}]})
);
// An item's position is a valid input for the next level.
let main_calls = h
.json(
"get_call_hierarchy",
json!({"filePath":"src/main.rs","line":main["startLine"],"column":main["startColumn"],"direction":"outgoing"}),
)
.await;
assert_eq!(names(&main_calls), ["price", "show"]);
}
#[tokio::test(flavor = "multi_thread")]
async fn outgoing_call_sites_are_in_the_file_of_the_root() {
let (h, _server) = call_hierarchy_harness().await;
// On the call `price(1)` in main.rs: the hierarchy of `price`, declared in lib.rs.
let callees = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs","line":2,"column":14,"direction":"outgoing"}))
.await;
assert_eq!(callees["root"]["filePath"], "src/lib.rs");
assert_eq!(names(&callees), ["double"]);
assert_eq!(
callees["items"][0]["callSites"],
json!([{"filePath":"src/lib.rs","startLine":2,"startColumn":5,"endLine":2,"endColumn":11,"lineText":" double(cents)"}])
);
let from_main = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs","line":1,"column":4,"direction":"outgoing"}))
.await;
let price = &from_main["items"][0];
assert_eq!((&price["filePath"], &price["callSites"][0]["filePath"]), (&json!("src/lib.rs"), &json!("src/main.rs")));
assert_eq!(price["callSites"][0]["lineText"], " let a = price(1);");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_position_in_a_function_body_means_that_function() {
let (h, _server) = call_hierarchy_harness().await;
let body = json!({"filePath":"src/main.rs","line":2,"column":5,"direction":"outgoing"});
let callees = h.json("get_call_hierarchy", body).await;
assert_eq!(callees["root"]["name"], "main");
assert_eq!(names(&callees), ["price", "show"]);
let outside = h.error("get_call_hierarchy", json!({"filePath":"src/main.rs","line":6,"column":1})).await;
assert_eq!(outside, "no function or method at 6:1");
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_pages_are_sorted_and_scoped() {
let (h, _server) = call_hierarchy_harness().await;
let at = |extra: Value| {
let mut args = json!({"filePath":"src/lib.rs","line":1,"column":9});
args.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
args
};
let first = h.json("get_call_hierarchy", at(json!({"limit":2}))).await;
assert_eq!(names(&first), ["Caller", "helper"]);
assert_eq!(first["items"][0]["filePath"], LIBRARY_URI);
assert!(first["items"][0].get("lineText").is_none(), "{first}");
assert_eq!((&first["more"], &first["nextOffset"]), (&json!(true), &json!(2)));
let next = h.json("get_call_hierarchy", at(json!({"limit":2,"offset":2}))).await;
assert_eq!(names(&next), ["main"]);
let scoped = h.json("get_call_hierarchy", at(json!({"scope":"src"}))).await;
assert_eq!(names(&scoped), ["main"]);
assert_eq!(scoped["total"], 1);
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the scope");
}
-234
Переглянути файл
@@ -1,234 +0,0 @@
//! `ui.read-clipboard` (API 1.11) through the `test.clipboard` fixture and a
//! scripted window answering `ClipboardRequested`: commands and view actions the
//! user ran read the window's clipboard, anything unattended is denied.
use base64::Engine;
use ide_host::plugins::*;
use ide_plugin::{HostError, Invocation, Limits, ViewEvent};
use parking_lot::Mutex;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::{Duration, Instant};
const ID: &str = "test.clipboard";
fn fixture_dir() -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/clipboard")
}
struct Workspace {
root: PathBuf,
}
impl PluginWorkspace for Workspace {
fn projects(&self) -> Vec<PathBuf> {
vec![self.root.clone()]
}
fn buffer_text(&self, _: &Path) -> Option<String> {
None
}
fn document(&self, _: &Path) -> Option<(u64, String)> {
None
}
fn apply_edits(&self, _: &Path, _: u64, _: &[ide_core::TextEdit], _: bool) -> Result<u64, HostError> {
Err(HostError::NotFound("not open".into()))
}
fn trusted(&self, _: &Path) -> bool {
true
}
fn project_of(&self, _: &str) -> Option<PathBuf> {
Some(self.root.clone())
}
fn publish_diagnostics(&self, _: &str, _: &Path, _: Vec<ide_core::Diagnostic>) -> Result<(), HostError> {
Ok(())
}
}
/// The window: what it answers, and the requests it got (`(window, request id)`).
#[derive(Default)]
struct Window {
answer: Option<ClipboardAnswer>,
/// Answer from this window instead of the one asked.
answer_as: Option<String>,
requests: Vec<(Option<String>, String)>,
}
struct Fixture {
host: Arc<PluginHost>,
window: Arc<Mutex<Window>>,
project: PathBuf,
_tmp: tempfile::TempDir,
}
impl Fixture {
fn new() -> Self {
let tmp = tempfile::tempdir().unwrap();
let project = tmp.path().join("project");
std::fs::create_dir_all(&project).unwrap();
let window = Arc::new(Mutex::new(Window::default()));
let host_slot: Arc<Mutex<Option<std::sync::Weak<PluginHost>>>> = Arc::default();
let (w, slot) = (window.clone(), host_slot.clone());
// Answers on another thread, as the UI does through `plugin_answer_clipboard`.
let sink = Arc::new(move |client: Option<&str>, e: PluginEvent| {
let PluginEvent::ClipboardRequested { request_id, .. } = e else { return };
let (client, w, slot) = (client.map(str::to_owned), w.clone(), slot.clone());
std::thread::spawn(move || {
let (answer, from) = {
let mut w = w.lock();
w.requests.push((client.clone(), request_id.clone()));
(w.answer.clone(), w.answer_as.clone().or(client).unwrap_or_default())
};
let host = slot.lock().as_ref().and_then(std::sync::Weak::upgrade).unwrap();
if let Some(answer) = answer {
host.answer_clipboard(&from, &request_id, answer);
}
});
});
let host = Arc::new(PluginHost::new(tmp.path().join("plugins"), sink, Limits::default()).unwrap());
*host_slot.lock() = Some(Arc::downgrade(&host));
host.set_workspace(Some(Arc::new(Workspace { root: project.clone() })));
host.load_all();
host.startup_finished();
host.install_from_dir(&fixture_dir(), &Consent::all()).unwrap();
Self { host, window, project, _tmp: tmp }
}
fn inv(&self) -> Invocation {
Invocation { client: Some("main".into()), workspace_root: Some(self.project.clone()), ..Invocation::default() }
}
fn answer(&self, answer: ClipboardAnswer) {
self.window.lock().answer = Some(answer);
}
fn read(&self) -> Result<String, String> {
self.host.run_command(ID, "read", None, self.inv()).map(Option::unwrap_or_default).map_err(|e| e.message)
}
/// What the last view action or event handler read.
fn last(&self) -> String {
self.host.run_command(ID, "last", None, self.inv()).unwrap().unwrap_or_default()
}
fn requests(&self) -> usize {
self.window.lock().requests.len()
}
}
fn content(text: Option<&str>, png: Option<&[u8]>) -> ClipboardAnswer {
ClipboardAnswer::Content {
text: text.map(str::to_owned),
png: png.map(|png| base64::engine::general_purpose::STANDARD.encode(png)),
}
}
#[test]
fn a_command_reads_the_text_and_image_of_its_window() {
let f = Fixture::new();
f.answer(content(Some("curl https://example.com"), None));
assert_eq!(f.read().unwrap(), "text=curl https://example.com image=-");
assert_eq!(f.window.lock().requests[0].0.as_deref(), Some("main"), "the invoking window is asked");
f.answer(content(None, Some(&[0x89, b'P', b'N', b'G', 1, 2])));
assert_eq!(f.read().unwrap(), "text=- image=6");
f.answer(content(Some("caption"), Some(&[1, 2, 3])));
assert_eq!(f.read().unwrap(), "text=caption image=3");
// Empty: neither kind, also when the window sends empty strings.
f.answer(content(None, None));
assert_eq!(f.read().unwrap(), "text=- image=-");
f.answer(ClipboardAnswer::Content { text: Some(String::new()), png: Some(String::new()) });
assert_eq!(f.read().unwrap(), "text=- image=-");
}
#[test]
fn refusals_failures_and_oversized_content_are_errors() {
let f = Fixture::new();
f.answer(ClipboardAnswer::Refused);
let err = f.read().unwrap_err();
assert!(err.contains("clipboard.read (the user refused)"), "{err}");
f.answer(ClipboardAnswer::Failed { message: "the WebView refused".into() });
assert!(f.read().unwrap_err().contains("the WebView refused"));
let large = vec![0u8; ide_plugin::MAX_CLIPBOARD_BYTES + 1];
f.answer(content(None, Some(&large)));
assert!(f.read().unwrap_err().contains("16 MiB"));
f.answer(content(Some(&"x".repeat(ide_plugin::MAX_CLIPBOARD_BYTES + 1)), None));
assert!(f.read().unwrap_err().contains("16 MiB"));
}
#[test]
fn reading_needs_its_own_grant() {
let f = Fixture::new();
f.answer(content(Some("secret"), None));
f.host.set_capability(ID, "clipboard.read", false).unwrap();
let err = f.read().unwrap_err();
assert!(err.contains("clipboard.read"), "{err}");
assert_eq!(f.requests(), 0, "the window is not asked");
}
#[test]
fn only_calls_the_user_ran_read_it() {
let f = Fixture::new();
f.answer(content(Some("secret"), None));
let denied = |out: &str| out.starts_with("error: ") && out.contains("clipboard.read");
// A view's button is the user's; a web view message is the page's own.
f.host.view_event(ID, "clipboard", ViewEvent::Button { id: "read".into() }, f.inv()).unwrap();
assert_eq!(f.last(), "text=secret image=-");
assert_eq!(f.requests(), 1);
f.host.view_event(ID, "clipboard", ViewEvent::Message { text: "read".into() }, f.inv()).unwrap();
let last = f.last();
assert!(denied(&last), "{last}");
// An event handler.
let now = Instant::now();
let focused = f.project.join("a.txt").to_string_lossy().into_owned();
f.host.post_events(Some("main"), vec![WorkbenchEvent::EditorFocused(Some(focused))]);
f.host.flush_events_at(now + Duration::from_secs(3));
assert!(f.host.wait_events(Duration::from_secs(10)));
let last = f.last();
assert!(denied(&last), "{last}");
// A command another plugin ran through `command-runner`, and one with no window.
let nested = Invocation { command_chain: vec!["other.plugin".into()], ..f.inv() };
assert!(f.host.run_command(ID, "read", None, nested).unwrap_err().message.contains("clipboard.read"));
let headless = Invocation { client: None, ..f.inv() };
assert!(f.host.run_command(ID, "read", None, headless).unwrap_err().message.contains("clipboard.read"));
assert_eq!(f.requests(), 1, "only the view's button asked the window");
}
#[test]
fn only_the_asked_window_answers() {
let f = Fixture::new();
f.window.lock().answer_as = Some("other".into());
f.answer(content(Some("other window"), None));
let host = f.host.clone();
let inv = f.inv();
let read = std::thread::spawn(move || host.run_command(ID, "read", None, inv));
let started = Instant::now();
while f.requests() == 0 {
assert!(started.elapsed() < Duration::from_secs(10), "the window was not asked");
std::thread::sleep(Duration::from_millis(10));
}
// The other window's answer was ignored, so the call still waits for `main`.
std::thread::sleep(Duration::from_millis(200));
assert!(!read.is_finished());
let request = f.window.lock().requests[0].1.clone();
assert!(f.host.answer_clipboard("main", &request, content(Some("main window"), None)));
assert_eq!(read.join().unwrap().unwrap().as_deref(), Some("text=main window image=-"));
}
#[test]
fn the_capability_needs_api_1_11() {
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("clipboard");
std::fs::create_dir_all(pkg.join("dist")).unwrap();
let manifest = std::fs::read_to_string(fixture_dir().join("plugin.toml")).unwrap();
std::fs::write(pkg.join("plugin.toml"), manifest.replace("^1.11", "^1.10")).unwrap();
std::fs::copy(fixture_dir().join("dist/plugin.wasm"), pkg.join("dist/plugin.wasm")).unwrap();
let host =
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap();
let err = host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.11"), "{err:?}");
}
-32
Переглянути файл
@@ -2204,10 +2204,6 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
let info = f.host.install_from_dir(&pkg, &Consent::default()).unwrap();
assert_eq!(info.status, PluginStatus::Static, "{:?}", info.error);
assert!(info.contributions.iter().any(|c| c.point == "javaAgents" && c.label == "fixture agent.jar=mode=test"));
let agent = info.java_agent.clone().expect("agent metadata");
assert_eq!(agent.file_name, "fixture agent.jar");
assert_eq!(agent.args.as_deref(), Some("mode=test"));
assert!(!agent.approved);
let source = f.host.java_agents();
let launch = || {
let agents = ide_run::java_agent::approved(&source.agents());
@@ -2221,7 +2217,6 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
// Granted: the installed jar with its arguments, one argument after the VM options.
let info = f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert!(info.capabilities.iter().any(|c| c.id == "java.agent" && c.granted));
assert!(info.java_agent.as_ref().is_some_and(|agent| agent.approved));
let jar = dunce::canonicalize(f.installed("java-agent").join("agent/fixture agent.jar")).unwrap();
let option = format!("-javaagent:{}=mode=test", jar.display());
let mut with_agent = plain.clone();
@@ -2233,11 +2228,7 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
let (args, notes) = launch();
assert_eq!(args, plain);
assert!(notes.len() == 1 && notes[0].contains("changed since it was approved"), "{notes:?}");
let changed = f.host.info_of("java-agent").unwrap();
assert!(!changed.java_agent.as_ref().unwrap().approved, "Settings must show the changed jar");
f.host.set_capability("java-agent", "java.agent", false).unwrap();
f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert!(f.host.info_of("java-agent").unwrap().java_agent.as_ref().is_some_and(|a| a.approved));
assert_eq!(launch(), (with_agent.clone(), vec![]));
// Revoked, then the plugin disabled: no agent either way.
@@ -5284,29 +5275,6 @@ fn plugin_readonly_fields_and_table_row_extensions_round_trip() {
}
}
#[test]
fn document_changes_reach_plugins_relative_to_the_project() {
let f = fixture(Limits::default());
f.install(&sample("path-events"));
f.run("test.path-events", "count", None).unwrap();
let deliver = |path: &str| {
let change = ide_plugin::DocumentChanged {
path: to_ipc(&f.project.join(path)),
base_version: 1,
version: 2,
changes: Vec::new(),
};
f.host.post_events(Some("main"), vec![WorkbenchEvent::DocumentChanged(change)]);
f.host.flush_events_at(Instant::now() + Duration::from_secs(3));
assert!(f.host.wait_events(Duration::from_secs(10)));
};
deliver("src/main.rs");
assert_eq!(f.run("test.path-events", "document", None).unwrap(), None, "outside the subscribed paths");
// 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"));
}
#[test]
fn path_filtered_events_do_not_wake_idle_plugins_and_recheck_queued_filters() {
let f = fixture(Limits { idle_timeout: Some(Duration::from_millis(100)), ..Limits::default() });
-2
Переглянути файл
@@ -176,9 +176,7 @@ async fn properties_search_git_and_document_coordinates_agree() {
vec![ide_search::ReplaceTarget {
path: closed_path.clone().into(),
only: Some(vec![ide_core::Pos { line: 0, col: 10 }]),
skip: None,
}],
false,
ide_host::ops::Channel::new(|_| {}),
)
.await
-32
Переглянути файл
@@ -1080,35 +1080,3 @@ async fn cancelling_one_request_does_not_interrupt_another_running_command() {
assert_eq!(plugins.host().info_of("jobs").unwrap().stats.crashes, 0);
plugins.host().shutdown();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn a_remote_command_reads_the_clipboard_of_the_desktop_window() {
let (_tmp, plugins, peer, client) = command_rpc_fixture().await;
plugins.host().install_from_dir(&fixture("clipboard"), &Consent::all()).unwrap();
let read = tokio::spawn({
let peer = peer.clone();
async move {
invoke(&peer, "plugin_run_command", json!({ "pluginId": "test.clipboard", "commandId": "read" })).await
}
});
until("the server asks the window for its clipboard", 5, || {
client.plugin_events.lock().iter().any(|m| matches!(m.event, PluginEvent::ClipboardRequested { .. }))
})
.await;
let (window, request) = client
.plugin_events
.lock()
.iter()
.find_map(|m| match &m.event {
PluginEvent::ClipboardRequested { request_id, .. } => Some((m.window.clone(), request_id.clone())),
_ => None,
})
.unwrap();
assert_eq!(window.as_deref(), Some("main"), "the invoking window reads its own clipboard");
let answer = json!({ "kind": "content", "text": "from the desktop", "png": null });
let answered = invoke(&peer, "plugin_answer_clipboard", json!({ "requestId": request, "answer": answer }));
assert_eq!(answered.await.unwrap(), true);
let reply = tokio::time::timeout(Duration::from_secs(5), read).await.unwrap().unwrap().unwrap();
assert_eq!(reply, "text=from the desktop image=-");
plugins.host().shutdown();
}
-148
Переглянути файл
@@ -1,148 +0,0 @@
//! Replace All when the search hit its match limit (#4083): every match in the
//! scope is replaced, not just the listed ones.
use ide_core::{NullSink, Pos, RequestId};
use ide_host::{Host, HostConfig, ops};
use ide_search::{ReplaceEvent, ReplaceSummary, ReplaceTarget, SearchQuery};
use std::sync::{Arc, Mutex};
fn query(pattern: &str, is_regex: bool) -> SearchQuery {
serde_json::from_value(serde_json::json!({"pattern": pattern, "isRegex": is_regex, "caseSensitive": true, "wholeWord": false, "include": [], "exclude": [], "scope": {"kind": "project"}, "maxMatches": 2000})).unwrap()
}
struct Case {
name: &'static str,
files: Vec<(&'static str, String)>,
pattern: &'static str,
is_regex: bool,
replacement: &'static str,
/// `(file, positions)` sent as targets: `skip` with `all_in_scope`, else `only`.
targets: Vec<(&'static str, Vec<Pos>)>,
all_in_scope: bool,
expected: Vec<(&'static str, String)>,
replaced: u32,
}
fn lines(n: usize, text: &str) -> String {
format!("{text}\n").repeat(n)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn replace_all_covers_matches_past_the_limit() {
let cases = vec![
Case {
name: "one file, 2001 matches (the report)",
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
pattern: "CAP_PROBE",
is_regex: false,
replacement: "CAP_CHANGED",
targets: vec![],
all_in_scope: true,
expected: vec![("repeated.txt", lines(2001, "CAP_CHANGED"))],
replaced: 2001,
},
Case {
name: "several files, unlisted ones too",
files: vec![("a.txt", lines(1500, "CAP")), ("b.txt", lines(1500, "CAP")), ("sub/c.txt", "x CAP\n".into())],
pattern: "CAP",
is_regex: false,
replacement: "Z",
targets: vec![],
all_in_scope: true,
expected: vec![("a.txt", lines(1500, "Z")), ("b.txt", lines(1500, "Z")), ("sub/c.txt", "x Z\n".into())],
replaced: 3001,
},
Case {
name: "excluded usages are kept",
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
pattern: "CAP_PROBE",
is_regex: false,
replacement: "CAP_CHANGED",
targets: vec![("repeated.txt", vec![Pos::new(0, 0), Pos::new(2000, 0)])],
all_in_scope: true,
expected: vec![("repeated.txt", format!("CAP_PROBE\n{}CAP_PROBE\n", lines(1999, "CAP_CHANGED")))],
replaced: 1999,
},
Case {
name: "regex with groups",
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
pattern: r"CAP_(\w+)",
is_regex: true,
replacement: "${1}_CAP",
targets: vec![],
all_in_scope: true,
expected: vec![("repeated.txt", lines(2001, "PROBE_CAP"))],
replaced: 2001,
},
Case {
name: "Replace Selected keeps to the selected usages",
files: vec![("repeated.txt", lines(3, "CAP_PROBE"))],
pattern: "CAP_PROBE",
is_regex: false,
replacement: "CAP_CHANGED",
targets: vec![("repeated.txt", vec![Pos::new(1, 0)])],
all_in_scope: false,
expected: vec![("repeated.txt", "CAP_PROBE\nCAP_CHANGED\nCAP_PROBE\n".into())],
replaced: 1,
},
];
for case in cases {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
for (path, text) in &case.files {
let path = root.join(path);
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, text).unwrap();
}
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.trust.decide(&root, true, false).unwrap();
host.open_project("main", &root).unwrap();
let targets = case
.targets
.iter()
.map(|(path, at)| {
let path = root.join(path).into();
if case.all_in_scope {
ReplaceTarget { path, only: None, skip: Some(at.clone()) }
} else {
ReplaceTarget { path, only: Some(at.clone()), skip: None }
}
})
.collect();
let summary = Arc::new(Mutex::new(ReplaceSummary::default()));
let out = summary.clone();
ops::search::replace_in_files(
&host,
"main",
RequestId::next(),
query(case.pattern, case.is_regex),
case.replacement.into(),
false,
targets,
case.all_in_scope,
ops::Channel::new(move |e| {
if let ReplaceEvent::Done { summary } = e {
*out.lock().unwrap() = summary;
}
}),
)
.await
.unwrap();
for (path, text) in &case.expected {
assert_eq!(&std::fs::read_to_string(root.join(path)).unwrap(), text, "{}: {path}", case.name);
}
assert_eq!(summary.lock().unwrap().replacements, case.replaced, "{}", case.name);
host.close_project("main");
}
}
+33 -461
Переглянути файл
@@ -68,7 +68,7 @@ pub(crate) struct Shared {
pub store: Option<Store>,
pub indexing: AtomicBool,
pub cancelled: AtomicBool,
/// Non-cached content reads, including binary/unsupported files; used by tests.
/// Files whose content was (re)read and parsed; observability for tests.
pub parsed: std::sync::atomic::AtomicUsize,
queue: Mutex<Queue>,
wake: Condvar,
@@ -160,38 +160,14 @@ impl Shared {
q.busy = true;
}
if scan {
let startup_started = Instant::now();
// A warm start can trust the snapshot when neither the scope nor any
// directory/file metadata changed. Rebuilding the walk's file list is
// the expensive part; validate the flat manifest first.
let snapshot_started = Instant::now();
let fast = self.try_fast_start();
let snapshot_elapsed = snapshot_started.elapsed();
if !fast {
if !self.try_fast_start() {
let snapshot_guard = SystemTime::now();
let walk_started = Instant::now();
let found = self.walk_roots(None);
let walk_elapsed = walk_started.elapsed();
let hydration_started = Instant::now();
self.load_persisted(&found);
let hydration_elapsed = hydration_started.elapsed();
self.full_scan(Some(found), snapshot_guard);
if !self.is_cancelled() {
tracing::info!(
mode = "fallback",
snapshot_attempt_ms = snapshot_elapsed.as_millis() as u64,
walk_ms = walk_elapsed.as_millis() as u64,
hydration_ms = hydration_elapsed.as_millis() as u64,
elapsed_ms = startup_started.elapsed().as_millis() as u64,
"index startup completed"
);
}
} else if !self.is_cancelled() {
tracing::info!(
mode = "snapshot",
elapsed_ms = startup_started.elapsed().as_millis() as u64,
"index startup completed"
);
}
} else {
self.indexing.store(false, Ordering::SeqCst);
@@ -258,7 +234,6 @@ impl Shared {
return false;
}
let root = filter.root();
let validation_started = Instant::now();
for i in 0..snapshot.dirs_len() {
let rel = snapshot.dir(i);
let path = if rel.is_empty() { root.to_owned() } else { root.join(rel) };
@@ -290,7 +265,6 @@ impl Shared {
return false;
}
}
let validation_elapsed = validation_started.elapsed();
let build_started = Instant::now();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
(0..snapshot.len())
@@ -328,16 +302,9 @@ impl Shared {
d.load_bulk(entries, dirs);
drop(d);
tracing::info!(
mode = "snapshot",
snapshot_hydrated = snapshot.len(),
discovered = 0usize,
symbol_extractions = 0usize,
load_ms = loaded.as_millis() as u64,
directory_validation_ms = validation_elapsed.as_millis() as u64,
file_validation_build_ms = built.as_millis() as u64,
insert_ms = insert_started.elapsed().as_millis() as u64,
elapsed_ms = started.elapsed().as_millis() as u64,
"index snapshot hydrated"
"index snapshot: warm start in {:?} (load {loaded:?}, validate/build {built:?}, insert {:?})",
started.elapsed(),
insert_started.elapsed()
);
#[cfg(test)]
eprintln!(
@@ -474,7 +441,7 @@ impl Shared {
self.scan(None, found, guard);
}
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) -> Option<ScanCounts> {
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) {
let started = Instant::now();
self.indexing.store(true, Ordering::SeqCst);
self.emit_state();
@@ -490,12 +457,10 @@ impl Shared {
let filter = self.filter();
let walk_started = Instant::now();
let was_prewalked = prewalked.is_some();
let found = prewalked.unwrap_or_else(|| self.walk_roots(dirs));
let walk = walk_started.elapsed();
if self.is_cancelled() {
self.end_scan(task);
return None;
return self.end_scan(task);
}
let classify_started = Instant::now();
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
@@ -522,7 +487,6 @@ impl Shared {
self.persist(&[], &stale, false);
let total = todo.len();
let update_started = Instant::now();
let mut laps = ChunkLaps::default();
{
// One streaming parallel pass: parse on `INDEX_POOL` without
@@ -582,14 +546,11 @@ impl Shared {
laps.extract = pass_started.elapsed();
}
if self.is_cancelled() {
self.end_scan(task);
return None;
return self.end_scan(task);
}
let durable_started = Instant::now();
self.persist(&[], &[], true);
let durable = durable_started.elapsed();
let update_elapsed = update_started.elapsed();
let snapshot_started = Instant::now();
if let Some(store) = &self.store {
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
let d = self.data.read();
@@ -602,7 +563,6 @@ impl Shared {
tracing::warn!("index recent snapshot: {e}");
}
}
let snapshot_elapsed = snapshot_started.elapsed();
*self.snapshot_due.lock() = None;
self.indexing.store(false, Ordering::SeqCst);
self.sink.emit(IdeEvent::Task {
@@ -614,47 +574,20 @@ impl Shared {
cancellable: false,
});
self.emit_state();
if self.is_cancelled() {
return None;
}
laps.outcomes.not_processed += total - laps.outcomes.total();
let counts = ScanCounts {
discovered: found.len(),
metadata_reused: found.len() - total,
scheduled: total,
outcomes: laps.outcomes,
};
let outcomes = &counts.outcomes;
let d = self.data.read();
tracing::info!(
scope = if dirs.is_some() { "subtree" } else { "full" },
files = d.file_count,
symbols = d.symbol_count,
discovered = counts.discovered,
metadata_reused = counts.metadata_reused,
scheduled = counts.scheduled,
hash_reused = outcomes.hash_reused,
symbol_extractions = outcomes.symbol_extractions,
ignored = outcomes.ignored,
oversized = outcomes.oversized,
binary = outcomes.binary,
unsupported = outcomes.unsupported,
read_failed = outcomes.read_failed,
not_processed = outcomes.not_processed,
prewalked = was_prewalked,
walk_ms = walk.as_millis() as u64,
classify_ms = classify.as_millis() as u64,
// Pipeline and update wall times overlap insert/persist; do not sum these fields.
extract_pipeline_ms = laps.extract.as_millis() as u64,
insert_ms = laps.insert.as_millis() as u64,
persist_ms = laps.persist.as_millis() as u64,
durable_ms = durable.as_millis() as u64,
update_ms = update_elapsed.as_millis() as u64,
snapshot_write_ms = snapshot_elapsed.as_millis() as u64,
elapsed_ms = started.elapsed().as_millis() as u64,
"index scan completed"
"indexed {} files ({} parsed, {} symbols) in {:?} (walk {:?}, classify {:?}, extract {:?}, insert {:?}, persist {:?}, durable {:?})",
d.file_count,
total,
d.symbol_count,
started.elapsed(),
walk,
classify,
laps.extract,
laps.insert,
laps.persist,
durable
);
Some(counts)
}
/// Extracts records in parallel, then publishes them to memory and disk.
@@ -666,7 +599,6 @@ impl Shared {
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
});
laps.extract = started.elapsed();
laps.outcomes.not_processed = files.len() - extracted.len();
if extracted.is_empty() {
return laps;
}
@@ -690,9 +622,9 @@ impl Shared {
let key = filter.store_key(&f.path);
let outcome = match self.extract(f, prev_hash) {
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
Extracted::New(rec, extraction) => {
Extracted::New(rec) => {
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
ParsedOutcome::New { rec, bytes, extraction }
ParsedOutcome::New { rec, bytes }
}
};
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
@@ -708,8 +640,7 @@ impl Shared {
for out in batch {
let ParsedFile { rel, key, outcome, path } = out;
match outcome {
ParsedOutcome::New { rec, bytes, extraction } => {
laps.outcomes.record(extraction);
ParsedOutcome::New { rec, bytes } => {
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
}
@@ -727,13 +658,10 @@ impl Shared {
d.insert(e, symbols);
}
for r in refreshes {
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored) {
laps.outcomes.record(Extraction::HashReused);
if let Some(key) = r.key {
refreshed_records.push((key, rec));
}
} else {
laps.outcomes.not_processed += 1;
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
&& let Some(key) = r.key
{
refreshed_records.push((key, rec));
}
}
}
@@ -798,18 +726,15 @@ impl Shared {
fn extract(&self, f: &Found, prev_hash: Option<[u8; 32]>) -> Extracted {
let mut rec = FileRecord { mtime: f.mtime, size: f.size, ignored: f.ignored, ..Default::default() };
if f.ignored {
return Extracted::New(rec, Extraction::Ignored);
}
if f.size > MAX_SYMBOL_FILE {
return Extracted::New(rec, Extraction::Oversized);
if f.ignored || f.size > MAX_SYMBOL_FILE {
return Extracted::New(rec);
}
let mut bytes = Vec::with_capacity(f.size as usize);
match std::fs::File::open(&f.path).and_then(|mut file| file.read_to_end(&mut bytes)) {
Ok(_) => {}
Err(e) => {
tracing::debug!("index: cannot read {}: {e}", f.path.display());
return Extracted::New(rec, Extraction::ReadFailed);
return Extracted::New(rec);
}
}
rec.hash = *blake3::hash(&bytes).as_bytes();
@@ -818,7 +743,7 @@ impl Shared {
}
self.parsed.fetch_add(1, Ordering::Relaxed);
if bytes[..bytes.len().min(8192)].contains(&0) {
return Extracted::New(rec, Extraction::Binary);
return Extracted::New(rec);
}
let text = String::from_utf8_lossy(&bytes);
let lang = self.languages.detect(&f.path, Some(first_line(&text)));
@@ -835,9 +760,8 @@ impl Shared {
bases: t.bases,
})
.collect();
return Extracted::New(rec, Extraction::Symbols);
}
Extracted::New(rec, Extraction::Unsupported)
Extracted::New(rec)
}
fn process(&self, jobs: Vec<Job>) {
@@ -1014,7 +938,7 @@ fn first_line(text: &str) -> &str {
enum Extracted {
/// Content hash matches the indexed version.
Unchanged,
New(FileRecord, Extraction),
New(FileRecord),
}
/// Wall-time laps of one `index_files` chunk, accumulated by the scan.
@@ -1023,7 +947,6 @@ struct ChunkLaps {
extract: Duration,
insert: Duration,
persist: Duration,
outcomes: ExtractionCounts,
}
impl ChunkLaps {
@@ -1031,7 +954,6 @@ impl ChunkLaps {
self.extract += other.extract;
self.insert += other.insert;
self.persist += other.persist;
self.outcomes.add(other.outcomes);
}
}
@@ -1045,7 +967,7 @@ struct MetadataRefresh {
enum ParsedOutcome {
Unchanged { mtime: u64, size: u64, ignored: bool },
New { rec: FileRecord, bytes: Option<Vec<u8>>, extraction: Extraction },
New { rec: FileRecord, bytes: Option<Vec<u8>> },
}
/// One file parsed off the index thread: its outcome ready to publish, with new
@@ -1058,356 +980,6 @@ struct ParsedFile {
path: PathBuf,
}
/// Mutually exclusive outcomes for this batch, not all files in the index. "Symbols"
/// means tags() was called, even when no symbols were found.
#[derive(Clone, Copy)]
enum Extraction {
HashReused,
Symbols,
Ignored,
Oversized,
Binary,
Unsupported,
ReadFailed,
}
#[derive(Default, Debug, PartialEq, Eq)]
struct ExtractionCounts {
hash_reused: usize,
symbol_extractions: usize,
ignored: usize,
oversized: usize,
binary: usize,
unsupported: usize,
read_failed: usize,
/// Cancellation, a changed root configuration, or a concurrently removed entry.
not_processed: usize,
}
impl ExtractionCounts {
fn total(&self) -> usize {
self.hash_reused
+ self.symbol_extractions
+ self.ignored
+ self.oversized
+ self.binary
+ self.unsupported
+ self.read_failed
+ self.not_processed
}
fn record(&mut self, outcome: Extraction) {
*match outcome {
Extraction::HashReused => &mut self.hash_reused,
Extraction::Symbols => &mut self.symbol_extractions,
Extraction::Ignored => &mut self.ignored,
Extraction::Oversized => &mut self.oversized,
Extraction::Binary => &mut self.binary,
Extraction::Unsupported => &mut self.unsupported,
Extraction::ReadFailed => &mut self.read_failed,
} += 1;
}
fn add(&mut self, other: Self) {
self.hash_reused += other.hash_reused;
self.symbol_extractions += other.symbol_extractions;
self.ignored += other.ignored;
self.oversized += other.oversized;
self.binary += other.binary;
self.unsupported += other.unsupported;
self.read_failed += other.read_failed;
self.not_processed += other.not_processed;
}
}
struct ScanCounts {
/// Files yielded by the filtered walker, not every file on disk.
discovered: usize,
/// Metadata matched an in-memory entry (possibly loaded from disk cache).
metadata_reused: usize,
scheduled: usize,
outcomes: ExtractionCounts,
}
#[cfg(test)]
mod metric_tests {
use super::*;
use std::sync::Arc;
fn index_files<'a>(index: &Shared, files: impl Iterator<Item = &'a Found>, force: bool) -> ExtractionCounts {
let files: Vec<_> = files
.map(|f| {
let hash = if force || f.ignored { None } else { index.data.read().get(&f.path).map(|e| e.hash) };
(f.clone(), hash)
})
.collect();
index.index_files(&files).outcomes
}
fn shared(root: &Path) -> Shared {
Shared::new(
PathFilter::new(root, &crate::IndexRoots::from(Vec::new()), &[]),
Arc::new(LanguageRegistry::load(None).unwrap()),
Arc::new(Syntax::new()),
Arc::new(ide_core::NullSink),
None,
)
}
#[test]
fn streaming_scan_counts_full_batch_and_tail() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let shared = shared(&root);
let count = SCAN_BATCH + 3;
for i in 0..count {
std::fs::write(root.join(format!("file_{i}.unknown")), "plain").unwrap();
}
let cold = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((cold.discovered, cold.metadata_reused, cold.scheduled), (count, 0, count));
assert_eq!(cold.outcomes, ExtractionCounts { unsupported: count, ..Default::default() });
assert_eq!(shared.data.read().file_count as usize, count);
let hot = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((hot.discovered, hot.metadata_reused, hot.scheduled), (count, count, 0));
assert_eq!(hot.outcomes.total(), 0);
}
#[test]
fn removed_entry_is_not_counted_as_hash_reuse() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let shared = shared(&root);
let path = root.join("main.rs");
std::fs::write(&path, "fn main() {}").unwrap();
shared.scan(None, None, SystemTime::now()).unwrap();
let (found, hash) = {
let data = shared.data.read();
let e = data.get(&path).unwrap();
(Found { path: path.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, e.hash)
};
let parsed = shared.parse_found(&found, Some(hash), &shared.filter()).unwrap();
shared.data.write().remove(&path).unwrap();
let counts = shared.publish(std::iter::once(parsed)).outcomes;
assert_eq!(counts, ExtractionCounts { not_processed: 1, ..Default::default() });
assert_eq!(shared.data.read().file_count, 0);
}
#[test]
fn scan_distinguishes_cold_metadata_and_hash_reuse() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let path = root.join("main.rs");
std::fs::write(&path, "fn main() {}\n").unwrap();
let shared = shared(&root);
let cold = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((cold.discovered, cold.metadata_reused, cold.scheduled), (1, 0, 1));
assert_eq!(cold.outcomes, ExtractionCounts { symbol_extractions: 1, ..Default::default() });
let hot = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((hot.discovered, hot.metadata_reused, hot.scheduled), (1, 1, 0));
assert_eq!(hot.outcomes, ExtractionCounts::default());
// Force a metadata mismatch without a timestamp-resolution-dependent sleep.
let mut rec = {
let data = shared.data.read();
data.record(data.get(&path).unwrap())
};
rec.mtime = rec.mtime.wrapping_add(1);
let (entry, symbols) = FileEntry::new(path.clone(), "main.rs".into(), rec);
shared.data.write().insert(entry, symbols);
let touched = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((touched.discovered, touched.metadata_reused, touched.scheduled), (1, 0, 1));
assert_eq!(touched.outcomes, ExtractionCounts { hash_reused: 1, ..Default::default() });
assert_eq!(shared.data.read().symbol_count, 1);
}
#[test]
fn extraction_outcomes_are_exclusive_and_forced_parsing_is_counted() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let shared = shared(&root);
let mut found = Vec::new();
for (name, contents, ignored, size) in [
("source.rs", "fn source() {}", false, 14),
("ignored.rs", "fn hidden() {}", true, 14),
("huge.rs", "", false, MAX_SYMBOL_FILE + 1),
("binary.rs", "\0", false, 1),
("plain.unknown", "plain", false, 5),
("missing.rs", "", false, 0),
] {
let path = root.join(name);
if name != "missing.rs" {
std::fs::write(&path, contents).unwrap();
}
found.push(Found { path, mtime: 0, size, ignored });
}
let counts = index_files(&shared, found.iter(), false);
assert_eq!(
counts,
ExtractionCounts {
symbol_extractions: 1,
ignored: 1,
oversized: 1,
binary: 1,
unsupported: 1,
read_failed: 1,
hash_reused: 0,
not_processed: 0,
}
);
assert_eq!(shared.data.read().file_count as usize, found.len());
assert_eq!(index_files(&shared, found[..1].iter(), false).hash_reused, 1);
assert_eq!(index_files(&shared, found[..1].iter(), true).symbol_extractions, 1);
}
#[test]
fn reopened_cache_counts_metadata_reuse() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let root = dunce::canonicalize(root).unwrap();
std::fs::write(root.join("main.rs"), "fn main() {}\n").unwrap();
let cache = dir.path().join("cache");
{
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
assert_eq!(index.scan(None, None, SystemTime::now()).unwrap().outcomes.symbol_extractions, 1);
}
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
let found = index.walk_roots(None);
index.load_persisted(&found);
let counts = index.scan(None, Some(found), SystemTime::now()).unwrap();
assert_eq!((counts.discovered, counts.metadata_reused, counts.scheduled), (1, 1, 0));
assert_eq!(counts.outcomes, ExtractionCounts::default());
assert_eq!(index.data.read().symbol_count, 1);
}
#[test]
fn warm_snapshot_hydrates_without_symbol_extraction() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let root = dunce::canonicalize(root).unwrap();
std::fs::write(root.join("main.rs"), "fn main() {}\n").unwrap();
let cache = dir.path().join("cache");
{
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
assert_eq!(index.scan(None, None, SystemTime::now()).unwrap().outcomes.symbol_extractions, 1);
}
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
assert!(index.try_fast_start());
assert_eq!(index.parsed.load(Ordering::Relaxed), 0);
assert_eq!(index.data.read().file_count, 1);
assert_eq!(index.data.read().symbol_count, 1);
}
#[test]
fn cancelled_warm_start_does_not_log_completion() {
struct CompletionCounter(Arc<std::sync::atomic::AtomicUsize>);
impl tracing::Subscriber for CompletionCounter {
fn enabled(&self, _: &tracing::Metadata<'_>) -> bool {
true
}
fn new_span(&self, _: &tracing::span::Attributes<'_>) -> tracing::span::Id {
tracing::span::Id::from_u64(1)
}
fn record(&self, _: &tracing::span::Id, _: &tracing::span::Record<'_>) {}
fn record_follows_from(&self, _: &tracing::span::Id, _: &tracing::span::Id) {}
fn enter(&self, _: &tracing::span::Id) {}
fn exit(&self, _: &tracing::span::Id) {}
fn event(&self, event: &tracing::Event<'_>) {
struct Message(bool);
impl tracing::field::Visit for Message {
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
if field.name() == "message" && format!("{value:?}").contains("index startup completed") {
self.0 = true;
}
}
}
let mut message = Message(false);
event.record(&mut message);
if message.0 {
self.0.fetch_add(1, Ordering::Relaxed);
}
}
}
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let root = dunce::canonicalize(root).unwrap();
std::fs::write(root.join("main.rs"), "fn main() {}\n").unwrap();
let cache = dir.path().join("cache");
{
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
index.scan(None, None, SystemTime::now()).unwrap();
}
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
let count = Arc::new(std::sync::atomic::AtomicUsize::new(0));
index.cancel();
tracing::subscriber::with_default(CompletionCounter(count.clone()), || {
tracing::info!("index startup completed");
assert_eq!(count.swap(0, Ordering::Relaxed), 1);
index.run(true);
});
assert_eq!(index.parsed.load(Ordering::Relaxed), 0);
assert_eq!(index.data.read().file_count, 1);
assert_eq!(count.load(Ordering::Relaxed), 0);
}
#[test]
fn files_outside_current_scope_and_cancelled_batches_are_accounted_for() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let index = shared(&root);
// A scan can retain Found values from a root removed by set_scope.
let outside = Found { path: dir.path().join("outside.rs"), mtime: 0, size: 0, ignored: false };
assert_eq!(
index_files(&index, [&outside].into_iter(), false),
ExtractionCounts { not_processed: 1, ..Default::default() }
);
index.cancel();
let inside = Found { path: root.join("inside.rs"), mtime: 0, size: 0, ignored: false };
assert_eq!(
index_files(&index, [&inside].into_iter(), false),
ExtractionCounts { not_processed: 1, ..Default::default() }
);
}
#[test]
fn cancellation_during_final_notifications_suppresses_completion() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
std::fs::write(root.join("source.rs"), "fn source() {}").unwrap();
let index: Arc<Shared> = Arc::new_cyclic(|weak: &std::sync::Weak<Shared>| {
let mut index = shared(&root);
let weak = weak.clone();
index.sink = Arc::new(move |event| {
if matches!(event, IdeEvent::Task { done: true, .. }) {
weak.upgrade().unwrap().cancel();
}
});
index
});
assert!(index.scan(None, None, SystemTime::now()).is_none());
assert!(index.is_cancelled());
assert!(!index.indexing.load(Ordering::Relaxed));
assert_eq!(index.data.read().file_count, 1);
}
#[test]
fn cancelled_scan_does_not_report_completion() {
let dir = tempfile::tempdir().unwrap();
let shared = shared(dir.path());
shared.cancel();
assert!(shared.scan(None, None, SystemTime::now()).is_none());
assert!(!shared.indexing.load(Ordering::Relaxed));
}
}
#[cfg(test)]
mod tests {
use crate::data::safe_rel;
+2 -3
Переглянути файл
@@ -406,14 +406,13 @@ impl Peer {
// would (`PATH` × `PATHEXT`, e.g. `codex` → `codex.cmd`) first.
let resolved = resolve_spawn_program(command, env);
let mut cmd = tokio::process::Command::new(&resolved);
// The working directory first: it picks the project's environment.
cmd.current_dir(cwd);
ide_core::process::prepare(cmd.as_std_mut());
// Wrappers (`npx`, `codex.cmd`, launcher scripts) start the real server as a child:
// stopping the connection stops the whole tree.
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.envs(ide_core::process::shell_env_in(cwd))
.current_dir(cwd)
.envs(ide_core::process::shell_env())
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.stdin(Stdio::piped())
.stdout(Stdio::piped())
-1
Переглянути файл
@@ -6,7 +6,6 @@ edition.workspace = true
license.workspace = true
[dependencies]
dunce.workspace = true
ide-core.workspace = true
ide-extension.workspace = true
ide-text.workspace = true
+1 -1
Переглянути файл
@@ -18,7 +18,7 @@ mod markers;
pub mod plugin_point;
mod registry;
mod syntax;
pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root, project_spelling};
pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root};
pub use plugin_point::PluginLanguages;
pub use registry::{FileTypes, LanguageRegistry};
pub use syntax::{
-15
Переглянути файл
@@ -2,23 +2,8 @@
//! framework's project there (`Cargo.toml`, `angular.json`). Language server
//! roots (`root-markers`) and framework modes (`framework-ui-modes`) share them.
use std::borrow::Cow;
use std::path::{Path, PathBuf};
/// `path` as the project's roots spell it, `inside` telling whether a path is
/// under one. Roots are canonical, while a file can arrive under another
/// spelling (other letter case on macOS, a symlinked folder) and would look
/// outside the project, missing its frameworks' markers.
pub fn project_spelling<'a>(path: &'a Path, inside: impl Fn(&Path) -> bool) -> Cow<'a, Path> {
if inside(path) {
return path.into();
}
match dunce::canonicalize(path) {
Ok(canonical) if inside(&canonical) => canonical.into(),
_ => path.into(),
}
}
/// The outermost ancestor of `file` containing a root marker, within
/// `project_root` (any ancestor without one: loose files). A directory counts
/// as its own ancestor: a module folder is served like the files in it.
-35
Переглянути файл
@@ -90,7 +90,6 @@ const BUILTIN: &[(&str, &str)] = &[
("toml", include_str!("../../../languages/toml.toml")),
("typescript", include_str!("../../../languages/typescript.toml")),
("typescriptreact", include_str!("../../../languages/typescriptreact.toml")),
("typst", include_str!("../../../languages/typst.toml")),
("vue", include_str!("../../../languages/vue.toml")),
("xml", include_str!("../../../languages/xml.toml")),
("yaml", include_str!("../../../languages/yaml.toml")),
@@ -371,7 +370,6 @@ impl LanguageRegistry {
pub fn framework_ui_mode(&self, language: &LanguageId, path: &Path, project_root: Option<&Path>) -> Option<String> {
let state = self.state();
let cfg = state.languages.iter().find(|l| &l.id == language)?;
let path = &*crate::project_spelling(path, |p| project_root.is_none_or(|root| p.starts_with(root)));
cfg.framework_ui_modes
.iter()
.find(|f| crate::marked_root(project_root, path, &f.root_markers).is_some())
@@ -614,7 +612,6 @@ mod tests {
"TTCN",
"TTCN_CFG",
"Turtle",
"Typst",
"Web IDL",
"VB.NET",
"VBScript",
@@ -929,38 +926,6 @@ mod tests {
assert_eq!(detect("pages/promo.html"), "html");
}
/// #4061: the project root is canonical; a template reached under another
/// spelling of it is still the project's.
#[test]
fn templates_spelt_differently_from_the_project_use_framework_modes() {
let reg = reg();
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("Develop/shop");
std::fs::create_dir_all(root.join("node_modules/@angular/core")).unwrap();
let template = root.join("apps/myapp/src/app/example.component.html");
std::fs::create_dir_all(template.parent().unwrap()).unwrap();
std::fs::write(&template, "<button (click)=\"onConfirm()\">Confirm</button>\n").unwrap();
let mode = |path: &Path| reg.framework_ui_mode(&LanguageId::new("html"), path, Some(&root));
let links = tempfile::tempdir().unwrap();
let mut spellings = Vec::new();
#[cfg(unix)]
{
std::os::unix::fs::symlink(&root, links.path().join("shop")).unwrap();
spellings.push(links.path().join("shop").join(template.strip_prefix(&root).unwrap()));
}
// Only on a case-insensitive disk (macOS, Windows): `develop` for `Develop`.
let lower = PathBuf::from(template.to_string_lossy().replace("Develop", "develop"));
if lower.exists() {
spellings.push(lower);
}
for path in &spellings {
assert_eq!(mode(path).as_deref(), Some("Angular Template"), "{}", path.display());
}
// Still nothing for files that are elsewhere under every spelling.
std::fs::create_dir_all(links.path().join("other")).unwrap();
assert_eq!(mode(&links.path().join("other/index.html")), None);
}
#[test]
fn markers_outside_the_project_do_not_make_angular_templates() {
let reg = reg();
+3 -4
Переглянути файл
@@ -6,8 +6,8 @@
//! parse instead of a full one.
use super::{
Grammar, MAX_PARSE_BYTES, ParsedTree, Syntax, SyntaxHighlights, TreeError, highlight, outline, parse_cancellable,
selection,
Grammar, MAX_PARSE_BYTES, ParsedTree, Syntax, SyntaxHighlights, TreeError, folding, highlight, outline,
parse_cancellable, selection,
};
use crate::FoldRange;
use ide_core::{DocId, LanguageId, OutlineItem, Range};
@@ -219,10 +219,9 @@ impl SyntaxCache {
|m| &mut m.folding,
|| {
self.with_tree(doc, lang, version, text, |g, tree, text| {
Some(self.syntax.folding_with_scripts(g, tree, text, lang))
Some(folding::folding(g.spec, g.kinds(), tree, text, self.syntax.comment_tokens(lang)))
})
.or_else(|| super::external::folding(lang, text))
.or_else(|| self.syntax.web_folding(lang, text))
.or_else(|| Some(self.syntax.custom_folding(lang, text)))
},
)
-68
Переглянути файл
@@ -118,16 +118,6 @@ pub(super) fn folding(
});
return true;
}
// Some languages write documentation as a string-like node rather than a
// lexical comment (Python docstrings, Elixir `@doc` / `@moduledoc`). The
// generic comment pass above never sees those, so fold them as documentation.
if node.is_named()
&& start != end
&& let Some(fold) = docstring_fold(spec, &node, kinds, text)
{
out.push(fold);
return false;
}
if start != end && !spec.imports.is_empty() && node.named_child_count() > 1 {
import_runs(kinds, node, text, &mut out);
}
@@ -216,64 +206,6 @@ pub(crate) fn is_comment(kind: &str) -> bool {
kind.contains("comment") || kind == "Comment"
}
/// Folds a documentation string written as a non-comment node. Returns `None`
/// for every other node; the caller skips its subtree only on a match.
fn docstring_fold(spec: &Spec, node: &Node, kinds: &KindTable, text: &str) -> Option<FoldRange> {
let multi_line = |n: &Node| n.start_position().row != n.end_position().row && kinds.has(n, FOLD_NODE);
let range = |n: &Node| FoldRange {
start_line: n.start_position().row as u32,
end_line: last_content_row(n, text) as u32,
kind: FoldKind::Comment,
};
match spec.name {
// A bare string as the first statement of a module/class/function body.
"python" if node.kind() == "expression_statement" => {
let string = node.named_child(0)?;
if string.kind() != "string" || !multi_line(&string) {
return None;
}
let parent = node.parent()?;
let mut cursor = parent.walk();
if parent.named_children(&mut cursor).find(|c| !kinds.has(c, COMMENT)) != Some(*node) {
return None;
}
Some(range(node))
}
// `@doc """…"""` / `@moduledoc """…"""`: an @-prefixed call whose
// argument is a multi-line string (or a sigil like `~S"""`).
"elixir" if node.kind() == "unary_operator" => {
let operand = node.child_by_field_name("operand")?;
if operand.kind() != "call" || !is_elixir_doc_attr(operand, text) {
return None;
}
// The string is the argument of the attribute call: `@doc """…"""`
// parses as unary_operator -> call(target: doc) -> arguments -> string.
let mut cursor = operand.walk();
let doc_string =
operand.named_children(&mut cursor).find(|c| c.kind() == "arguments").and_then(|args| {
let mut args_cursor = args.walk();
args.named_children(&mut args_cursor).find(|c| multi_line(c))
})?;
if !matches!(doc_string.kind(), "string" | "sigil") {
return None;
}
Some(range(&doc_string))
}
_ => None,
}
}
/// Whether an Elixir `call` is `@doc` / `@moduledoc` / `@typedoc` (the documented
/// attributes that take a string argument).
fn is_elixir_doc_attr(call: Node, text: &str) -> bool {
let Some(target) = call.child_by_field_name("target") else { return false };
let name = text.get(target.byte_range()).unwrap_or_default();
if target.kind() != "identifier" {
return false;
}
matches!(name, "doc" | "moduledoc" | "typedoc")
}
/// Row of the closing token when `node` is delimited by a matching bracket pair.
pub(crate) fn bracket_pair<'t>(node: &Node<'t>) -> Option<(Node<'t>, Node<'t>)> {
let count = node.child_count();
+2 -29
Переглянути файл
@@ -190,38 +190,11 @@ impl Syntax {
}
pub fn folding(&self, lang: &LanguageId, text: &str) -> Vec<FoldRange> {
self.web_folding(lang, text)
.or_else(|| self.analyze(lang, text, |g, tree, text| Some(self.folding_with_scripts(g, tree, text, lang))))
let tokens = self.comment_tokens(lang);
self.analyze(lang, text, |g, tree, text| Some(folding::folding(g.spec, g.kinds(), tree, text, tokens)))
.unwrap_or_else(|| self.custom_folding(lang, text))
}
pub(crate) fn web_folding(&self, lang: &LanguageId, text: &str) -> Option<Vec<FoldRange>> {
let g = self.web_grammar(lang)?;
if g.spec.name != "html" || text.len() > MAX_PARSE_BYTES {
return None;
}
let tree = parse(&g.language, text, None)?;
Some(self.folding_with_scripts(g, &tree, text, lang))
}
fn folding_with_scripts(&self, g: &Grammar, tree: &Tree, text: &str, lang: &LanguageId) -> Vec<FoldRange> {
let mut folds = folding::folding(g.spec, g.kinds(), tree, text, self.comment_tokens(lang));
if g.spec.name == "html" {
let lines = lines::LineIndex::new(text);
for region in sfc::script_regions(tree, text) {
let base_line = lines.line_of(region.base) as u32;
folds.extend(self.folding(&region.language, &region.text).into_iter().map(|mut fold| {
fold.start_line += base_line;
fold.end_line += base_line;
fold
}));
}
folds.sort_by(|a, b| a.start_line.cmp(&b.start_line).then(b.end_line.cmp(&a.end_line)));
folds.dedup_by_key(|f| f.start_line);
}
folds
}
fn comment_tokens(&self, lang: &LanguageId) -> &folding::CommentTokens {
static EMPTY: OnceLock<folding::CommentTokens> = OnceLock::new();
self.comments.get(lang.as_str()).unwrap_or_else(|| EMPTY.get_or_init(Default::default))
-93
Переглянути файл
@@ -987,28 +987,6 @@ fn folding_typescript_import_run_ending_with_multiline_import() {
assert!(folds("typescript", src).contains(&(0, 4, FoldKind::Imports)));
}
#[test]
fn folding_script_imports_in_web_containers() {
use ide_core::DocId;
use std::sync::Arc;
let src = "<template><div/></template>\n<script setup lang=\"ts\">\nimport { ref, normalizeStyle } from 'vue'\nimport { Button, CheckableTagGroup, Divider, Space } from 'antdv-next'\n</script>\n";
let cache = SyntaxCache::new(Arc::new(Syntax::new()));
for id in ["vue", "html", "svelte", "jsp"] {
let expected = (2, 3, FoldKind::Imports);
assert!(folds(id, src).contains(&expected), "{id}");
let doc = DocId::next();
cache.open(doc, &lang(id), 0);
let cached = cache.folding(doc, &lang(id), 0, src);
assert!(cached.iter().any(|f| (f.start_line, f.end_line, f.kind) == expected), "{id}");
}
let js = "<script>\r\nimport a from 'a'\r\nimport b from 'b'\r\n</script>\r\n";
assert!(folds("vue", js).contains(&(1, 2, FoldKind::Imports)));
let json = "<script type=\"application/json\">\nimport a from 'a'\nimport b from 'b'\n</script>\n";
assert!(!folds("vue", json).iter().any(|f| f.2 == FoldKind::Imports));
}
#[test]
fn folding_xml_custom_regions() {
for (start, end) in [
@@ -1103,77 +1081,6 @@ fn folding_python_bodies_start_at_header() {
);
}
#[test]
fn folding_python_docstrings_are_comments() {
let src = r#""""Module doc.
More.
"""
class A:
"""Class doc.
More.
"""
def f(self):
"""Method doc.
More.
"""
return 1
"#;
assert_eq!(
folds("python", src),
vec![
(0, 2, FoldKind::Comment),
(4, 12, FoldKind::Region),
(5, 7, FoldKind::Comment),
(8, 12, FoldKind::Region),
(9, 11, FoldKind::Comment),
]
);
}
#[test]
fn folding_python_single_line_or_later_strings_are_not_docstrings() {
// A one-line docstring has nothing to fold; a multi-line string that is not
// the opening statement stays an ordinary string fold, not a doc comment.
let src = r#"x = 1
"""Later string.
Still later.
"""
def f():
"""One line."""
return 1
"#;
let found = folds("python", src);
assert!(!found.contains(&(1, 3, FoldKind::Comment)), "later string must not be a doc comment: {found:?}");
assert!(found.contains(&(1, 3, FoldKind::Region)), "later string still folds as a string: {found:?}");
assert!(!found.iter().any(|f| f.2 == FoldKind::Comment), "single-line docstring has no fold: {found:?}");
}
#[test]
fn folding_elixir_doc_strings_are_comments() {
let src = r#"defmodule Foo do
@moduledoc """
Module doc.
More.
"""
@doc ~S"""
Function doc.
More.
"""
def bar, do: :ok
@doc "one line"
def baz, do: :ok
end
"#;
assert_eq!(
folds("elixir", src),
vec![(0, 14, FoldKind::Region), (1, 4, FoldKind::Comment), (6, 9, FoldKind::Comment),]
);
}
#[test]
fn folding_data_and_markup() {
assert_eq!(
-2
Переглянути файл
@@ -1032,7 +1032,6 @@ pub fn call_item(conv: &Conv, item: &lsp::CallHierarchyItem, from_ranges: Vec<Ra
path: path.into(),
uri,
from_ranges,
from_path: None,
})
}
@@ -1057,7 +1056,6 @@ pub fn type_item(conv: &Conv, item: &lsp::TypeHierarchyItem) -> Option<Hierarchy
path: path.into(),
uri,
from_ranges: Vec::new(),
from_path: None,
})
}
+6 -47
Переглянути файл
@@ -7,7 +7,6 @@
use crate::LspManager;
use crate::server::Server;
use ide_core::{CancellationToken, DocId, Pos, Range};
use ide_language::LanguageServerConfig;
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
@@ -126,10 +125,10 @@ impl LspManager {
return;
}
let config = server.effective_config();
let search = crate::launch::server_search_path(&config, &server.root);
let search = crate::launch::server_search_path(&config);
let Some(dir) = path.parent().map(Path::to_path_buf) else { return };
let modules: Vec<String> = required.iter().map(|r| r.path.clone()).collect();
let Some(deprecated) = list_deprecations(&dir, &config, &search, &modules, cancel).await else { return };
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
// The document changed meanwhile: its own save runs again.
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
return;
@@ -209,15 +208,16 @@ struct ListedModule {
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
async fn list_deprecations(
dir: &Path,
config: &LanguageServerConfig,
search: &std::ffi::OsStr,
modules: &[String],
cancel: &CancellationToken,
) -> Option<Vec<(String, String)>> {
let (dir, config, search, modules) = (dir.to_path_buf(), config.clone(), search.to_owned(), modules.to_vec());
let (dir, search, modules) = (dir.to_path_buf(), search.to_owned(), modules.to_vec());
let command = tokio::task::spawn_blocking(move || {
let go: PathBuf = ide_core::tool_path::find_command("go", &search, &dir)?;
Some(deprecations_command(&go, &dir, &config, &search, &modules))
let mut command = Command::new(go);
command.args(["list", "-m", "-u", "-e", "-json"]).args(modules).current_dir(dir).env("PATH", search);
Some(command)
})
.await
.ok()??;
@@ -228,23 +228,6 @@ async fn list_deprecations(
tokio::task::spawn_blocking(move || parse_deprecations(&output)).await.ok()
}
fn deprecations_command(
go: &Path,
dir: &Path,
config: &LanguageServerConfig,
search: &std::ffi::OsStr,
modules: &[String],
) -> Command {
let mut command = Command::new(go);
command
.args(["list", "-m", "-u", "-e", "-json"])
.args(modules)
.current_dir(dir)
.envs(&config.env)
.env("PATH", search);
command
}
async fn run_query(command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
let cancel = cancel.child_token();
let _cancel_on_drop = cancel.clone().drop_guard();
@@ -331,30 +314,6 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
mod tests {
use super::*;
#[test]
fn deprecation_command_inherits_server_environment() {
let config: LanguageServerConfig = serde_json::from_value(serde_json::json!({
"name": "gopls", "command": "gopls", "env": {
"PATH": "selected-toolchain", "GOPROXY": "off", "GOPRIVATE": "example.invalid/*",
"GOTOOLCHAIN": "local", "GOWORK": "off"
}
}))
.unwrap();
let command = deprecations_command(
Path::new("go"),
Path::new("workspace"),
&config,
&crate::launch::server_search_path(&config, Path::new("workspace")),
&["example.invalid/lib".into()],
);
let env: std::collections::BTreeMap<_, _> = command.get_envs().collect();
for (key, value) in &config.env {
assert_eq!(env.get(std::ffi::OsStr::new(key)), Some(&Some(std::ffi::OsStr::new(value))), "missing {key}");
}
assert_eq!(command.get_current_dir(), Some(Path::new("workspace")));
assert_eq!(command.get_args().collect::<Vec<_>>(), ["list", "-m", "-u", "-e", "-json", "example.invalid/lib"]);
}
#[test]
fn queries_cancel_only_the_superseded_document() {
let mut queries = Queries::default();
+5 -5
Переглянути файл
@@ -527,7 +527,7 @@ impl Handler for ClientHandler {
"window/logMessage" => {
let text = params.get("message").and_then(Value::as_str).unwrap_or_default();
if self.server.config.tsserver_project && tsserver_ran_out_of_memory(text) {
tracing::warn!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name);
tracing::warn!("[{}] {text}", self.server.name);
// The tasks of the dead tsserver never see their `end`: end them now
// instead of letting them sit as zombies until the stale window, and
// stop holding queries back — the restarted instance re-reports.
@@ -554,12 +554,12 @@ impl Handler for ClientHandler {
}
match params.get("type").and_then(Value::as_u64) {
Some(1) if self.server.name == "jdtls" && text.contains(crate::jdtls::reserved_names::IMPORT_FAILURE) => {
tracing::warn!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name);
tracing::warn!("[{}] {text}", self.server.name);
mgr.report_import_failure(self.server.root.clone(), text.to_owned());
}
Some(1) => tracing::warn!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name),
Some(2 | 3) => tracing::info!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name),
_ => tracing::debug!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name),
Some(1) => tracing::warn!("[{}] {text}", self.server.name),
Some(2 | 3) => tracing::info!("[{}] {text}", self.server.name),
_ => tracing::debug!("[{}] {text}", self.server.name),
}
}
"tsserver/request" => mgr.forward_tsserver_requests(self.server.clone(), self.generation, params),
-1
Переглянути файл
@@ -88,7 +88,6 @@ impl LspManager {
/// for `path` (by file name). Missing servers are not started, so a batch
/// run doesn't prompt to install every language it meets.
pub fn serves_path(&self, path: &Path) -> bool {
let path = &*self.in_project_spelling(path);
let lang = self.languages.detect(path, None);
let arduino = if lang.as_str() == "arduino" {
Some(self.servers_for(&lang, path))
+15 -43
Переглянути файл
@@ -1,7 +1,7 @@
//! Starting server processes: binary resolution and the [`Launcher`] seam.
use ide_core::CancellationToken;
use ide_core::tool_path::search_path_in;
use ide_core::tool_path::search_path;
use ide_jsonrpc::{Handler, Peer};
use ide_language::LanguageServerConfig;
use std::ffi::{OsStr, OsString};
@@ -95,10 +95,10 @@ impl Launcher for ProcessLauncher {
on_stderr: Box<dyn Fn(String) + Send + Sync>,
cancel: &CancellationToken,
) -> Result<(Peer, Option<PathBuf>), LaunchError> {
if !required_env_set(config, root) {
if !required_env_set(config) {
return Err(LaunchError::Missing);
}
let search = server_search_path(config, root);
let search = server_search_path(config);
let binary = match &config.pinned {
// A plugin's server: the approved program, unchanged since.
Some(pin) => Some(pin.verify().map_err(LaunchError::Failed)?.to_path_buf()),
@@ -128,27 +128,26 @@ impl Launcher for ProcessLauncher {
}
fn available(&self, config: &LanguageServerConfig, root: &Path) -> bool {
if !required_env_set(config, root) {
if !required_env_set(config) {
return false;
}
if let Some(pin) = &config.pinned {
return pin.path.is_file();
}
ide_core::tool_path::find_command(&config.command, &server_search_path(config, root), root).is_some()
ide_core::tool_path::find_command(&config.command, &server_search_path(config), root).is_some()
}
}
fn required_env_set(config: &LanguageServerConfig, root: &Path) -> bool {
fn required_env_set(config: &LanguageServerConfig) -> bool {
config.requires_env.iter().all(|key| match config.env.get(key) {
Some(value) => !value.is_empty(),
None => ide_core::process::host_var_os_in(root, key).is_some_and(|v| !v.is_empty()),
None => ide_core::process::host_var_os(key).is_some_and(|v| !v.is_empty()),
})
}
/// A configured `PATH` (e.g. a selected toolchain prepended) also resolves the binary; else
/// the project's (a Nix devshell's language servers), then the IDE's.
pub(crate) fn server_search_path(config: &LanguageServerConfig, root: &Path) -> OsString {
config.env.get("PATH").map(OsString::from).unwrap_or_else(|| search_path_in(root))
/// A configured `PATH` (e.g. a selected toolchain prepended) also resolves the binary.
pub(crate) fn server_search_path(config: &LanguageServerConfig) -> OsString {
config.env.get("PATH").map(OsString::from).unwrap_or_else(search_path)
}
/// What a version manager's shim says when the active version has no such tool.
@@ -163,8 +162,9 @@ fn reject_dead_shim(binary: PathBuf, search: &OsStr, root: &Path) -> Option<Path
if !binary.parent().is_some_and(|d| d.file_name().is_some_and(|n| n == "shims")) {
return Some(binary);
}
let Ok(mut child) = ide_core::process::prepare(std::process::Command::new(&binary).current_dir(root))
let Ok(mut child) = ide_core::process::prepare(&mut std::process::Command::new(&binary))
.arg("--version")
.current_dir(root)
.env("PATH", search)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
@@ -235,8 +235,9 @@ fn resolve_rustup_proxy(command: &str, binary: PathBuf, root: &Path) -> Option<P
/// Whether the proxy runs for the toolchain active in `root`. A probe that hangs or can't
/// be waited for counts as working: the real start decides.
fn proxy_works(binary: &Path, root: &Path) -> bool {
let Ok(mut child) = ide_core::process::prepare(std::process::Command::new(binary).current_dir(root))
let Ok(mut child) = ide_core::process::prepare(&mut std::process::Command::new(binary))
.arg("--version")
.current_dir(root)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
@@ -347,35 +348,6 @@ mod tests {
assert_eq!(reject_dead_shim(plain.clone(), &search, tmp.path()), Some(plain));
}
#[cfg(unix)]
#[test]
fn servers_from_the_project_environment_are_found() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("project");
let devshell = tmp.path().join("nix-store-devshell/bin");
std::fs::create_dir_all(&devshell).unwrap();
std::fs::create_dir_all(&root).unwrap();
let server = devshell.join("openidea-test-nil");
std::fs::write(&server, "#!/bin/sh\n").unwrap();
std::fs::set_permissions(&server, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut config: LanguageServerConfig =
toml::from_str("name = \"nil\"\ncommand = \"openidea-test-nil\"").unwrap();
config.requires_env = vec!["OPENIDEA_TEST_IN_DEVSHELL".into()];
assert!(!ProcessLauncher.available(&config, &root));
ide_core::project_env::set(
&root,
vec![
("PATH".into(), Some(devshell.clone().into_os_string())),
("OPENIDEA_TEST_IN_DEVSHELL".into(), Some("1".into())),
],
);
assert!(ProcessLauncher.available(&config, &root));
assert_eq!(std::env::split_paths(&server_search_path(&config, &root)).next(), Some(devshell));
ide_core::project_env::remove(&root);
assert!(!ProcessLauncher.available(&config, &root));
}
#[test]
fn marked_root_needs_a_marker() {
let tmp = tempfile::tempdir().unwrap();
@@ -409,7 +381,7 @@ mod tests {
#[test]
fn search_path_contains_env_path() {
let p = ide_core::tool_path::search_path();
let p = search_path();
let dirs: Vec<PathBuf> = std::env::split_paths(&p).collect();
// The process's own `PATH` starts the search, then per-user and system dirs.
let first_env = std::env::split_paths(&std::env::var_os("PATH").unwrap()).find(|d| d.is_absolute()).unwrap();
+4 -103
Переглянути файл
@@ -649,11 +649,6 @@ impl LspManager {
.unwrap_or_else(|| self.project_root.clone())
}
/// `path` as the project's roots spell it ([`ide_language::project_spelling`]).
fn in_project_spelling<'a>(&self, path: &'a Path) -> std::borrow::Cow<'a, Path> {
ide_language::project_spelling(path, |p| p.starts_with(self.project_root_for(p)))
}
fn server_for(&self, cfg: &LanguageServerConfig, language: &LanguageId, path: &Path) -> Arc<Server> {
let shared = is_local_jdtls(cfg).then(|| self.jdtls_workspace_state());
let mut servers = self.servers.lock();
@@ -675,25 +670,10 @@ impl LspManager {
})
};
if let Some(s) = servers.iter().find(|s| s.name == cfg.name && s.root == root) {
if !path.starts_with(&project) {
tracing::debug!(
server = ?s.id,
name = %s.name,
root = %s.root.display(),
"reusing language server for external file"
);
}
s.add_language(language);
return s.clone();
}
let server = Arc::new(Server::new(cfg.clone(), root, language.clone()));
tracing::debug!(
server = ?server.id,
name = %server.name,
root = %server.root.display(),
external = !path.starts_with(&project),
"created language server route"
);
servers.push(server.clone());
server
}
@@ -704,7 +684,6 @@ impl LspManager {
/// only files below one, and stands in for no other. One that a server before
/// it `replaces` is left out while that server serves the file.
fn servers_for(&self, language: &LanguageId, path: &Path) -> Vec<Arc<Server>> {
let path = &*self.in_project_spelling(path);
if let Some(servers) = self.arduino_servers(language, path) {
return servers;
}
@@ -849,9 +828,6 @@ impl LspManager {
async fn run_instance(self: Arc<Self>, server: Arc<Server>, generation: u64) {
let Some(cancel) = server.starting_status(generation, &self.sink) else { return };
// Includes settings/prepare, blocking-pool queueing, launch and initialize.
let started = std::time::Instant::now();
tracing::info!(server = ?server.id, generation, name = %server.name, "starting language server");
let handler = Arc::new(handler::ClientHandler::new(self.me.clone(), server.clone(), generation));
let me = self.clone();
let tail = server.clone();
@@ -859,9 +835,6 @@ impl LspManager {
// The settings hook may touch the filesystem (e.g. scanning for JDKs); TCP
// servers may take a while to start listening.
let launched = tokio::task::spawn_blocking(move || {
// The project's direnv environment (a Nix devshell) may hold the server and its
// toolchain: start once it has loaded.
ide_core::project_env::wait(&tail.root, &launch_cancel);
if !me.execution_allowed.load(Ordering::Acquire) {
return Err(LaunchError::Config("Project is in Restricted Mode".into()));
}
@@ -973,15 +946,8 @@ impl LspManager {
};
let caps = match result {
Ok(result) => {
tracing::info!(
server = ?server.id,
generation,
name = %server.name,
startup_to_initialize_ms = started.elapsed().as_millis() as u64,
"language server initialized"
);
if let Some(info) = result.get("serverInfo") {
tracing::info!(server = ?server.id, generation, "{} initialized: {info}", server.name);
tracing::info!("{} initialized: {info}", server.name);
}
let mut caps_val = result.get("capabilities").cloned().unwrap_or_else(|| json!({}));
if server.name == arduino::SERVER {
@@ -3275,7 +3241,6 @@ impl LspManager {
.call(t, "textDocument/prepareCallHierarchy", snap.pos_params(t, pos), Some(cancel), DEFAULT_TIMEOUT)
.await?;
let items = items.filter(|i| !i.is_empty()).ok_or_else(no_hierarchy_target)?;
let root = convert::call_item(&self.conv(t.enc()), &items[0], Vec::new());
let query = || async {
let mut out = Vec::new();
for item in &items {
@@ -3298,10 +3263,7 @@ impl LspManager {
let (src, _) = uri_target(item.uri.as_str());
for c in calls.unwrap_or_default() {
let ranges = c.from_ranges.iter().map(|r| conv.range(&src, *r)).collect();
out.extend(
convert::call_item(&conv, &c.to, ranges)
.map(|to| HierarchyItem { from_path: Some(src.clone().into()), ..to }),
);
out.extend(convert::call_item(&conv, &c.to, ranges));
}
}
}
@@ -3331,8 +3293,8 @@ impl LspManager {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
self.note_virtual(&t.server, out.iter().chain(&root).map(|i| i.uri.as_deref()));
Ok(CallHierarchy { root, items: out, incomplete })
self.note_virtual(&t.server, out.iter().map(|i| i.uri.as_deref()));
Ok(CallHierarchy { items: out, incomplete })
}
/// The type at `pos` as the server's type hierarchy names it (with its `detail`, the
@@ -4302,64 +4264,3 @@ mod code_action_tests {
assert!(!source_actions_only(&kinds(&["sourcefoo"])));
}
}
#[cfg(test)]
mod external_go_routing_tests {
use super::*;
fn manager(root: &Path) -> Arc<LspManager> {
LspManager::new(
root.to_owned(),
Arc::new(LanguageRegistry::load(None).unwrap()),
Arc::new(|_: ide_core::IdeEvent| {}),
)
}
fn route(manager: &LspManager, path: &Path) -> Arc<Server> {
let language = LanguageId::new("go");
let config = manager.languages.get(&language).unwrap();
manager.server_for(&config.language_servers[0], &language, path)
}
fn module(root: &Path, name: &str) -> PathBuf {
let root = root.join(name);
std::fs::create_dir_all(&root).unwrap();
std::fs::write(root.join("go.mod"), format!("module example.test/{name}\n")).unwrap();
root.join("main.go")
}
// Characterize the fallback, not a promise that this is the correct consumer
// context for a shared dependency. No gopls process is launched in these tests.
#[tokio::test]
async fn external_go_file_reuses_first_module_without_creating_another_server() {
let workspace = tempfile::tempdir().unwrap();
let cache = tempfile::tempdir().unwrap();
let a = module(workspace.path(), "a");
let b = module(workspace.path(), "b");
let dependency = cache.path().join("dependency.go");
for order in [[&a, &b], [&b, &a]] {
let manager = manager(workspace.path());
let first = route(&manager, order[0]);
let second = route(&manager, order[1]);
assert_ne!(first.id, second.id);
assert_eq!(route(&manager, &dependency).id, first.id);
assert_eq!(route(&manager, &dependency).id, first.id);
assert_eq!(manager.servers.lock().len(), 2);
}
}
#[tokio::test]
async fn external_go_file_restored_first_keeps_project_root_fallback() {
let workspace = tempfile::tempdir().unwrap();
let cache = tempfile::tempdir().unwrap();
let a = module(workspace.path(), "a");
let dependency = cache.path().join("dependency.go");
let manager = manager(workspace.path());
let restored = route(&manager, &dependency);
assert_eq!(restored.root, workspace.path());
let consumer = route(&manager, &a);
assert_ne!(restored.id, consumer.id);
assert_eq!(route(&manager, &dependency).id, restored.id);
assert_eq!(manager.servers.lock().len(), 2);
}
}
-1
Переглянути файл
@@ -397,7 +397,6 @@ impl LspManager {
range: *r,
selection_range: *selection,
from_ranges: vec![*call],
from_path: None,
}),
}
}
+1 -1
Переглянути файл
@@ -94,9 +94,9 @@ pub(crate) fn connect_or_start(
let args = substitute_args(&config.args, port, root);
let mut cmd = tokio::process::Command::new(binary);
cmd.current_dir(root);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(&args)
.current_dir(root)
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::piped())
-9
Переглянути файл
@@ -329,11 +329,6 @@ pub struct HierarchyItem {
pub selection_range: Range,
/// Call sites, for call hierarchy.
pub from_ranges: Vec<Range>,
/// The file of `from_ranges` when it is not the item's own: for an outgoing call, the
/// file of the prepared item that makes it (a path, or the URI of a virtual document).
#[serde(default)]
#[specta(optional)]
pub from_path: Option<ide_core::IpcPath>,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
@@ -580,10 +575,6 @@ pub struct ServerRefactored {
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CallHierarchy {
/// The symbol the hierarchy is for: the first item the server prepared at the position.
#[serde(default)]
#[specta(optional)]
pub root: Option<HierarchyItem>,
pub items: Vec<HierarchyItem>,
pub incomplete: Option<ReferencesIncomplete>,
}
+10 -126
Переглянути файл
@@ -23,7 +23,6 @@ use std::time::Duration;
struct MockState {
caps: Mutex<Value>,
missing: std::sync::atomic::AtomicBool,
omit_server_info: std::sync::atomic::AtomicBool,
binary: Mutex<Option<PathBuf>>,
launches: AtomicUsize,
notifications: Mutex<Vec<(String, Value)>>,
@@ -150,11 +149,7 @@ impl Handler for MockHandler {
if let Some(error) = s.errors.lock().get("initialize").cloned() {
return Err(error);
}
let mut result = json!({ "capabilities": s.caps.lock().clone() });
if !s.omit_server_info.load(Ordering::SeqCst) {
result["serverInfo"] = json!({ "name": "mock" });
}
Ok(result)
Ok(json!({ "capabilities": s.caps.lock().clone(), "serverInfo": { "name": "mock" } }))
}
"shutdown" => Ok(Value::Null),
_ => {
@@ -483,23 +478,6 @@ async fn dart_file_watching_requires_an_explicit_registration() {
// ------------------------------------------------------------------ tests
#[tokio::test(flavor = "multi_thread")]
async fn servers_start_once_the_project_environment_has_loaded() {
let h = harness(&[("mock", incremental_caps())]);
// The project's direnv environment (a Nix devshell) is still being read.
ide_core::project_env::begin_loading(&h.root);
h.open("a.mk", "x");
h.wait_status("mock", ServerStatus::Starting).await;
tokio::time::sleep(Duration::from_millis(300)).await;
let server = h.launcher.state("mock");
assert_eq!(server.launches.load(Ordering::SeqCst), 0);
ide_core::project_env::set(&h.root, vec![("OPENIDEA_TEST_DEVSHELL".into(), Some("1".into()))]);
h.wait_status("mock", ServerStatus::Ready).await;
assert_eq!(server.launches.load(Ordering::SeqCst), 1);
ide_core::project_env::remove(&h.root);
h.mgr.shutdown_all().await;
}
#[tokio::test(flavor = "multi_thread")]
async fn linked_projects_initialize_separate_language_server_roots() {
let h = harness(&[("mock", incremental_caps())]);
@@ -3005,13 +2983,13 @@ async fn a_project_update_attaches_maven_generated_sources_before_rechecking() {
.as_array()
.unwrap()
.iter()
.map(|arg| (PathBuf::from(arg["path"].as_str().unwrap()), arg["test"].as_bool().unwrap()))
.map(|arg| (arg["path"].as_str().unwrap().to_owned(), arg["test"].as_bool().unwrap()))
.collect();
assert_eq!(
paths,
vec![
(h.root.join("target/generated-sources/protobuf/grpc-java"), false),
(h.root.join("target/generated-sources/protobuf/java"), false),
(h.root.join("target/generated-sources/protobuf/grpc-java").to_string_lossy().into_owned(), false),
(h.root.join("target/generated-sources/protobuf/java").to_string_lossy().into_owned(), false),
]
);
}
@@ -3633,52 +3611,6 @@ async fn a_server_requiring_a_root_marker_serves_only_files_below_one() {
h.wait_status("alt", ServerStatus::Ready).await;
}
/// #4061: an Angular template opened under another spelling of the project's
/// (canonical) path, other letter case on macOS or a symlinked folder, still
/// gets the Angular server, which answers hover and Go to Declaration there.
#[tokio::test(flavor = "multi_thread")]
async fn a_framework_server_serves_files_spelt_differently_from_the_project() {
let h = harness_configured("mock", "html", &[("framework", incremental_caps())], |cfg| {
cfg.root_markers = vec!["angular.json".into()];
cfg.require_root_marker = true;
});
std::fs::write(h.root.join("angular.json"), "{}").unwrap();
let app = h.root.join("apps/myapp/src/app");
std::fs::create_dir_all(&app).unwrap();
let (template, component) = (app.join("example.component.html"), app.join("example.component.ts"));
std::fs::write(&template, "<button (click)=\"onConfirm()\">Confirm</button>\n").unwrap();
std::fs::write(&component, "export class ExampleComponent {\n onConfirm() {}\n}\n").unwrap();
let framework = h.launcher.state("framework");
framework.respond("textDocument/hover", json!({ "contents": "(method) ExampleComponent.onConfirm(): void" }));
let target = Range::new(Pos::new(1, 2), Pos::new(1, 11));
let range = json!({ "start": { "line": 1, "character": 2 }, "end": { "line": 1, "character": 11 } });
framework.respond("textDocument/definition", json!([{ "uri": uri_of(&component), "range": range }]));
#[cfg(unix)]
let links = tempfile::tempdir().unwrap();
let mut spellings = Vec::new();
#[cfg(unix)]
{
std::os::unix::fs::symlink(&h.root, links.path().join("linked")).unwrap();
spellings.push(links.path().join("linked").join(template.strip_prefix(&h.root).unwrap()));
}
// Only on a case-insensitive disk (macOS, Windows).
let upper = PathBuf::from(template.to_string_lossy().to_uppercase());
if upper.exists() {
spellings.push(upper);
}
for path in spellings {
let doc = DocId::next();
h.mgr.did_open(doc, &path, &h.lang, 1, "<button (click)=\"onConfirm()\">Confirm</button>\n");
eventually(|| framework.docs.lock().contains_key(&uri_of(&path))).await;
let hover = h.mgr.hover(doc, Pos::new(0, 20), Default::default()).await.unwrap();
assert!(hover.is_some_and(|h| h.contents.value.contains("onConfirm")), "{}", path.display());
let defs = h.mgr.goto(doc, Pos::new(0, 20), GotoKind::Definition).await.unwrap();
assert_eq!((&*defs[0].path, defs[0].range), (component.as_path(), target), "{}", path.display());
}
assert_eq!(h.statuses("framework").iter().filter(|s| **s == ServerStatus::Starting).count(), 1);
}
/// A server that `replaces` another (a PHP server with its own Laravel support and
/// `laravel-lsp`) keeps it away while it serves, and only then.
#[tokio::test(flavor = "multi_thread")]
@@ -4002,32 +3934,17 @@ async fn navigation_rename_format_and_decorations() {
let item = json!({ "name": "foo", "kind": 12, "uri": uri, "range": r(0,0,0,11), "selectionRange": r(0,3,0,6), "data": "id" });
s.respond("textDocument/prepareCallHierarchy", json!([item]));
s.respond("callHierarchy/incomingCalls", json!([{ "from": { "name": "main", "kind": 12, "uri": uri, "range": r(1,0,1,6), "selectionRange": r(1,0,1,3) }, "fromRanges": [r(1,0,1,3)] }]));
let hierarchy =
h.mgr.call_hierarchy(doc, Pos::new(0, 4), HierarchyDirection::Incoming, Default::default()).await.unwrap();
let root = hierarchy.root.expect("the prepared item");
assert_eq!((root.name.as_str(), root.selection_range), ("foo", rng(0, 3, 0, 6)));
assert_eq!(root.path.to_path_buf(), path);
let calls = hierarchy.items;
let calls = h
.mgr
.call_hierarchy(doc, Pos::new(0, 4), HierarchyDirection::Incoming, Default::default())
.await
.unwrap()
.items;
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].name, "main");
assert_eq!(calls[0].from_ranges, vec![rng(1, 0, 1, 3)]);
assert_eq!(s.requested("callHierarchy/incomingCalls")[0]["item"]["data"], "id");
// Outgoing calls of each prepared item are in that item's file.
let other = path.with_file_name("b.mk");
let second =
json!({ "name": "foo", "kind": 12, "uri": uri_of(&other), "range": r(4,0,4,11), "selectionRange": r(4,3,4,6) });
s.respond("textDocument/prepareCallHierarchy", json!([item, second]));
s.respond("callHierarchy/outgoingCalls", json!([{ "to": { "name": "bar", "kind": 12, "uri": uri, "range": r(2,0,2,6), "selectionRange": r(2,0,2,3) }, "fromRanges": [r(0,8,0,11)] }]));
let callees = h
.mgr
.call_hierarchy(doc, Pos::new(0, 4), HierarchyDirection::Outgoing, Default::default())
.await
.unwrap()
.items;
let from: Vec<_> = callees.iter().map(|c| c.from_path.clone().map(|p| p.into_path_buf())).collect();
assert_eq!(from, [Some(path.clone()), Some(other)]);
// No documentSymbolProvider → None so callers fall back to tree-sitter.
assert_eq!(h.mgr.document_symbols(doc).await.unwrap(), None);
}
@@ -7826,39 +7743,6 @@ async fn notebook_edits_change_cell_text_and_reorders_reopen_it() {
h.mgr.shutdown_all().await;
}
#[tokio::test(flavor = "multi_thread")]
async fn external_go_file_reuses_module_and_reopens_after_restart() {
let h = harness_configured("go", "go", &[("gopls", incremental_caps())], |cfg| {
cfg.root_markers = vec!["go.work".into(), "go.mod".into()];
});
h.launcher.state("gopls").omit_server_info.store(true, Ordering::SeqCst);
let module = h.root.join("service");
std::fs::create_dir_all(&module).unwrap();
std::fs::write(module.join("go.mod"), "module example.test/service\n").unwrap();
h.open("service/main.go", "package service\n");
h.wait_status("gopls", ServerStatus::Ready).await;
let cache = tempfile::tempdir().unwrap();
let external = cache.path().join("dependency.go");
std::fs::write(&external, "package dependency\n").unwrap();
let doc = DocId::next();
h.mgr.did_open(doc, &external, &h.lang, 1, "package dependency\n");
let state = h.launcher.state("gopls");
let opened_external = || {
state.notified("textDocument/didOpen").iter().filter(|p| p["textDocument"]["uri"] == uri_of(&external)).count()
};
eventually(|| opened_external() == 1).await;
assert_eq!(state.launches.load(Ordering::SeqCst), 1);
let id = h.mgr.servers()[0].id;
h.mgr.restart(id).await.unwrap();
eventually(|| opened_external() == 2).await;
assert_eq!(state.launches.load(Ordering::SeqCst), 2);
assert_eq!(h.mgr.servers().len(), 1);
let inits = state.requested("initialize");
assert_eq!(inits.len(), 2);
assert!(inits.iter().all(|p| p["rootUri"] == uri_of(&module)));
h.mgr.shutdown_all().await;
}
/// A plugin's request (`language-servers` in the plugin API) reaches the running server
/// named in the language definition: only the server's own methods, and never a start.
#[tokio::test(flavor = "multi_thread")]
+2 -2
Переглянути файл
@@ -17,8 +17,8 @@ mod wit_host;
pub use actor::{Actor, ActorError, Pending};
pub use runtime::{
API_VERSION, CANCELLED, CallCancel, CallError, GuestError, HostApi, MAX_CLIPBOARD_BYTES, PluginEngine, Runtime,
RuntimeSetup, check_api, component_api, host_api,
API_VERSION, CANCELLED, CallCancel, CallError, GuestError, HostApi, PluginEngine, Runtime, RuntimeSetup, check_api,
component_api, host_api,
};
pub use sandbox::{
MAX_READ_BYTES, inside_root, inside_roots, read_text, resolve_in_root, resolve_in_roots, resolve_new_in_root,
+7 -17
Переглянути файл
@@ -56,11 +56,9 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.11";
pub const API_VERSION: &str = "1.10";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
pub const MAX_CLIPBOARD_BYTES: usize = 16 << 20;
pub(crate) const MAX_TITLE: usize = 256;
const STDERR_CAPACITY: usize = 256 << 10;
/// Message of a call interrupted through [`Runtime::cancel_handle`].
@@ -320,12 +318,6 @@ pub trait HostApi: Send + Sync {
let _ = (client, text);
Ok(())
}
/// The clipboard of the machine `client`'s window runs on, as that window reads it;
/// waits for the window until `cancel` fires.
fn read_clipboard(&self, client: &str, cancel: &CancellationToken) -> Result<crate::ClipboardContent, HostError> {
let _ = (client, cancel);
Err(HostError::Failed("the clipboard is unavailable".into()))
}
fn open_url(&self, client: Option<&str>, url: String) -> Result<(), HostError> {
let _ = (client, url);
Ok(())
@@ -890,9 +882,7 @@ pub struct StoreData {
pub(crate) invocation: Invocation,
/// The running call is a command or an event.
pub(crate) interactive: bool,
/// The user ran it: a command, or a view action other than a web view message.
/// Gates what must not happen unattended (`net:ask` prompts, reading the clipboard).
pub(crate) user_invoked: bool,
pub(crate) net_interactive: bool,
/// Editor window for pick, pick-many, input and confirm during action resolution.
pub(crate) action_prompt_client: Option<String>,
/// Tasks begun by the running call and not ended yet.
@@ -1142,7 +1132,7 @@ impl Runtime {
host: setup.host,
invocation: Invocation::default(),
interactive: false,
user_invoked: false,
net_interactive: false,
action_prompt_client: None,
open_tasks: Vec::new(),
last_report: None,
@@ -1793,7 +1783,7 @@ impl Runtime {
let result = self.call(invocation, self.limits.timeout, |e, store| {
let ctx = store.data_mut().new_invocation()?;
store.data_mut().interactive = true;
store.data_mut().user_invoked = true;
store.data_mut().net_interactive = true;
let r = e.plugin.openidea_plugin_commands().call_run(
&mut *store,
id,
@@ -1919,12 +1909,12 @@ impl Runtime {
if self.exports.views.is_none() {
return Err(CallError::missing_export("view-provider"));
}
let user_invoked = !matches!(&event, ViewEvent::Message { .. });
let net_interactive = !matches!(&event, ViewEvent::Message { .. });
let event = event_to_wit_view(event);
let result = self.call(invocation, self.limits.timeout, |e, store| {
let ctx = store.data_mut().new_invocation()?;
store.data_mut().interactive = true;
store.data_mut().user_invoked = user_invoked;
store.data_mut().net_interactive = net_interactive;
let views = e.views.as_ref().expect("checked");
let r = views.call_handle(&mut *store, view, &event, wasmtime::component::Resource::new_borrow(ctx.rep()));
store.data_mut().drop_invocation(ctx);
@@ -1976,7 +1966,7 @@ impl Runtime {
let data = self.store.data_mut();
data.invocation = Invocation::default();
data.interactive = false;
data.user_invoked = false;
data.net_interactive = false;
data.action_prompt_client = None;
// Tasks don't outlive the call that began them.
for id in std::mem::take(&mut data.open_tasks) {
-8
Переглянути файл
@@ -866,14 +866,6 @@ pub struct Endpoint {
pub location: Location,
}
/// The clipboard as `ui.read-clipboard` returns it (API 1.11): `None` for a kind it doesn't
/// hold; `image` is PNG bytes.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ClipboardContent {
pub text: Option<String>,
pub image: Option<Vec<u8>>,
}
/// A notification button that runs one of the publishing plugin's commands.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+1 -32
Переглянути файл
@@ -353,7 +353,7 @@ impl StoreData {
/// their window; background and scheduled calls ask nobody, so only an
/// already-allowed host connects there.
fn ask_net(&mut self, host: &str) -> Result<Option<bool>, wit::Error> {
let client = self.user_invoked.then(|| self.invocation.client.clone()).flatten();
let client = self.net_interactive.then(|| self.invocation.client.clone()).flatten();
let subject = self.subject.clone();
let started = Instant::now();
let answer = self.host.net_ask(&subject, client.as_deref(), host, &self.cancel.token());
@@ -544,37 +544,6 @@ impl ui::Host for StoreData {
Ok(self.host.copy_to_clipboard(client.as_deref(), clip(text, crate::runtime::MAX_TEXT)).map_err(to_wit))
}
fn read_clipboard(&mut self) -> Fallible<ui::ClipboardContent> {
if let Err(e) = self.require(Capability::ClipboardRead) {
return Ok(Err(e));
}
// Never unattended: not from an event handler, a web view message or a command
// another plugin ran through `command-runner` (its chain is not empty).
let client = match &self.invocation.client {
Some(client) if self.user_invoked && self.invocation.command_chain.is_empty() => client.clone(),
_ => {
let why = "clipboard.read (only in a command or view action the user ran)";
return Ok(Err(wit::Error::Denied(why.into())));
}
};
let started = Instant::now();
let content = self.host.read_clipboard(&client, &self.cancel.token());
// The window may ask the user first: the wait doesn't count against the call's budget.
let waited = started.elapsed();
self.deadline += waited;
self.call_started += waited;
let content = match content {
Ok(content) => content,
Err(e) => return Ok(Err(to_wit(e))),
};
let max = crate::runtime::MAX_CLIPBOARD_BYTES;
if content.text.as_ref().is_some_and(|t| t.len() > max) || content.image.as_ref().is_some_and(|i| i.len() > max)
{
return Ok(Err(wit::Error::Failed(format!("the clipboard holds more than {} MiB", max >> 20))));
}
Ok(Ok(ui::ClipboardContent { text: content.text, image: content.image }))
}
fn open_url(&mut self, url: String) -> Fallible<()> {
let trimmed = url.trim();
let valid = (trimmed.starts_with("https://") || trimmed.starts_with("http://")) && trimmed.len() <= 8192;
+5 -6
Переглянути файл
@@ -91,16 +91,15 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.11.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.11.0", "1.0.0-rc.1"]
{
let host = v("1.10.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.0.0-rc.1"] {
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.12.0"), &host).unwrap_err();
assert!(newer.contains("1.12") && newer.contains("update OpenIDEA"), "{newer}");
let newer = check_api(&v("1.11.0"), &host).unwrap_err();
assert!(newer.contains("1.11") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.11 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.10 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c10d6f373bd3a701e201350d0272a211da72b23cef010144760db5bae44e2c11
f6069ad2d31b629e4c99fbb800b3bf389ffb87ca7f24fc9cf7803fef68997ef5
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
cd7a14b6d4464a559c197ba7fcba30fb045a8927c074fd0c310bec6039af0e0f
178a2dd60891bfa56a02be322b47dfdbbf22f6e0a50ac56a4b7e4ae1520a821a
-336
Переглянути файл
@@ -1,336 +0,0 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "anyhow"
version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "bitflags"
version = "2.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
[[package]]
name = "equivalent"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]]
name = "foldhash"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
[[package]]
name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
dependencies = [
"foldhash",
]
[[package]]
name = "heck"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
[[package]]
name = "id-arena"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "indexmap"
version = "2.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
dependencies = [
"equivalent",
"hashbrown",
"serde",
"serde_core",
]
[[package]]
name = "itoa"
version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
[[package]]
name = "leb128fmt"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
[[package]]
name = "log"
version = "0.4.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
[[package]]
name = "macro-string"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e7b3a5bbb2f63aaa223a671ea1bd0e7bc16bd30ce387324cf63995deaddbbd2"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "memchr"
version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "openidea-plugin"
version = "0.1.0"
dependencies = [
"serde",
"serde_json",
"wit-bindgen",
]
[[package]]
name = "openidea-test-clipboard"
version = "0.1.0"
dependencies = [
"openidea-plugin",
]
[[package]]
name = "prettyplease"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0"
dependencies = [
"proc-macro2",
"syn",
]
[[package]]
name = "proc-macro2"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [
"proc-macro2",
]
[[package]]
name = "semver"
version = "1.0.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
[[package]]
name = "serde"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
dependencies = [
"serde_core",
"serde_derive",
]
[[package]]
name = "serde_core"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.154"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
dependencies = [
"itoa",
"memchr",
"serde",
"serde_core",
"zmij",
]
[[package]]
name = "syn"
version = "3.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
[[package]]
name = "wasm-encoder"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4495a6f85dd94c411c749303efcbc5defade0b0cbdbc0541495241ab917a9b5a"
dependencies = [
"leb128fmt",
"wasmparser",
]
[[package]]
name = "wasm-metadata"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c86ff6668190d9fb70372b306b4f9fe8930f0e2f57ce72e4922bf2f117900949"
dependencies = [
"anyhow",
"indexmap",
"wasm-encoder",
"wasmparser",
]
[[package]]
name = "wasmparser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "974d643b125b272607e2fff8012ea14a8328acd7621e4bafa7afb32500052b1b"
dependencies = [
"bitflags",
"hashbrown",
"indexmap",
"semver",
]
[[package]]
name = "wit-bindgen"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b85a987ab61d365382d25c7d47e26edd48941b3bf6e3fbf76eff918bc71dab06"
dependencies = [
"bitflags",
"wit-bindgen-rust-macro",
]
[[package]]
name = "wit-bindgen-core"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "775e122e390603abfacd548027016cd0113a6e2bf2f8ce6bdd3658b013456ea8"
dependencies = [
"anyhow",
"heck",
"wit-parser",
]
[[package]]
name = "wit-bindgen-rust"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84e26e13b9d972026778d2ffb7985736de116026fdc8d9464f966e12df2eb240"
dependencies = [
"anyhow",
"heck",
"indexmap",
"prettyplease",
"syn",
"wasm-metadata",
"wit-bindgen-core",
"wit-component",
]
[[package]]
name = "wit-bindgen-rust-macro"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16a008a0d6b4840677326beb4edbeb210a2f1b7d0183fb7cc33f466b90fd7fb6"
dependencies = [
"anyhow",
"macro-string",
"prettyplease",
"proc-macro2",
"quote",
"syn",
"wit-bindgen-core",
"wit-bindgen-rust",
]
[[package]]
name = "wit-component"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "078def49fdb49cab405c3006e05793b3fdaf7069126ba6b9c97d01ec8c98fe4c"
dependencies = [
"anyhow",
"bitflags",
"indexmap",
"log",
"serde",
"serde_derive",
"serde_json",
"wasm-encoder",
"wasm-metadata",
"wasmparser",
"wit-parser",
]
[[package]]
name = "wit-parser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00f0dc051466ffe46787721fca3d088536f158ae400be044f1b1c386ba9397ad"
dependencies = [
"anyhow",
"hashbrown",
"id-arena",
"indexmap",
"log",
"semver",
"serde",
"serde_derive",
"serde_json",
"unicode-ident",
"wasmparser",
]
[[package]]
name = "zmij"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
-20
Переглянути файл
@@ -1,20 +0,0 @@
[package]
name = "openidea-test-clipboard"
version = "0.1.0"
edition = "2024"
publish = false
[workspace]
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies]
openidea-plugin = { path = "../../../../../sdk/rust/openidea-plugin" }
[profile.release]
opt-level = "s"
lto = true
strip = true
codegen-units = 1
panic = "abort"
Бінарний файл не відображається.
-1
Переглянути файл
@@ -1 +0,0 @@
017cb719d8c3a226cb6178d75da7ae0396b2d78799658ef560f729e8e06f36e3
-25
Переглянути файл
@@ -1,25 +0,0 @@
# Test fixture: `ui.read-clipboard` (API 1.11) from a command, a view's button,
# a web view message and an event handler; only the first two are the user's.
id = "test.clipboard"
name = "Clipboard fixture"
version = "0.1.0"
engines.openidea = "^1.11"
wasm = "dist/plugin.wasm"
activation = ["on-command:*", "on-view:clipboard", "on-event:editor-focused"]
[capabilities]
optional = ["clipboard.read", "events"]
[[contributes.commands]]
id = "read"
title = "Read the clipboard"
[[contributes.commands]]
id = "last"
title = "What the last view action or event read"
[[contributes.views]]
id = "clipboard"
title = "Clipboard"
icon = "toolwindow-services"
location = "right"
-47
Переглянути файл
@@ -1,47 +0,0 @@
use openidea_plugin::views::{Body, Button, View, ViewEvent, Viewport, Views};
use openidea_plugin::{ClipboardContent, Error, Event, Invocation, Plugin, host, register_plugin};
/// `text=<text> image=<PNG byte count>`, `-` for what the clipboard doesn't hold.
fn describe(content: Result<ClipboardContent, Error>) -> String {
match content {
Ok(c) => format!(
"text={} image={}",
c.text.as_deref().unwrap_or("-"),
c.image.map_or("-".into(), |png| png.len().to_string())
),
Err(e) => format!("error: {e}"),
}
}
#[derive(Default)]
struct Clipboard {
/// What the last view action or event handler read.
last: Option<String>,
}
impl Plugin for Clipboard {
fn run_command(&mut self, id: &str, _: &Invocation, _: Option<&str>) -> Result<Option<String>, Error> {
match id {
"read" => Ok(Some(describe(Ok(host::read_clipboard()?)))),
"last" => Ok(self.last.take()),
_ => Err(Error::NotFound(id.into())),
}
}
fn handle_events(&mut self, _: &[Event], _: &Invocation) {
self.last = Some(describe(host::read_clipboard()));
}
}
impl Views for Clipboard {
fn render(&mut self, _: &str, _: Option<Viewport>, _: &Invocation) -> Result<View, Error> {
Ok(View::new(Body::Message("clipboard".into())).button(Button::new("read", "Read")))
}
fn handle(&mut self, _: &str, _: ViewEvent, _: &Invocation) -> Result<(), Error> {
self.last = Some(describe(host::read_clipboard()));
Ok(())
}
}
register_plugin!(Clipboard, views);
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
93a9660a0941f2f57d11ea7ae331bd6d209ddcb134729ee88ec2fd96e978e631
c39252e48882cb605286f95d1115a3293c191538d7762d1d3ce3afb1bfad814b
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
6a0008339af0935c7c0128d23bf3e885a642c335ad57097cffb3f000766aba33
0809519ebb56f31b1f00d1e256a6d1af4e1c357990226ef949ac61f1e61989d6
Loaded 100 of 547 files, more files were not shown because too many files have changed in this diff. Show more