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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 0ecf2bcf52 fix(build): never wipe an artifact's chosen output folder 2026-11-16 18:22:03 +08:00
43 змінених файлів з 128 додано та 696 видалено

No files matched your search

+2 -61
Переглянути файл
@@ -2,8 +2,8 @@
//! the agent reports them over ACP.
use crate::model::{
AgentCommand, AgentCommandSource, AgentConfigChoice, AgentConfigOption, AgentConfigValue, AgentConfigVia,
AgentCost, AgentLimit, AgentModelPricing, AgentUsage,
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
AgentModelPricing, AgentUsage,
};
use serde_json::{Value, json};
@@ -54,45 +54,6 @@ pub(crate) fn bypass_approvals(config: &[AgentConfigOption]) -> bool {
.any(|category| selected(category).zip(bypass_value(category)).is_some_and(|(value, bypass)| bypass(value)))
}
/// Mode values that ask before anything changes the project, most careful first: Codex's
/// Read Only (its Ask still edits the workspace), Claude Code's default (its Accept Edits
/// doesn't ask), then plan modes.
const ASKING_MODES: [&str; 4] = ["read-only", "default", "plan", "ask"];
/// Moves `config` to settings that ask before anything changes the project (a side
/// conversation): approvals that approve everything ask, and the mode is the most careful one.
pub(crate) fn keep_asking(config: &mut [AgentConfigOption]) {
ask_for_approvals(config);
for option in config.iter_mut().filter(|o| o.category.as_deref() == Some("mode")) {
if let Some(mode) = ASKING_MODES.iter().find(|m| option.values.iter().any(|v| v.value == **m)) {
option.current = Some((*mode).to_owned());
}
}
}
/// The choices that keep a session asking before it changes anything: `wanted` without its
/// mode and approval choices, and the [`keep_asking`] value of each such option of `options`.
pub(crate) fn asking_choices(options: &[AgentConfigOption], wanted: &[AgentConfigChoice]) -> Vec<AgentConfigChoice> {
let guarded = |o: &AgentConfigOption| o.category.as_deref().and_then(bypass_value).is_some();
let mut out: Vec<AgentConfigChoice> =
wanted.iter().filter(|c| !options.iter().any(|o| o.id == c.id && guarded(o))).cloned().collect();
let mut asking = options.to_vec();
keep_asking(&mut asking);
for option in asking.iter().filter(|o| guarded(o)) {
if let Some(value) = &option.current {
out.push(AgentConfigChoice { id: option.id.clone(), value: value.clone() });
}
}
out
}
/// Whether `config` is what [`keep_asking`] makes of it.
pub(crate) fn keeps_asking(config: &[AgentConfigOption]) -> bool {
let mut asking = config.to_vec();
keep_asking(&mut asking);
asking.iter().zip(config).all(|(a, b)| a.current == b.current)
}
/// For an option of `category` that can approve everything, what tells its approving values.
fn bypass_value(category: &str) -> Option<fn(&str) -> bool> {
match category {
@@ -503,26 +464,6 @@ mod tests {
assert_eq!(ids(&c), [("allow_all", Some("off")), ("approval", Some("ask"))]);
}
#[test]
fn asking_choices_keep_a_side_conversation_from_changing_anything() {
let codex = options_of(&json!({"modes": {"currentModeId": "full-access",
"availableModes": [{"id": "read-only"}, {"id": "ask"}, {"id": "auto"}, {"id": "full-access"}]}}));
let mode = codex[0].id.clone();
let choice = |id: &str, value: &str| AgentConfigChoice { id: id.into(), value: value.into() };
// Codex goes to Read Only (its Ask edits the workspace), whatever the source task chose.
let wanted = asking_choices(&codex, &[choice(&mode, "full-access"), choice("model", "gpt")]);
assert_eq!(wanted, [choice("model", "gpt"), choice(&mode, "read-only")]);
assert_eq!(asking_choices(&codex, &[choice(&mode, "ask")]), [choice(&mode, "read-only")]);
// Claude Code's Accept Edits doesn't ask: default does.
let claude = options_of(&json!({"modes": {"currentModeId": "acceptEdits",
"availableModes": [{"id": "default"}, {"id": "acceptEdits"}, {"id": "plan"}, {"id": "bypassPermissions"}]}}));
assert_eq!(asking_choices(&claude, &[]), [choice(&claude[0].id, "default")]);
assert!(!keeps_asking(&claude));
let mut safe = claude.clone();
keep_asking(&mut safe);
assert!(keeps_asking(&safe));
}
#[test]
fn effort_and_fast_categories_are_inferred_from_ids() {
let mut c = options_of(&json!({
+14 -64
Переглянути файл
@@ -210,23 +210,20 @@ impl Shared {
}
}
/// The MCP servers passed to a session, and the names of the ones off for it.
fn mcp_servers_for_session(
&self,
provider: &str,
init: &acp::Negotiated,
overrides: &BTreeMap<String, bool>,
) -> McpForSession {
let builtin_off = overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false);
let mut servers =
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
) -> Vec<Value> {
let mut servers = if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
Vec::new()
} else {
mcp_servers_for(init.mcp_stdio(), &self.paths.project_root)
};
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
let mut off = mcp::servers_off(&configured, overrides);
if builtin_off {
off.push(BUILTIN_SERVER.to_owned());
}
McpForSession { servers, off }
servers
}
fn known_config(&self, provider: &str) -> Vec<AgentConfigOption> {
@@ -894,9 +891,7 @@ impl AgentManager {
let prompt = clean(req.prompt).ok_or_else(|| IdeError::invalid("describe the topic first"))?;
let title = title_of(&prompt);
let mut config = self.merged_config(&spec.id, &req.config);
// The source task's choices may change the project without asking; the side conversation asks.
let wanted = config::asking_choices(&config, &req.config);
config::keep_asking(&mut config);
config::ask_for_approvals(&mut config);
if config::bypass_approvals(&config) {
return Err(IdeError::invalid(
"this agent has no mode that asks before changing things, so it can't run a side conversation",
@@ -938,7 +933,7 @@ impl AgentManager {
task: task.clone(),
session_id: None,
entries: Vec::new(),
wanted,
wanted: req.config,
before,
saved: None,
touched: None,
@@ -1055,15 +1050,6 @@ impl AgentManager {
if !o.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
}
if s.ephemeral {
let mut next = s.task.config.clone();
if let Some(n) = next.iter_mut().find(|n| n.id == option) {
n.current = Some(value.clone());
}
if !config::keeps_asking(&next) {
return Err(IdeError::invalid("a side conversation asks before changing anything"));
}
}
o.clone()
};
let previous = target.current.clone();
@@ -1152,11 +1138,7 @@ impl AgentManager {
.peer
.request(
"session/fork",
{
let mut params = session_params(&cwd_s, &mcp_servers);
params["sessionId"] = json!(live.session);
params
},
json!({ "sessionId": live.session, "cwd": cwd_s, "mcpServers": mcp_servers }),
None,
)
.await
@@ -2329,8 +2311,7 @@ impl Task {
let mut session = None;
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);
let params = json!({ "sessionId": &id, "cwd": &cwd_s, "mcpServers": &mcp_servers });
let loaded = self.request_with_auth(&peer, &init, &mut tried_auth, "session/load", params).await;
tokio::time::sleep(REPLAY_GRACE).await;
self.replaying.store(false, Ordering::Release);
@@ -2343,7 +2324,7 @@ impl Task {
let (session_id, result) = match session {
Some(s) => s,
None => {
let params = session_params(&cwd_s, &mcp_servers);
let params = json!({ "cwd": &cwd_s, "mcpServers": &mcp_servers });
let v = self.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params).await.map_err(
|e| match self.sign_in_error(&e, Some(&sign_in_message)) {
Some(msg) => SessionOpenError { message: msg, allow_acp_fallback: false },
@@ -2384,10 +2365,7 @@ impl Task {
}
let (mut options, mut wanted) = {
let s = self.state.lock();
let options = if known { reported } else { s.task.config.clone() };
// A side conversation asks before anything, whatever mode the agent starts in.
let wanted = if s.ephemeral { config::asking_choices(&options, &s.wanted) } else { s.wanted.clone() };
(options, wanted)
(if known { reported } else { s.task.config.clone() }, s.wanted.clone())
};
config::add_client_options(provider_id, &mut options);
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
@@ -2434,14 +2412,6 @@ impl Task {
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
}
}
// A side conversation never runs in a mode that changes things without asking: when the
// agent refused the switch, it doesn't start.
if self.state.lock().ephemeral && !config::keeps_asking(&options) {
return Err(SessionOpenError {
message: "The agent didn't switch to a mode that asks before changing anything, so the side conversation can't start".into(),
allow_acp_fallback: false,
});
}
let model = model_of(&options).filter(|_| model_options);
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
{
@@ -3287,23 +3257,6 @@ fn turn_starts(entries: &[AgentEntry]) -> Vec<usize> {
.collect()
}
/// The MCP servers of a session, and the names of the ones off for it.
struct McpForSession {
servers: Vec<Value>,
off: Vec<String>,
}
/// The session parameters `session/new`, `session/load` and `session/fork` share: the MCP
/// servers, and the ones off for this session, so an agent that also loads its own
/// configuration (Claude Code) can keep a same-named server of it off too.
fn session_params(cwd: &str, mcp: &McpForSession) -> Value {
let mut params = json!({ "cwd": cwd, "mcpServers": mcp.servers });
if !mcp.off.is_empty() {
params["_meta"] = json!({ "openidea": { "mcpServersOff": mcp.off } });
}
params
}
fn is_false(b: &bool) -> bool {
!*b
}
@@ -3412,9 +3365,6 @@ mod replay_tests;
#[cfg(test)]
mod tests;
/// The name agents know the built-in server by (its tools are `mcp__OpenIDEA__…` in Claude Code).
const BUILTIN_SERVER: &str = "OpenIDEA";
// The desktop advertises its relay only while the built-in server is listening.
static MCP_EXECUTABLE: parking_lot::RwLock<Option<std::path::PathBuf>> = parking_lot::RwLock::new(None);
@@ -3429,7 +3379,7 @@ fn mcp_servers_for(supported: bool, root: &std::path::Path) -> Vec<Value> {
fn stdio_mcp_servers(executable: Option<&std::path::Path>, supported: bool, root: &std::path::Path) -> Vec<Value> {
let Some(executable) = executable.filter(|_| supported) else { return Vec::new() };
let command = ide_mcp::stdio_command(executable, root);
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": [] })]
vec![json!({ "name": "OpenIDEA", "command": command[0], "args": command[1..], "env": [] })]
}
/// What was sent of a streaming message: its first `bytes` (`utf16` UTF-16 units), which
-61
Переглянути файл
@@ -86,29 +86,6 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
})
}
/// The configured servers off for this session: off by default and not switched on for it, or
/// switched off for it. Named so an agent that also loads its own configuration can keep a
/// same-named server of it off too. Workspace entries take precedence, as in [`acp_mcp_servers`].
pub(crate) fn servers_off(all: &[McpServer], overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut seen = HashSet::new();
let ordered =
all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
let configured: Vec<String> = ordered
.filter(|s| seen.insert(s.name.as_str()))
.filter(|s| !overrides.get(&s.name).copied().unwrap_or(s.enabled))
.map(|s| s.name.clone())
.collect();
// A server switched off that the IDE doesn't configure may still be the agent's own.
let switched = overrides
.iter()
.filter(|(name, on)| !**on && name.as_str() != BUILTIN_MCP_NAME && !seen.contains(name.as_str()))
.map(|(name, _)| name.clone());
let mut off: Vec<String> = configured.into_iter().chain(switched).collect();
off.sort();
off.dedup();
off
}
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
/// Workspace entries take precedence over User entries with the same name. Per-session
/// `overrides` (`server_name` -> `enabled`) can enable a disabled server or disable an enabled one
@@ -1039,44 +1016,6 @@ fn parse_key_values_map(val: Option<&Value>) -> BTreeMap<String, String> {
mod tests {
use super::*;
fn configured(name: &str, scope: McpScope, enabled: bool) -> McpServer {
McpServer {
id: format!("{scope:?}:{name}"),
name: name.into(),
scope,
transport: McpTransport::Stdio,
enabled,
command: Some("x".into()),
args: Vec::new(),
env: Vec::new(),
url: None,
headers: Vec::new(),
agents: Vec::new(),
unapproved: false,
}
}
#[test]
fn servers_off_follow_the_effective_state() {
let all = [
configured("default-off", McpScope::User, false),
configured("switched-on", McpScope::User, false),
configured("on", McpScope::User, true),
configured("switched-off", McpScope::User, true),
// The workspace entry decides for its name.
configured("both", McpScope::User, true),
configured("both", McpScope::Workspace, false),
];
let overrides = BTreeMap::from([
("switched-on".to_owned(), true),
("switched-off".to_owned(), false),
("agent-own".to_owned(), false),
(BUILTIN_MCP_NAME.to_owned(), false),
]);
assert_eq!(servers_off(&all, &overrides), ["agent-own", "both", "default-off", "switched-off"]);
assert_eq!(servers_off(&all[2..4], &BTreeMap::new()), Vec::<String>::new());
}
#[test]
fn crud_and_acp_filtering_by_scope_agent_and_transport() {
let mut user = BTreeMap::new();
+11 -31
Переглянути файл
@@ -170,8 +170,6 @@ struct Session {
id: String,
cwd: PathBuf,
mcp_config: Option<tempfile::TempPath>,
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
mcp_off: Vec<String>,
shim: Weak<Shim>,
st: Mutex<State>,
/// Serializes (re)starting the process.
@@ -346,10 +344,9 @@ impl Shim {
cwd: PathBuf,
start: Start,
pending: bool,
params: &Value,
mcp_config: Option<String>,
) -> Arc<Session> {
let mcp_off = mcp_off(params);
let mcp_config = mcp_config(params).and_then(|json| match write_mcp_config(&json) {
let mcp_config = mcp_config.and_then(|json| match write_mcp_config(&json) {
Ok(path) => Some(path),
Err(e) => {
tracing::warn!("Claude Code session {id}: cannot write its MCP configuration: {e}");
@@ -359,7 +356,6 @@ impl Shim {
let session = Arc::new(Session {
id: id.to_owned(),
mcp_config,
mcp_off,
shim: Arc::downgrade(self),
st: Mutex::new(State {
proc: None,
@@ -415,8 +411,13 @@ impl Shim {
}
"session/new" => {
let id = new_uuid(false);
let session =
self.add_session(&id, self.cwd_of(&params), Start::New { id: id.clone() }, false, &params);
let session = self.add_session(
&id,
self.cwd_of(&params),
Start::New { id: id.clone() },
false,
mcp_config(&params),
);
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
session.announce_commands();
Ok(json!({ "sessionId": id, "configOptions": session.st.lock().settings.options() }))
@@ -432,7 +433,7 @@ impl Shim {
None => return Err(invalid(format!("no Claude Code session {id} in {}", cwd.display()))),
};
let chain = self.base_chain(&cwd, &start).map_err(internal)?;
let session = self.add_session(id, cwd, start, pending, &params);
let session = self.add_session(id, cwd, start, pending, mcp_config(&params));
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
if method == "session/load" {
session.replay(&chain);
@@ -458,7 +459,7 @@ impl Shim {
(start, st.settings.clone())
};
self.save_pending(&id, Some(&start));
let session = self.add_session(&id, source.cwd.clone(), start, true, &params);
let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(&params));
session.st.lock().settings = settings;
let options = session.st.lock().settings.options();
Ok(json!({ "sessionId": id, "configOptions": options }))
@@ -665,9 +666,6 @@ impl Session {
if let Some(config) = &self.mcp_config {
args.extend(["--mcp-config".to_owned(), config.to_string_lossy().into_owned()]);
}
if !self.mcp_off.is_empty() {
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
}
args.extend(start.args());
let launch =
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
@@ -1499,24 +1497,6 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
Ok(file.into_temp_path())
}
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
/// Claude Code's own configuration stays off too.
fn mcp_off(params: &Value) -> Vec<String> {
params
.pointer("/_meta/openidea/mcpServersOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.map(|name| {
let name: String =
name.chars().map(|c| if c.is_ascii_alphanumeric() || c == '_' || c == '-' { c } else { '_' }).collect();
format!("mcp__{name}")
})
.collect()
}
/// ACP `mcpServers` as Claude Code's `--mcp-config` JSON (`None` when there are none).
fn mcp_config(params: &Value) -> Option<String> {
let servers = params.get("mcpServers")?.as_array()?;
-7
Переглянути файл
@@ -1243,13 +1243,6 @@ async fn skipped_questions_have_no_answers() {
assert_eq!(cancelled, None);
}
#[test]
fn servers_switched_off_become_disallowed_tools() {
assert!(mcp_off(&json!({})).is_empty());
let off = mcp_off(&json!({ "_meta": { "openidea": { "mcpServersOff": ["github", "my server.v2"] } } }));
assert_eq!(off, ["mcp__github", "mcp__my_server_v2"]);
}
#[test]
fn mcp_servers_become_an_mcp_config() {
assert_eq!(mcp_config(&json!({ "mcpServers": [] })), None);
-11
Переглянути файл
@@ -4238,14 +4238,3 @@ done
);
mgr.shutdown();
}
#[test]
fn session_params_name_the_servers_off() {
let mcp = McpForSession { servers: vec![json!({ "name": "docs" })], off: vec!["github".into()] };
let params = session_params("/p", &mcp);
assert_eq!(params["cwd"], "/p");
assert_eq!(params["mcpServers"][0]["name"], "docs");
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
assert!(session_params("/p", &none).get("_meta").is_none());
}
+1 -29
Переглянути файл
@@ -487,10 +487,6 @@ impl Action {
}
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
// A link in the artifact's place is replaced, not written through.
if fs::symlink_metadata(to).is_ok_and(|m| m.file_type().is_symlink()) {
fs::remove_file(to).map_err(|e| IdeError::internal(format!("cannot replace {} ({e})", to.display())))?;
}
if let Some(parent) = to.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
@@ -508,12 +504,6 @@ fn copy_tree(from: &Path, to: &Path, written: &mut Vec<PathBuf>, cancel: &Cancel
let Ok(t) = e.file_type() else { continue };
let target = to.join(e.file_name());
if t.is_dir() {
if fs::symlink_metadata(&target).is_ok_and(|m| m.file_type().is_symlink()) {
return Err(IdeError::invalid(format!(
"{} links to another folder; the artifact is not laid out through it",
target.display()
)));
}
copy_tree(&e.path(), &target, written, cancel)?;
} else if t.is_file() {
copy_file(&e.path(), &target)?;
@@ -541,14 +531,7 @@ fn replace_recorded(into: &Path, record: &Path, written: &[PathBuf]) -> IdeResul
continue;
}
let file = into.join(&rel);
// Never through a link: a folder of the output that now links elsewhere (or a file that
// is a link) leads out of what the layout wrote.
let mut at = into.to_path_buf();
let linked = rel.components().any(|c| {
at.push(c);
fs::symlink_metadata(&at).is_ok_and(|m| m.file_type().is_symlink())
});
if !linked && file.is_file() {
if file.is_file() {
let _ = fs::remove_file(&file);
let mut dir = file.parent();
while let Some(d) = dir.filter(|d| *d != into && d.starts_with(into)) {
@@ -916,17 +899,6 @@ mod tests {
write(&tmp.path().join("outside.txt"), "x");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(tmp.path().join("outside.txt").is_file());
// Nor through a folder of the output that now links elsewhere.
#[cfg(unix)]
{
write(&project.join("assets/x.txt"), "laid out");
write(&record, &format!("{}\nassets/x.txt", project.display()));
fs::remove_dir_all(project.join("assets")).unwrap();
std::os::unix::fs::symlink(project.join("src"), project.join("assets")).unwrap();
write(&project.join("src/x.txt"), "source");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("src/x.txt").is_file());
}
// Nor does one made for another output folder.
write(&project.join("c.jar"), "mine");
write(&record, "/elsewhere\nc.jar");
+2 -5
Переглянути файл
@@ -167,10 +167,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
}
call.confirm(&subject, Some(detail)).await?;
// Exactly the request the user approved: preparing it again would read the
// environment files again, which may name another destination by now.
let redact_url = prepared.url.clone();
let exchange = ide_http::send(prepared, Some(&path), &call.cancel).await?;
let exchange = ide_http::run(input, &call.cancel).await?;
let history = call.project().http_history.clone();
let saved = exchange.clone();
let _ = call.host().blocking(move || history.add(&saved)).await;
@@ -191,7 +188,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
"status": response.map(|r| r.status),
"statusText": response.map(|r| r.status_text.clone()),
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
"error": redact_transport_error(exchange.entry.error.clone(), &redact_url),
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
"body": body,
"bodyTruncated": body_truncated,
}))
+1 -11
Переглянути файл
@@ -34,16 +34,6 @@ pub struct RunInput<'a> {
/// variables, missing includes) fail; transport errors are part of the exchange.
pub async fn run(input: RunInput<'_>, cancel: &CancellationToken) -> IdeResult<HttpExchange> {
let request = prepare(&input)?;
send(request, input.file, cancel).await
}
/// Sends an already prepared request (one the user approved as shown); `file` is the
/// request file it came from, for the history.
pub async fn send(
request: PreparedRequest,
file: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<HttpExchange> {
let time_ms = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs_f64() * 1000.0)
@@ -67,7 +57,7 @@ pub async fn send(
url: request.url.clone(),
status: response.as_ref().map(|r| r.status),
total_ms: response.as_ref().map(|r| r.total_ms),
file: file.map(IpcPath::from),
file: input.file.map(IpcPath::from),
error,
},
request,
+1 -2
Переглянути файл
@@ -295,10 +295,9 @@ export const lspTheme = EditorView.theme({
padding: "6px 10px",
borderRadius: "var(--radius-popup)",
boxShadow: "var(--shadow-popup)",
maxWidth: "480px",
whiteSpace: "pre-wrap",
},
// The hint is the tooltip element itself: beat the editor theme's `.cm-tooltip` width.
".cm-tooltip.cm-lsp-hint": { maxWidth: "min(480px, 100%)" },
".cm-lsp-hint-error": {
backgroundColor: "var(--bg-feedback-error, color-mix(in srgb, var(--danger) 8%, var(--bg-popup)))",
borderColor: "color-mix(in srgb, var(--danger) 35%, var(--border-popup))",
+24 -20
Переглянути файл
@@ -316,7 +316,7 @@ export async function fillMarkers(
const c = up[i]!;
const self = classOf(c);
if (!self) continue;
const found = resolver ? await superMethodsFrom(resolver, self, c.symbol, deps) : [];
const found = resolver ? await superMethodsFrom(resolver, self.name, c.symbol, deps) : [];
if (!found.length) continue;
const known = supers[i]!;
// Same merge rule as ↓: add the graph's super methods to what the server answered.
@@ -369,37 +369,41 @@ function mergeLocations(first: readonly Location[], more: readonly Location[]):
return [...first, ...more.filter((l) => !first.some((f) => sameDeclarationLine(f, l)))];
}
/** Identifies one class declaration in the inheritance graph. */
/**
* Super methods of `method` declared by a base of the class declaration `start`, walking the
* inheritance graph's concrete declarations up to a few levels: a base resolves from the file
* that names it, so an unrelated class of the same name never joins the walk. Empty when no
* base declares the method.
* Super methods of `method` declared by a class in `byName`, walking the inheritance
* graph's bases up to a few levels. Empty when no base declares the method.
*/
async function superMethodsFrom(
resolver: InheritanceIndex,
start: ClassInheritance,
start: string,
method: string,
deps: MarkerDeps,
depth = 3,
): Promise<{ location: Location; owner: string }[]> {
const bare = method.replace(/\s*[(<].*$/, "");
const key = (c: ClassInheritance) => `${c.path}:${c.line}:${c.col}`;
const seen = new Set<string>([key(start)]);
const seen = new Set<string>([start]);
let level = [start];
for (let d = 0; d < depth && level.length; d++) {
const next: ClassInheritance[] = [];
const next: string[] = [];
const found: { location: Location; owner: string }[] = [];
for (const cls of level) {
for (const base of cls.bases) {
// Same rule as the graph: a base the imports name, else a unique one.
for (const baseCls of await resolver.resolve(base, cls.path)) {
if (seen.has(key(baseCls))) continue;
seen.add(key(baseCls));
const outline = await deps.supers.outline(baseCls.path).catch(() => [] as OutlineItem[]);
const m = methodInOutline(outline, baseCls, bare);
if (m) found.push({ location: { path: baseCls.path, range: m.selection_range }, owner: base });
// Not declared there: keep walking that class's own bases.
else next.push(baseCls);
for (const name of level) {
for (const cls of resolver.byName.get(name) ?? []) {
for (const base of cls.bases) {
if (!seen.add(base)) continue;
// Same rule as the graph: a base the imports name, else a unique one.
const declarations = await resolver.resolve(base, cls.path);
let answered = false;
for (const baseCls of declarations) {
const outline = await deps.supers.outline(baseCls.path).catch(() => [] as OutlineItem[]);
const m = methodInOutline(outline, baseCls, bare);
if (m) {
found.push({ location: { path: baseCls.path, range: m.selection_range }, owner: base });
answered = true;
}
}
// Not found in a base that declares nothing: keep walking its own bases.
if (!answered) next.push(base);
}
}
}
-20
Переглянути файл
@@ -803,26 +803,6 @@ describe("python inheritance fallback", () => {
expect(cachedMarkers(candidates, ALL, cache).map((m) => [m.line, m.kind])).toEqual([[0, "overridden"]]);
});
it("walks up from the class itself, not every class of its name", async () => {
// a.py: `class BaseA` with `foo`, `class Child(BaseA)` with `foo`; b.py the same with BaseB.
const outline = (base: string) => [
item(base, "class", 0, 2, [item("foo", "method", 1, 1)], 6),
item("Child", "class", 3, 5, [item("foo", "method", 4, 4)], 6),
];
const graph: ClassInheritance[] = [
{ path: "/p/a.py", line: 0, col: 6, name: "BaseA", bases: [] },
{ path: "/p/a.py", line: 3, col: 6, name: "Child", bases: ["BaseA"] },
{ path: "/p/b.py", line: 0, col: 6, name: "BaseB", bases: [] },
{ path: "/p/b.py", line: 3, col: 6, name: "Child", bases: ["BaseB"] },
];
const { deps } = pythonServer(graph, { "/p/a.py": outline("BaseA"), "/p/b.py": outline("BaseB") });
const candidates = markerCandidates(outline("BaseA"), () => "");
const cache = emptyCache();
await fillMarkers("/p/a.py", candidates, ALL, deps(), cache);
const up = cachedMarkers(candidates, ALL, cache).find((m) => m.line === 4 && m.kind === "overriding");
expect(up?.targets.map((t) => [t.path, t.range.start.line])).toEqual([["/p/a.py", 1]]);
});
it("resolves an ambiguous base name through the subclass file's imports", async () => {
// Two modules declare `Config`; `from pkg.b import Config` picks one of them, so
// only b.py's Config is marked as subclassed.
+2 -7
Переглянути файл
@@ -1,5 +1,5 @@
/** IDEA's Change Signature dialog for Java methods (`signature.ts`). */
import { useEffect, useRef, useState } from "react";
import { useState } from "react";
import type { MethodSignature } from "@/bindings";
import { Checkbox, Dialog, IconButton, Input, Select, Spinner, T, Toolbar } from "@/ui";
import { useTx } from "@/platform/i18n";
@@ -46,11 +46,7 @@ function ChangeSignatureDialogInner({ request }: { request: SignatureRequest })
const ready = !busy && !problem && signatureChanged(info, signature);
const current = Math.min(selected, rows.length - 1);
// Closing the dialog cancels a refactoring still being checked: it applies nothing.
const running = useRef<AbortController | null>(null);
useEffect(() => () => running.current?.abort(), []);
const close = () => {
running.current?.abort();
useSignatureDialog.setState({ request: null });
request.view.focus();
};
@@ -76,10 +72,9 @@ function ChangeSignatureDialogInner({ request }: { request: SignatureRequest })
};
const submit = async (preview: boolean) => {
if (!ready) return;
const run = (running.current = new AbortController());
setBusy(true);
setError(null);
const outcome = await changeSignature(request, signature, delegate, preview, run.signal);
const outcome = await changeSignature(request, signature, delegate, preview);
if (useSignatureDialog.getState().request !== request) return;
setBusy(false);
if (outcome.status === "done") close();
+2 -7
Переглянути файл
@@ -1,5 +1,5 @@
/** IDEA's Extract Interface dialog for Java classes (`extractInterface.ts`). */
import { useEffect, useRef, useState } from "react";
import { useState } from "react";
import { Checkbox, Dialog, Input, Select, Spinner, T } from "@/ui";
import { useTx } from "@/platform/i18n";
import {
@@ -39,11 +39,7 @@ function ExtractInterfaceDialogInner({ request }: { request: InterfaceRequest })
const ready = !busy && !problem && !!target;
const allChecked = checked.size === info.members.length;
// Closing the dialog cancels a refactoring still being checked: it applies nothing.
const running = useRef<AbortController | null>(null);
useEffect(() => () => running.current?.abort(), []);
const close = () => {
running.current?.abort();
useExtractInterfaceDialog.setState({ request: null });
request.view.focus();
};
@@ -56,11 +52,10 @@ function ExtractInterfaceDialogInner({ request }: { request: InterfaceRequest })
});
const submit = async (preview: boolean) => {
if (!ready) return;
const run = (running.current = new AbortController());
setBusy(true);
setError(null);
const members = info.members.map((m) => m.handleIdentifier).filter((id) => checked.has(id));
const outcome = await extractInterface(request, trimmed, target, members, preview, run.signal);
const outcome = await extractInterface(request, trimmed, target, members, preview);
if (useExtractInterfaceDialog.getState().request !== request) return;
setBusy(false);
if (outcome.status === "done") close();
-56
Переглянути файл
@@ -1,56 +0,0 @@
import { describe, expect, it, vi } from "vitest";
const cancelRequest = vi.fn(async (_id: number) => ({ status: "ok", data: null }));
vi.mock("@/platform/ipc", async (original) => {
const ipc = await original<typeof import("@/platform/ipc")>();
return { ...ipc, commands: { ...ipc.commands, cancelRequest } };
});
const { cancellable } = await import("./signature");
const { isCancelled } = await import("@/platform/ipc");
describe("cancellable refactoring requests", () => {
it("cancels the request in flight when the dialog closes", async () => {
const run = new AbortController();
let sent = -1;
let answer!: (v: string) => void;
const reply = cancellable(run.signal, (id) => {
sent = id;
return new Promise<string>((r) => (answer = r));
});
run.abort();
expect(cancelRequest).toHaveBeenCalledWith(sent);
answer("late");
await expect(reply).resolves.toBe("late");
});
it("leaves a request alone once it answered", async () => {
cancelRequest.mockClear();
const run = new AbortController();
await cancellable(run.signal, async () => "done");
run.abort();
expect(cancelRequest).not.toHaveBeenCalled();
});
it("never sends a request the dialog closed before", async () => {
const run = new AbortController();
run.abort();
const send = vi.fn(async () => "sent");
const err = await cancellable(run.signal, send).catch((e: unknown) => e);
expect(isCancelled(err)).toBe(true);
expect(send).not.toHaveBeenCalled();
});
it("tells the sender once the dialog closed after the request was handed over", async () => {
const run = new AbortController();
let wanted!: () => boolean;
const reply = cancellable(run.signal, async (_id, w) => {
wanted = w;
return "sent";
});
expect(wanted()).toBe(true);
run.abort();
expect(wanted()).toBe(false);
await reply;
});
});
-4
Переглянути файл
@@ -25,9 +25,5 @@ describe("extract interface", () => {
expect(interfaceProblem("Shape", "Shape", 1)).toBe("Interface name should differ from the class name");
expect(interfaceProblem("HasArea", "Shape", 0)).toBe("Select the members to form the interface");
expect(interfaceProblem("HasArea", "Shape", 2)).toBeNull();
// Java identifiers take letters of any script.
expect(interfaceProblem("处理器", "Shape", 1)).toBeNull();
expect(interfaceProblem("Größe", "Shape", 1)).toBeNull();
expect(interfaceProblem("a-b", "Shape", 1)).toBe("Interface name is not a valid identifier");
});
});
+11 -16
Переглянути файл
@@ -17,7 +17,7 @@ import { tx } from "@/platform/i18n";
import { commands, isCancelled, nextRequestId, unavailableText } from "@/platform/ipc";
import { editorService } from "@/workbench/contributions";
import { cannotPerform } from "./catalog";
import { JAVA_NAME, applyEdit, cancellable, confirmProblems } from "./signature";
import { applyEdit, confirmProblems } from "./signature";
/** Languages whose server extracts interfaces through the dialog. */
export const EXTRACT_INTERFACE_LANGUAGES = new Set(["java"]);
@@ -51,6 +51,8 @@ export function memberLabel(m: InterfaceMember): string {
return `${m.name}${params}: ${m.typeName}`;
}
const JAVA_NAME = /^[A-Za-z_$][\w$]*$/;
/** Why the interface can't be extracted yet, or null. */
export function interfaceProblem(name: string, className: string, members: number): string | null {
if (!name) return "No interface name specified";
@@ -125,8 +127,6 @@ export async function extractInterface(
pkg: PackageChoice,
members: readonly string[],
preview: boolean,
/** The dialog closed: nothing is confirmed, previewed or applied any more. */
signal?: AbortSignal,
): Promise<InterfaceOutcome> {
const { view } = request;
if (view.state.doc !== request.text) return { status: "stay", error: "The file changed; open the dialog again" };
@@ -136,32 +136,27 @@ export async function extractInterface(
for (;;) {
await whenSynced(view);
const token: string | null = confirmation;
extracted = await cancellable(signal, (id, wanted) =>
lspRequest(
() => commands.lspExtractInterface(id, request.doc, request.pos, [...members], name, pkg.json, token),
wanted,
),
extracted = await lspRequest(() =>
commands.lspExtractInterface(nextRequestId(), request.doc, request.pos, [...members], name, pkg.json, token),
);
if (signal?.aborted) return { status: "stay" };
const fatal = extracted.problems.find((p) => p.severity === "fatal");
if (fatal || (!extracted.edit && !extracted.confirmation))
return { status: "stay", error: fatal?.message ?? "Nothing to change" };
if (!extracted.confirmation) break;
if (!(await confirmProblems(extracted.problems.map((p) => p.message))) || signal?.aborted)
return { status: "stay" };
if (!(await confirmProblems(extracted.problems.map((p) => p.message)))) return { status: "stay" };
confirmation = extracted.confirmation;
}
} catch (e) {
if (isCancelled(e) || signal?.aborted) return { status: "stay" };
if (isCancelled(e)) return { status: "stay" };
return { status: "stay", error: errorText(e) };
}
const edit = extracted.edit!;
const summary = summarizeWorkspaceEdit(edit);
if (!summary.files) return { status: "stay", error: "Nothing to change" };
const created = edit.files.find((f) => f.kind === "create")?.path;
const apply = async (cancel?: AbortSignal) => {
await applyEdit(view, edit, cancel);
if (created && !cancel?.aborted) await editorService().openFile(created, { focus: true });
const apply = async () => {
await applyEdit(view, edit);
if (created) await editorService().openFile(created, { focus: true });
};
if (preview) {
openPopup({
@@ -172,7 +167,7 @@ export async function extractInterface(
onConfirm: () => void apply(),
});
} else {
await apply(signal);
await apply();
}
return { status: "done" };
}
-4
Переглянути файл
@@ -23,10 +23,6 @@ describe("change signature", () => {
it("tells what keeps the signature from being submitted", () => {
expect(signatureProblem(info)).toBeNull();
expect(signatureProblem({ ...info, methodName: "2x" })).toBe("Method name is not a valid identifier");
expect(signatureProblem({ ...info, methodName: "处理" })).toBeNull();
expect(
signatureProblem({ ...info, parameters: info.parameters.map((p, i) => ({ ...p, name: `数量${i}` })) }),
).toBeNull();
expect(signatureProblem({ ...info, returnType: " " })).toBe("Return type is not specified");
const dup = { ...info, parameters: [info.parameters[0]!, { ...info.parameters[1]!, name: "a" }] };
expect(signatureProblem(dup)).toBe("Duplicate parameter name");
+9 -39
Переглянути файл
@@ -15,7 +15,7 @@ import { showHint } from "@/editor/lsp/hint";
import { openPopup } from "@/editor/lsp/popupStore";
import { summarizeWorkspaceEdit } from "@/editor/lsp/workspaceEdit";
import { tx } from "@/platform/i18n";
import { IpcError, commands, isCancelled, nextRequestId, unavailableText } from "@/platform/ipc";
import { commands, isCancelled, nextRequestId, unavailableText } from "@/platform/ipc";
import { ask } from "@/workbench/messages";
import { cannotPerform } from "./catalog";
@@ -50,8 +50,7 @@ export function signatureText(sig: {
return head + throws;
}
/** A Java identifier: letters of any script, `$` and `_`, then digits and combining marks too. */
export const JAVA_NAME = /^[\p{L}\p{Nl}\p{Sc}\p{Pc}][\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}]*$/u;
const JAVA_NAME = /^[A-Za-z_$][\w$]*$/;
/** Why the edited signature can't be submitted yet, or null. */
export function signatureProblem(sig: MethodSignature): string | null {
@@ -129,40 +128,15 @@ export async function startChangeSignature(view: EditorView): Promise<void> {
}
}
export async function applyEdit(view: EditorView, edit: WorkspaceEdit, signal?: AbortSignal) {
export async function applyEdit(view: EditorView, edit: WorkspaceEdit) {
try {
await whenAllSynced();
// The dialog closed while the editors were syncing: nothing is applied.
if (signal?.aborted) return;
await lspRequest(
() => commands.applyWorkspaceEdit(edit),
() => !signal?.aborted,
);
await lspRequest(() => commands.applyWorkspaceEdit(edit));
} catch (e) {
reportLspError(view, e, true);
}
}
/**
* Sends `send(id, wanted)` with a fresh request id that `signal` cancels. `wanted` goes to
* `lspRequest`, which syncs editors first: a dialog closed meanwhile never sends the request.
*/
export async function cancellable<T>(
signal: AbortSignal | undefined,
send: (id: number, wanted: () => boolean) => Promise<T>,
): Promise<T> {
// Closed before the request went out: it never does (a cancel can't reach an unsent request).
if (signal?.aborted) throw new IpcError({ kind: "cancelled", message: "Cancelled" });
const id = nextRequestId();
const abort = () => void commands.cancelRequest(id);
signal?.addEventListener("abort", abort);
try {
return await send(id, () => !signal?.aborted);
} finally {
signal?.removeEventListener("abort", abort);
}
}
export async function confirmProblems(messages: readonly string[]): Promise<boolean> {
const { button } = await ask({
title: "Problems Detected",
@@ -184,8 +158,6 @@ export async function changeSignature(
signature: MethodSignature,
delegate: boolean,
preview: boolean,
/** The dialog closed: nothing is confirmed, previewed or applied any more. */
signal?: AbortSignal,
): Promise<SignatureOutcome> {
const { view } = request;
if (view.state.doc !== request.text) return { status: "stay", error: "The file changed; open the dialog again" };
@@ -195,20 +167,18 @@ export async function changeSignature(
for (;;) {
await whenSynced(view);
const token: string | null = confirmation;
changed = await cancellable(signal, (id, wanted) =>
lspRequest(() => commands.lspChangeSignature(id, request.doc, request.pos, signature, delegate, token), wanted),
changed = await lspRequest(() =>
commands.lspChangeSignature(nextRequestId(), request.doc, request.pos, signature, delegate, token),
);
if (signal?.aborted) return { status: "stay" };
const fatal = changed.problems.find((p) => p.severity === "fatal");
if (fatal || (!changed.edit && !changed.confirmation))
return { status: "stay", error: fatal?.message ?? "Nothing to change" };
if (!changed.confirmation) break;
if (!(await confirmProblems(changed.problems.map((p) => p.message))) || signal?.aborted)
return { status: "stay" };
if (!(await confirmProblems(changed.problems.map((p) => p.message)))) return { status: "stay" };
confirmation = changed.confirmation;
}
} catch (e) {
if (isCancelled(e) || signal?.aborted) return { status: "stay" };
if (isCancelled(e)) return { status: "stay" };
return { status: "stay", error: errorText(e) };
}
const edit = changed.edit!;
@@ -223,7 +193,7 @@ export async function changeSignature(
onConfirm: () => void applyEdit(view, edit),
});
} else {
await applyEdit(view, edit, signal);
await applyEdit(view, edit);
}
return { status: "done" };
}
-29
Переглянути файл
@@ -281,32 +281,3 @@ it("confirmLeave asks about running processes before closing", async () => {
expect(asked[0]?.title).toContain("app");
expect(asked[0]?.body).toContain("app");
});
it("counts untitled buffers only when leaving for Welcome, and stays when one isn't saved", async () => {
const service = await import("@/workbench/contributions");
const { confirmLeave } = await import("../closeGuard");
let untitled = [7];
const spy = vi.spyOn(service, "maybeEditorService").mockReturnValue({
dirtyDocumentIds: () => [7],
untitledDirtyDocumentIds: () => untitled,
saveAll: vi.fn(async () => {}),
} as never);
try {
// Another project in place keeps the buffer: nothing to ask.
const kept = deps([]);
await expect(confirmLeave(kept.d, "openidea", true)).resolves.toBe(true);
expect(kept.asked).toHaveLength(0);
// Close Project asks; Save with the Save As cancelled keeps the project open, quietly.
const left = deps([{ button: "save", checked: false }]);
await expect(confirmLeave(left.d, "openidea", false)).resolves.toBe(false);
expect(left.asked[0]?.body).toContain("1");
expect(left.d.saveAll).toHaveBeenCalled();
// Saved: the project closes.
untitled = [];
const saved = deps([{ button: "save", checked: false }]);
left.d.saveAll = vi.fn(async () => {});
await expect(confirmLeave(saved.d, "openidea", false)).resolves.toBe(true);
} finally {
spy.mockRestore();
}
});
-17
Переглянути файл
@@ -115,23 +115,6 @@ describe("native window close", () => {
expect(forget).not.toHaveBeenCalled();
});
it("stays open when an untitled buffer's Save As is cancelled", async () => {
vi.mocked(ipc.commands.windowCloseContext).mockResolvedValue({ quitting: false, windows: 2 });
vi.mocked(services.maybeEditorService).mockReturnValue({
forgetSavedTabs: forget,
keepSavedTabs: keep,
dirtyDocumentIds: () => [],
untitledDirtyDocumentIds: () => ["untitled:1"],
cancelClose: vi.fn(),
} as never);
deps.prepareClose = async () => ({ dirty: 1, discard: vi.fn(), commit: vi.fn(), cancel: vi.fn() });
deps.ask = async () => ({ button: "save", checked: false });
const prevented = await close({});
expect(deps.saveAll).toHaveBeenCalledOnce();
expect(prevented).toHaveBeenCalledOnce();
expect(ipc.commands.windowGroupCancelClose).toHaveBeenCalled();
});
it("restores saved tabs if returning to Welcome fails", async () => {
vi.mocked(ipc.commands.closeProject).mockRejectedValue(new Error("close failed"));
const prevented = await close({ closeTabsWithWindow: true });
-2
Переглянути файл
@@ -148,8 +148,6 @@ describe("openProjectInWindow", () => {
expect(wslResolve).toHaveBeenCalledWith(share);
expect(connectRemote).toHaveBeenCalledWith(target, linuxPath);
expect(openProject).not.toHaveBeenCalled();
// The remote window doesn't keep untitled buffers, so the guard counts them.
expect(confirmLeaveProject).toHaveBeenCalledWith(false);
});
it("asks for a new window when this one already has a project", async () => {
+8 -24
Переглянути файл
@@ -12,7 +12,7 @@
* `general.closeWithoutWelcome` is on, in which case it closes. When
* `general.closeTabsWithWindow` is on, that close drops the saved editor tabs.
*/
import { IpcError, commands, isCancelled, isTauri, onIdeEvent, type Settings } from "@/platform/ipc";
import { commands, isTauri, onIdeEvent, type Settings } from "@/platform/ipc";
import { t } from "@/platform/i18n";
import { closeProject, provideLeaveProjectGuard, useProject } from "@/platform/project";
import { workflowSettings } from "@/platform/workflowSettings";
@@ -171,7 +171,6 @@ const defaultDeps: CloseDeps = {
while ((await liveProcesses()).length > 0) await new Promise((r) => setTimeout(r, 100));
},
onSaveFailed: (e) =>
!isCancelled(e) &&
notifications().notify({
level: "error",
title: t("app.unsaved.saveFailed"),
@@ -225,7 +224,7 @@ async function onCloseRequested(deps: CloseDeps): Promise<boolean> {
const s = useProject.getState();
// The last project or LightEdit window can return to Welcome. Otherwise it closes.
if (returnsToWelcome(ctx.quitting, ctx.windows, !!(s.project || s.lightEdit), s.settings)) {
if (await confirmLeave(deps, undefined, false)) {
if (await confirmLeave(deps)) {
forgot = forgetTabs();
try {
await closeProject();
@@ -250,7 +249,7 @@ async function onCloseRequested(deps: CloseDeps): Promise<boolean> {
dirty: dirtyCount(),
project: s.project?.displayName || s.project?.name || null,
},
savingUntitled(deps),
deps,
);
if (!ok) {
await (ctx.quitting ? commands.appCancelQuit() : commands.windowGroupCancelClose());
@@ -270,18 +269,6 @@ async function onCloseRequested(deps: CloseDeps): Promise<boolean> {
}
}
/** Save asks for each untitled buffer's path; one left unsaved (Save As cancelled) keeps the window open. */
function savingUntitled(deps: CloseDeps): CloseDeps {
return {
...deps,
saveAll: async () => {
await deps.saveAll();
if (maybeEditorService()?.untitledDirtyDocumentIds?.().length)
throw new IpcError({ kind: "cancelled", message: "Untitled files were not saved" });
},
};
}
/**
* Unsaved changes before this window opens another project in place or closes it. `project` names
* the project in the prompt when this window doesn't hold it (a comparison window).
@@ -289,19 +276,16 @@ function savingUntitled(deps: CloseDeps): CloseDeps {
export async function confirmLeave(
deps: CloseDeps = defaultDeps,
project = (useProject.getState().project?.displayName || useProject.getState().project?.name) ?? null,
keepUntitled = true,
): Promise<boolean> {
if (!(await closeDocumentWindows())) return false;
const confirmTerminate = workflowSettings().run.confirmTerminate;
// Untitled buffers follow the window into another project: they are neither counted nor
// saved then (the window keeps them open). Closing to Welcome drops them, so they count.
const untitled = new Set(keepUntitled ? (maybeEditorService()?.untitledDirtyDocumentIds?.() ?? []) : []);
// Untitled buffers follow the window across projects: they are neither
// counted nor saved by this guard (the window keeps them open).
const untitled = new Set(maybeEditorService()?.untitledDirtyDocumentIds?.() ?? []);
const saveDeps: CloseDeps =
untitled.size > 0
? { ...deps, saveAll: () => Promise.resolve(maybeEditorService()?.saveAll({ skipUntitled: true })) }
: keepUntitled
? deps
: savingUntitled(deps);
: deps;
return decideClose(
{
quitting: false,
@@ -347,7 +331,7 @@ export function installCloseGuard(deps: CloseDeps = defaultDeps): () => void {
useProject.subscribe((s, prev) => {
if (s.project?.root !== prev.project?.root || s.lightEdit !== prev.lightEdit) dirtyDocs.clear();
}),
provideLeaveProjectGuard((keepUntitled) => confirmLeave(deps, undefined, keepUntitled)),
provideLeaveProjectGuard(() => confirmLeave(deps)),
];
let unlisten: (() => void) | undefined;
let disposed = false;
+3 -3
Переглянути файл
@@ -55,10 +55,10 @@ function openFailed(path: string, e: unknown) {
/** Opens project `path` in this window; true once it is this window's project. */
async function openHere(path: string): Promise<boolean> {
if (!isRemoteWindow() && useProject.getState().project?.root === path) return true;
// A folder of a WSL distro runs there, not as a network folder; the window then drops untitled buffers.
const wsl = await commands.wslResolve(path).catch(() => null);
if (!(await confirmLeaveProject(!wsl))) return false;
if (!(await confirmLeaveProject())) return false;
try {
// A folder of a WSL distro runs there, not as a network folder.
const wsl = await commands.wslResolve(path).catch(() => null);
if (wsl) await connectRemote(wsl.target, wsl.path);
else await openProject(path);
return true;
+1 -1
Переглянути файл
@@ -79,7 +79,7 @@ export function activate(): () => void {
keywords: ["ssh", "remote", "close"],
when: "projectOpen",
run: async () => {
if (!(await confirmLeaveProject(false))) return;
if (!(await confirmLeaveProject())) return;
try {
await disconnectRemote();
} catch (e) {
-3
Переглянути файл
@@ -71,9 +71,6 @@
display: flex;
flex-direction: column;
}
.body[hidden] {
display: none;
}
/* Space a block takes before its diff loads, so the scrollbar is roughly right. */
.placeholder {
height: 160px;
+9 -11
Переглянути файл
@@ -98,15 +98,14 @@ function Block({
/>
)}
</div>
{/* A collapsed block keeps its loaded diff, hidden: unmounting it would release the
working-tree document and, with autosave off, drop its unsaved edits. */}
{near ? (
<div className={styles.body} hidden={collapsed}>
<DiffEditor input={input} fit />
</div>
) : (
!collapsed && <div className={styles.placeholder} />
)}
{!collapsed &&
(near ? (
<div className={styles.body}>
<DiffEditor input={input} fit />
</div>
) : (
<div className={styles.placeholder} />
))}
</section>
);
}
@@ -200,8 +199,7 @@ export function CombinedDiffTab({ input }: { input: EditorInput }) {
{items.length ? (
items.map((item, index) => (
<Block
// Keyed by file alone: switching the layout keeps each block's diff and its documents.
key={item.path}
key={`${item.path}:${mode}`}
item={item}
index={index}
items={items}
-12
Переглянути файл
@@ -354,15 +354,3 @@
[role="treeitem"][aria-selected="true"] .stageButton {
visibility: visible;
}
.inspectionFix {
margin-left: var(--space-2);
padding: 0;
border: none;
background: none;
color: var(--link);
font: inherit;
cursor: pointer;
}
.inspectionFix:hover {
text-decoration: underline;
}
+4 -33
Переглянути файл
@@ -15,7 +15,7 @@ import {
type MouseEvent,
type PointerEvent,
} from "react";
import { tx, txTemplate } from "@/platform/i18n";
import { tx } from "@/platform/i18n";
import clsx from "clsx";
import { executeAction } from "@/platform/actions";
import { basename, dirname } from "@/platform/project";
@@ -961,14 +961,6 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
);
}
const MISSING_BLANK_LINE = "Missing blank line between subject and body";
/** The quick fix for {@link MISSING_BLANK_LINE}: an empty line after the subject. */
export function addBlankLineAfterSubject(message: string): string {
const end = message.indexOf("\n");
return end < 0 ? message : `${message.slice(0, end)}\n${message.slice(end)}`;
}
/** Commit message inspections (Settings › Version Control › Commit). */
export function messageProblems(
message: string,
@@ -984,7 +976,8 @@ export function messageProblems(
const out: string[] = [];
if (c.limitSubject && (lines[0]?.length ?? 0) > c.subjectLimit)
out.push(`Subject line is longer than ${c.subjectLimit} characters`);
if (c.blankLineAfterSubject && lines.length > 1 && lines[1]!.trim() !== "") out.push(MISSING_BLANK_LINE);
if (c.blankLineAfterSubject && lines.length > 1 && lines[1]!.trim() !== "")
out.push("Missing blank line between subject and body");
if (c.limitBody) {
const long = lines.slice(1).findIndex((l) => l.length > c.bodyLimit);
if (long >= 0) out.push(`Body line ${long + 2} is longer than ${c.bodyLimit} characters`);
@@ -1167,29 +1160,7 @@ export function CommitMessageField({
)}
{problems.length > 0 && (
<div className={styles.inspections} role="status">
{problems.map((p, i) => (
<span key={p}>
{i > 0 && " · "}
{txTemplate(p)}
{p === MISSING_BLANK_LINE && (
<button
type="button"
className={styles.inspectionFix}
onClick={() => {
const el = ref.current;
const caret = el ? el.selectionStart + (el.selectionStart > first.length ? 1 : 0) : 0;
useCommit.setState({ message: addBlankLineAfterSubject(message) });
requestAnimationFrame(() => {
el?.focus();
el?.setSelectionRange(caret, caret);
});
}}
>
<T>Add blank line</T>
</button>
)}
</span>
))}
{problems.join(" · ")}
</div>
)}
{checkProblems.length > 0 && (
-5
Переглянути файл
@@ -335,11 +335,6 @@ export function DiffEditor({
};
}, [path, leftKey, rightKey, contextKey]);
// A host that picks the layout (the all-in-one diff's toolbar) switches it in place.
const asked = input_.mode;
useEffect(() => {
if (asked) setOptsState((o) => (o.mode === asked ? o : { ...o, mode: asked }));
}, [asked]);
const setOpts = (patch: Partial<DiffViewOptions>) =>
setOptsState((o) => {
const next = { ...o, ...patch };
+6 -18
Переглянути файл
@@ -83,40 +83,28 @@ describe("the all-in-one diff tab", () => {
expect(screen.getAllByText("src")).toHaveLength(2);
});
it("collapses a file and all files, keeping their diffs (and unsaved edits) loaded", () => {
it("collapses a file and all files", () => {
render(<CombinedDiffTab input={input} />);
const shown = () => screen.queryAllByTestId("block-diff").filter((b) => !b.closest("[hidden]"));
const first = screen.getAllByTestId("block-diff")[0]!;
act(() => {
fireEvent.click(screen.getAllByRole("button", { name: "Collapse File" })[0]!);
});
expect(shown()).toHaveLength(2);
expect(screen.getAllByTestId("block-diff")).toHaveLength(2);
act(() => {
fireEvent.click(screen.getByRole("button", { name: "Collapse All Files" }));
});
expect(shown()).toHaveLength(0);
expect(screen.queryAllByTestId("block-diff")).toHaveLength(0);
act(() => {
fireEvent.click(screen.getByRole("button", { name: "Expand All Files" }));
});
expect(shown()).toHaveLength(3);
// The same diff all along: collapsing never released its document.
expect(screen.getAllByTestId("block-diff")[0]).toBe(first);
expect(screen.getAllByTestId("block-diff")).toHaveLength(3);
});
it("switches every block between side-by-side and unified, collapsed ones too, in place", () => {
it("switches every block between side-by-side and unified", () => {
render(<CombinedDiffTab input={input} />);
const before = screen.getAllByTestId("block-diff");
act(() => {
fireEvent.click(screen.getAllByRole("button", { name: "Collapse File" })[0]!);
});
act(() => {
fireEvent.click(screen.getByRole("button", { name: "Unified Viewer" }));
});
const after = screen.getAllByTestId("block-diff");
expect(after.every((b) => b.dataset.mode === "unified")).toBe(true);
// The same diffs: switching never released their documents (and unsaved edits).
expect(after).toEqual(before);
after.forEach((b, i) => expect(b).toBe(before[i]));
expect(screen.getAllByTestId("block-diff").every((b) => b.dataset.mode === "unified")).toBe(true);
});
it("opens a file's own diff, and goes back to one tab per file", async () => {
-20
Переглянути файл
@@ -59,26 +59,6 @@ describe("staging area inclusion", () => {
expect(plan.stage).toEqual(["/p/src/Unstaged.kt", "/p/src/Gone.kt"]);
});
it("lists and commits a staged addition deleted from disk; the change lists leave it out", () => {
const gone = file("src/New.txt", "added", "deleted");
const status = [gone, unstagedOnly];
expect(isCommitAll(status)).toBe(false);
const plan = planCommit(status, stagingChecks(status));
expect(plan.included.map((f) => f.relPath)).toEqual(["src/New.txt"]);
expect(plan.exclude).toEqual([]);
// Staged shows the addition, Unstaged the deletion.
const tree = buildChangeTree(status, "/p", false, undefined, [], true);
const kinds = (group: string) =>
tree.find((n) => n.group === group)?.children?.flatMap((n) => (n.label === "New.txt" ? [n.kind] : []));
expect(kinds("staged")).toEqual(["added"]);
expect(kinds("unstaged")).toEqual(["deleted"]);
// Without the staging area it is no change against HEAD: listed nowhere, never committed.
expect(buildChangeTree(status, "/p", false).flatMap((n) => n.files.map((f) => f.relPath))).toEqual([
"src/Unstaged.kt",
]);
expect(planCommit(status, new Map([[unstagedOnly.path, "all" as const]])).exclude).toEqual(["/p/src/New.txt"]);
});
it("is not Commit All when only unversioned files changed", () => {
expect(isCommitAll([untracked])).toBe(false);
});
+1 -9
Переглянути файл
@@ -1,6 +1,6 @@
import { describe, expect, it, vi } from "vitest";
import type { BranchInfo } from "@/bindings";
import { addBlankLineAfterSubject, messageProblems, wrapAtMargin } from "../CommitView";
import { messageProblems, wrapAtMargin } from "../CommitView";
import { linkifyIssues } from "../issueLinks";
import {
isProtectedBranch,
@@ -41,14 +41,6 @@ describe("commit message inspections", () => {
expect(messageProblems("x".repeat(20), { ...cfg, limitSubject: false })).toEqual([]);
});
it("adds the missing blank line after the subject", () => {
const fixed = addBlankLineAfterSubject("111\n111");
expect(fixed).toBe("111\n\n111");
expect(messageProblems(fixed, cfg)).toEqual([]);
expect(addBlankLineAfterSubject("subject\nline 2\nline 3")).toBe("subject\n\nline 2\nline 3");
expect(addBlankLineAfterSubject("subject")).toBe("subject");
});
it("wraps body lines at the last space before the margin", () => {
const text = "subject\n\nhello world again";
expect(wrapAtMargin(text, text.length, 12)).toEqual({ text: "subject\n\nhello world\nagain", caret: text.length });
+2 -5
Переглянути файл
@@ -4,7 +4,7 @@ import type { FileStatus, Stash } from "@/bindings";
import { call, commands } from "@/platform/ipc";
import { Checkbox, Dialog, Icon, IconButton, Input, T, fileIconName } from "@/ui";
import { notifications } from "@/workbench/contributions";
import { addedThenDeleted, groupOf, remainingOverrides, renamedFromPath } from "./changes";
import { groupOf, remainingOverrides, renamedFromPath } from "./changes";
import { runCommitChecks } from "./commitChecks";
import { contributedCheckProblems, currentPlan, selectionOf } from "./commitSelection";
import { forgetAmendDraft, keepMessageAfterCommit, rememberMessage, useCommit } from "./commitStore";
@@ -54,10 +54,7 @@ export async function commitChanges(): Promise<string | undefined> {
});
return undefined;
}
const candidates = plan.included.map((f) => ({
path: stripSlash(f.path),
exists: effectiveKind(f) !== "deleted" && !addedThenDeleted(f),
}));
const candidates = plan.included.map((f) => ({ path: stripSlash(f.path), exists: effectiveKind(f) !== "deleted" }));
// IDEA: failed checks show in the commit panel; the next Commit ("Commit Anyway") skips them.
const checked = !useCommit.getState().checkProblems.length;
if (checked) {
+4 -18
Переглянути файл
@@ -57,14 +57,6 @@ export function groupOf(fs: FileStatus): GroupId | null {
return "changes";
}
/**
* Added to the index, then deleted from disk: no change against HEAD, so the change list leaves
* it out, but the staging area shows the staged addition (and the deletion, unstaged).
*/
export function addedThenDeleted(fs: Pick<FileStatus, "staged" | "unstaged">): boolean {
return fs.staged === "added" && fs.unstaged === "deleted";
}
export function isPartiallyStaged(fs: FileStatus): boolean {
return (
!!fs.staged &&
@@ -107,9 +99,7 @@ const KIND_ORDER: GroupId[] = ["conflicts", "changes", "unversioned"];
function fileNode(fs: FileStatus, root: string, group: GroupId, flat: boolean, scope: string = group): ChangeNode {
const path = stripSlash(fs.path);
const rel = relTo(root, path);
// Under Staged / Unstaged, a file without an overall kind (added, then deleted) shows its side's.
const side = group === "staged" ? fs.staged : group === "unstaged" ? fs.unstaged : null;
const kind = effectiveKind(fs) ?? (side === "added" || side === "deleted" ? side : "modified");
const kind = effectiveKind(fs) ?? "modified";
const dir = dirName(rel);
return {
key: `${scope}:${path}`,
@@ -269,7 +259,7 @@ export function buildChangeTree(
const repoRoots = byRepo ? repos : [];
const byGroup = new Map<GroupId, FileStatus[]>();
for (const fs of status) {
const g = groupOf(fs) ?? (byStaging && addedThenDeleted(fs) ? "changes" : null);
const g = groupOf(fs);
if (!g) continue;
let list = byGroup.get(g);
if (!list) byGroup.set(g, (list = []));
@@ -410,12 +400,8 @@ export function planCommit(status: readonly FileStatus[], checks: ReadonlyMap<st
const plan: CommitPlan = { stage: [], exclude: [], included: [], partial: [] };
for (const fs of status) {
if (!groupOf(fs)) {
// Added to the index, then deleted from disk: no change against HEAD, so the commit
// leaves the staged addition out, unless the staging area commits it (checked "staged").
if (addedThenDeleted(fs) && (checks.get(fs.path) ?? checks.get(stripSlash(fs.path))) === "staged") {
plan.included.push(fs);
continue;
}
// Listed nowhere, yet staged: added to the index, then deleted from disk. It is no
// change against HEAD, so the commit must not pick up the staged addition.
if (fs.staged && fs.staged !== "conflicted" && fs.unstaged !== "ignored") plan.exclude.push(stripSlash(fs.path));
continue;
}
+1 -3
Переглянути файл
@@ -5,7 +5,7 @@
*/
import type { ChangelistState, FileStatus } from "@/bindings";
import { useWorkflowSettings, workflowSettings } from "@/platform/workflowSettings";
import { addedThenDeleted, groupOf, type CheckState } from "./changes";
import { groupOf, type CheckState } from "./changes";
import { withListDefaults } from "./changelists";
const enabled = (vcs: { git: { stagingArea: boolean }; commit: { nonModal: boolean } }) =>
@@ -31,8 +31,6 @@ export function stagingChecks(status: readonly FileStatus[]): Map<string, CheckS
const all = isCommitAll(status);
const out = new Map<string, CheckState>();
for (const f of status) {
// A staged addition deleted from disk is committed as staged (nothing against HEAD for Commit All).
if (addedThenDeleted(f) && !all) out.set(f.path, "staged");
if (groupOf(f) !== "changes") continue;
out.set(f.path, all ? "all" : staged(f) ? "staged" : "none");
}
+1 -5
Переглянути файл
@@ -2157,9 +2157,5 @@
"Extract Interface from '{name}'": "Extract Interface from '{name}'",
"The interface could not be extracted": "The interface could not be extracted",
"Extract Interface is not supported for {name}": "Extract Interface is not supported for {name}",
"Package for new interface": "Package for new interface",
"Untitled files were not saved": "Untitled files were not saved",
"Missing blank line between subject and body": "Missing blank line between subject and body",
"Body line {0} is longer than {1} characters": "Body line {0} is longer than {1} characters",
"Add blank line": "Add blank line"
"Package for new interface": "Package for new interface"
}
+1 -5
Переглянути файл
@@ -8540,9 +8540,5 @@
"Extract Interface from '{name}'": "从 '{name}' 提取接口",
"The interface could not be extracted": "无法提取接口",
"Extract Interface is not supported for {name}": "{name} 不支持提取接口",
"Package for new interface": "新接口的软件包",
"Untitled files were not saved": "未命名文件未保存",
"Missing blank line between subject and body": "主题和正文之间缺少空行",
"Body line {0} is longer than {1} characters": "正文第 {0} 行超过 {1} 个字符",
"Add blank line": "添加空行"
"Package for new interface": "新接口的软件包"
}
+5 -11
Переглянути файл
@@ -25,26 +25,20 @@ export const useProject = create<ProjectState>(() => ({
useProject.subscribe((s) => setContext("projectOpening", s.openingPath !== null));
/** `keepUntitled`: the window opens another project in place and keeps its untitled buffers. */
type LeaveGuard = (keepUntitled: boolean) => Promise<boolean>;
let leaveGuard: LeaveGuard | null = null;
let leaveGuard: (() => Promise<boolean>) | null = null;
/** Installs the check run before this window leaves its project (unsaved changes). */
export function provideLeaveProjectGuard(guard: LeaveGuard): () => void {
export function provideLeaveProjectGuard(guard: () => Promise<boolean>): () => void {
leaveGuard = guard;
return () => {
if (leaveGuard === guard) leaveGuard = null;
};
}
/**
* False when the user chose to stay (another project in place, Close Project). Untitled buffers
* follow the window only into another local project (`keepUntitled`); leaving for Welcome or a
* remote host asks about them too.
*/
export function confirmLeaveProject(keepUntitled = true): Promise<boolean> {
/** False when the user chose to stay (another project in place, Close Project). */
export function confirmLeaveProject(): Promise<boolean> {
const s = useProject.getState();
return (s.project || s.lightEdit) && leaveGuard ? leaveGuard(keepUntitled) : Promise.resolve(true);
return (s.project || s.lightEdit) && leaveGuard ? leaveGuard() : Promise.resolve(true);
}
let startupLaunch: Promise<void> | null = null;
-1
Переглянути файл
@@ -105,7 +105,6 @@
display: flex;
gap: 10px;
width: 340px;
max-width: 100%;
/* Never grow past the window: the close button must stay reachable. */
max-height: calc(100vh - 48px);
padding: 14px 34px 14px 14px;
-3
Переглянути файл
@@ -2,8 +2,6 @@
position: fixed;
/* Inside the editor island's bottom-right corner, clear of the right stripe. */
right: 78px;
/* A narrow window narrows the balloons instead of pushing them off its left edge. */
left: 16px;
bottom: calc(var(--h-statusbar) + 16px);
/* Balloons belong to the main window: modal dialogs cover them, like IDEA. */
z-index: calc(var(--z-dialog) - 1);
@@ -14,7 +12,6 @@
pointer-events: none;
}
.balloon {
max-width: 100%;
pointer-events: auto;
animation: slideIn var(--dur) var(--ease);
}
+1 -2
Переглянути файл
@@ -65,8 +65,7 @@ export async function openRemoteProject(
await call(commands.windowOpenRemote(target, path, true));
return true;
}
// The remote host's project doesn't take this window's untitled buffers.
if (!(await confirmLeaveProject(false))) return false;
if (!(await confirmLeaveProject())) return false;
try {
await here();
return true;
+1 -1
Переглянути файл
@@ -69,7 +69,7 @@ export function registerShellActions(): () => void {
category: "File",
when: "projectOpen",
run: async () => {
if (!useProject.getState().project || !(await confirmLeaveProject(false))) return;
if (!useProject.getState().project || !(await confirmLeaveProject())) return;
try {
await closeProject();
} catch (e) {