mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-22 09:39:27 -10:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9b59961127 |
No files matched your search
@@ -80,7 +80,6 @@ Shared agent skills live in `.agents/skills/` (`.claude/skills/` links to them):
|
||||
this worktree's running MCP bridges and actual ports.
|
||||
- `pnpm build` — typecheck + bundle frontend.
|
||||
- `pnpm dogfood:build` / `pnpm dogfood:install` (or `mise run dogfood:build` / `mise run dogfood:install`) — build and locally install the grey-icon dogfood desktop app sharing release settings and data.
|
||||
- `pnpm dogfood:remote <remote_name> [--restart | --no-restart] [--clean]` (or `mise run dogfood:remote <remote_name>`) — sync backend sources to a host from **Tools › SSH Configurations**, build `openidea-server`, and stage it for Remote Development.
|
||||
- `cargo nextest run --workspace` (or `cargo test`), `cargo clippy --workspace --all-targets -- -D warnings`, `cargo fmt --all`.
|
||||
- `cargo test -p ide-host --test language_smoke -- --ignored --exact <language>` — code intelligence
|
||||
on `fixtures/` with that language's real server installed (CI: `Language smoke`, pinned versions).
|
||||
|
||||
Generated
+4
-6
@@ -2361,9 +2361,9 @@ checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
|
||||
|
||||
[[package]]
|
||||
name = "form_urlencoded"
|
||||
version = "1.2.3"
|
||||
version = "1.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "afa489199eaffb1211795df1c6236ce1ad0d41a6fa45250add73e3b02420f06e"
|
||||
checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
|
||||
dependencies = [
|
||||
"percent-encoding",
|
||||
]
|
||||
@@ -4846,7 +4846,6 @@ dependencies = [
|
||||
name = "ide-sdk"
|
||||
version = "0.1.50"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"dunce",
|
||||
"flate2",
|
||||
"ide-core",
|
||||
@@ -5012,7 +5011,6 @@ dependencies = [
|
||||
"ide-core",
|
||||
"ignore",
|
||||
"libc",
|
||||
"notify",
|
||||
"redb",
|
||||
"regex-lite",
|
||||
"serde",
|
||||
@@ -10827,9 +10825,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
|
||||
|
||||
[[package]]
|
||||
name = "url"
|
||||
version = "2.5.9"
|
||||
version = "2.5.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f00cd2407bb42c0ef17be88d4cf020f5cceffd121665bac9b8b9493a369b3b1a"
|
||||
checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
|
||||
dependencies = [
|
||||
"form_urlencoded",
|
||||
"idna",
|
||||
|
||||
@@ -35,8 +35,7 @@ icon set, copied unmodified (some renamed) from JetBrains' open-source repositor
|
||||
→ `maven/`); `plugins/gradle` (`icons/expui/gradle` → `toolwindows/gradle`,
|
||||
`icons/expui/gradleLoadChanges` → `build/gradleLoadChanges`,
|
||||
`icons/expui/gradle`, `icons/gradleSubproject` → `gradle/`);
|
||||
`platform/external-system-impl` (`icons/newui/task` → `externalSystem/task`);
|
||||
`platform/dvcs-impl` (`icons/new/cherryPick` → `vcs/cherryPick`).
|
||||
`platform/external-system-impl` (`icons/newui/task` → `externalSystem/task`).
|
||||
Copyright 2000-2026 JetBrains s.r.o. and contributors. Apache License 2.0 (below).
|
||||
- [intellij-plugins](https://github.com/JetBrains/intellij-plugins) (each plugin
|
||||
carries its own licence): `protobuf/protoeditor-core` (`newui/protoFile` →
|
||||
|
||||
+16
-35
@@ -63,9 +63,6 @@ pub type NewTaskApprovalsHook = Arc<dyn Fn() -> ide_core::settings::NewTaskAppro
|
||||
/// attached projects the user trusts.
|
||||
pub type WorkspaceRootsHook = Arc<dyn Fn() -> Vec<PathBuf> + Send + Sync>;
|
||||
|
||||
/// Returns the project's git executable (`None`: the default), which the tasks' git runs.
|
||||
pub type GitExecutableHook = Arc<dyn Fn() -> Option<PathBuf> + Send + Sync>;
|
||||
|
||||
/// Entry changes are batched for this long before they are sent.
|
||||
const FLUSH_DELAY: Duration = Duration::from_millis(40);
|
||||
/// Updates that arrive this late after `session/load` returns are still replayed history.
|
||||
@@ -188,7 +185,6 @@ struct Shared {
|
||||
security: RwLock<Option<SecurityHook>>,
|
||||
new_task_approvals: RwLock<Option<NewTaskApprovalsHook>>,
|
||||
workspace_roots: RwLock<Option<WorkspaceRootsHook>>,
|
||||
git_executable: RwLock<Option<GitExecutableHook>>,
|
||||
known: Arc<Mutex<HashMap<String, Known>>>,
|
||||
providers: RwLock<Vec<provider::ProviderSpec>>,
|
||||
/// Last probe of each provider.
|
||||
@@ -603,7 +599,6 @@ impl AgentManager {
|
||||
security: RwLock::new(None),
|
||||
new_task_approvals: RwLock::new(None),
|
||||
workspace_roots: RwLock::new(None),
|
||||
git_executable: RwLock::new(None),
|
||||
known,
|
||||
providers,
|
||||
probes: Mutex::new(HashMap::new()),
|
||||
@@ -676,11 +671,6 @@ impl AgentManager {
|
||||
*self.shared.workspace_roots.write() = Some(hook);
|
||||
}
|
||||
|
||||
/// Sets the callback that reads the project's git executable.
|
||||
pub fn set_git_executable_hook(&self, hook: GitExecutableHook) {
|
||||
*self.shared.git_executable.write() = Some(hook);
|
||||
}
|
||||
|
||||
/// The agents (custom ones re-read), whether each is installed, and what they offered last time.
|
||||
pub fn providers(&self) -> Vec<AgentProvider> {
|
||||
let specs = provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
|
||||
@@ -993,15 +983,14 @@ impl AgentManager {
|
||||
}
|
||||
let dir = self.shared.paths.worktrees_dir.clone();
|
||||
let (t, b) = (title.clone(), req.base.clone());
|
||||
let c = vcs(&self.shared, move || worktree::create(&root, &dir, &t, b.as_deref())).await?;
|
||||
let c = blocking(move || worktree::create(&root, &dir, &t, b.as_deref())).await?;
|
||||
(c.path, Some(c.branch), Some(c.base), Some(c.base_commit), BTreeMap::new())
|
||||
}
|
||||
Isolation::Local => {
|
||||
let r = root.clone();
|
||||
let (head, before) = vcs(&self.shared, move || {
|
||||
Ok((worktree::head_of(&r).ok(), worktree::snapshot(&r).unwrap_or_default()))
|
||||
})
|
||||
.await?;
|
||||
let (head, before) =
|
||||
blocking(move || Ok((worktree::head_of(&r).ok(), worktree::snapshot(&r).unwrap_or_default())))
|
||||
.await?;
|
||||
let (base, commit) = head.unzip();
|
||||
(root, None, base, commit, before)
|
||||
}
|
||||
@@ -1035,7 +1024,7 @@ impl AgentManager {
|
||||
} else {
|
||||
let name = format!("{id}.before");
|
||||
let (dir, at, files) = (self.shared.paths.store_dir.join(&name), cwd.clone(), before.clone());
|
||||
match vcs(&self.shared, move || worktree::save_before(&at, &files, &dir)).await {
|
||||
match blocking(move || worktree::save_before(&at, &files, &dir)).await {
|
||||
Ok(saved) => saved.then_some(name),
|
||||
Err(e) => {
|
||||
tracing::warn!("saving the changed files of agent task {id}: {e}");
|
||||
@@ -1837,7 +1826,7 @@ impl AgentManager {
|
||||
let _ = tokio::time::timeout(EXIT_WAIT, peer.exited()).await;
|
||||
}
|
||||
let worktrees = self.shared.paths.worktrees_dir.clone();
|
||||
vcs(&self.shared, move || worktree::remove(&root, &worktrees, &cwd)).await?;
|
||||
blocking(move || worktree::remove(&root, &worktrees, &cwd)).await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -1847,7 +1836,7 @@ impl AgentManager {
|
||||
let task = self.task(id)?;
|
||||
let at = task.base();
|
||||
let (before, touched) = task.attribution();
|
||||
vcs(&self.shared, move || Ok(worktree::made_by_task(at.changes(&before)?, touched.as_deref()))).await
|
||||
blocking(move || Ok(worktree::made_by_task(at.changes(&before)?, touched.as_deref()))).await
|
||||
}
|
||||
|
||||
/// The task's uncommitted changes and, for a worktree task, the commits made since it
|
||||
@@ -1856,7 +1845,7 @@ impl AgentManager {
|
||||
let task = self.task(id)?;
|
||||
let at = task.base();
|
||||
let (before, touched) = task.attribution();
|
||||
vcs(&self.shared, move || {
|
||||
blocking(move || {
|
||||
let mut grouped = at.grouped_changes(&before)?;
|
||||
grouped.uncommitted = worktree::made_by_task(grouped.uncommitted, touched.as_deref());
|
||||
Ok(grouped)
|
||||
@@ -1869,7 +1858,7 @@ impl AgentManager {
|
||||
pub async fn turn_changes(&self, id: &str) -> IdeResult<Vec<AgentChange>> {
|
||||
let (cwd, turn, dir) = self.task(id)?.last_turn();
|
||||
let Some(turn) = turn else { return Ok(Vec::new()) };
|
||||
vcs(&self.shared, move || {
|
||||
blocking(move || {
|
||||
let changed = match &turn.changed {
|
||||
Some(changed) => changed.clone(),
|
||||
None => worktree::changed_in_turn(&cwd, &turn)?.1,
|
||||
@@ -1886,10 +1875,10 @@ impl AgentManager {
|
||||
if view == AgentChangesView::LastTurn {
|
||||
let (cwd, turn, dir) = task.last_turn();
|
||||
let Some(turn) = turn else { return Ok(None) };
|
||||
return vcs(&self.shared, move || worktree::turn_text(&cwd, &path, &turn, &dir)).await;
|
||||
return blocking(move || worktree::turn_text(&cwd, &path, &turn, &dir)).await;
|
||||
}
|
||||
let at = task.base();
|
||||
vcs(&self.shared, move || {
|
||||
blocking(move || {
|
||||
let rev = match view {
|
||||
AgentChangesView::Group => worktree::head_commit(at.cwd())?,
|
||||
_ => at.rev()?,
|
||||
@@ -1923,7 +1912,7 @@ impl AgentManager {
|
||||
let s = task.state.lock();
|
||||
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)), s.touched.clone())
|
||||
};
|
||||
let (restamped, restored) = vcs(&self.shared, move || {
|
||||
let (restamped, restored) = blocking(move || {
|
||||
let (changes, rev) = match view {
|
||||
AgentChangesView::Group => (at.grouped_changes(&before)?.uncommitted, worktree::head_commit(at.cwd())?),
|
||||
AgentChangesView::SinceStart | AgentChangesView::LastTurn => (at.changes(&before)?, at.rev()?),
|
||||
@@ -1979,7 +1968,7 @@ impl AgentManager {
|
||||
let s = task.state.lock();
|
||||
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)))
|
||||
};
|
||||
let restamped = vcs(&self.shared, move || {
|
||||
let restamped = blocking(move || {
|
||||
let changed = match &turn.changed {
|
||||
Some(changed) => changed.clone(),
|
||||
None => worktree::changed_in_turn(&cwd, &turn)?.1,
|
||||
@@ -2036,7 +2025,7 @@ impl AgentManager {
|
||||
let Some(base) = base else {
|
||||
return Err(IdeError::invalid("the task has no base revision to accept from"));
|
||||
};
|
||||
vcs(&self.shared, move || {
|
||||
blocking(move || {
|
||||
let wanted: Vec<AgentChange> = worktree::without_untouched(worktree::changes(&cwd, &base)?, &before)
|
||||
.into_iter()
|
||||
.filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path)))
|
||||
@@ -2291,7 +2280,7 @@ impl Task {
|
||||
/// Records the checkout as a turn starts: what the turn's changes are compared with.
|
||||
async fn checkout_before_turn(&self) {
|
||||
let (cwd, previous, dir) = self.last_turn();
|
||||
let turn = match vcs(&self.shared, move || worktree::start_turn(&cwd, &dir, previous.as_deref())).await {
|
||||
let turn = match blocking(move || worktree::start_turn(&cwd, &dir, previous.as_deref())).await {
|
||||
Ok(turn) => Some(Arc::new(turn)),
|
||||
Err(e) => {
|
||||
tracing::warn!("recording the checkout as a turn of agent task {} starts: {e}", self.id);
|
||||
@@ -2308,9 +2297,7 @@ impl Task {
|
||||
let (cwd, turn, _) = self.last_turn();
|
||||
let Some(turn) = turn else { return };
|
||||
let start = turn.clone();
|
||||
let Ok((in_worktree, all)) = vcs(&self.shared, move || worktree::changed_in_turn(&cwd, &start)).await else {
|
||||
return;
|
||||
};
|
||||
let Ok((in_worktree, all)) = blocking(move || worktree::changed_in_turn(&cwd, &start)).await else { return };
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if !in_worktree.is_empty()
|
||||
@@ -4264,12 +4251,6 @@ async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + '
|
||||
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// [`blocking`] for work that runs git: the repositories it opens run the project's git.
|
||||
async fn vcs<T: Send + 'static>(shared: &Shared, f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
|
||||
let git = shared.git_executable.read().as_ref().and_then(|hook| hook());
|
||||
blocking(move || ide_vcs::with_git_executable(git.as_deref(), f)).await
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod replay;
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -948,12 +948,6 @@ pub struct AgentSkill {
|
||||
/// True when frontmatter sets `disable-model-invocation: true` (defaults to `slashOnly`).
|
||||
#[serde(default)]
|
||||
pub disable_model_invocation: bool,
|
||||
/// True when frontmatter sets `context: fork` (passed through natively to supporting CLIs).
|
||||
#[serde(default)]
|
||||
pub context_fork: bool,
|
||||
/// Optional `paths` / `globs` patterns from frontmatter (passed through natively to supporting CLIs).
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub paths: Vec<String>,
|
||||
/// The `SKILL.md` passes validation (`name` matches its folder, `description` present).
|
||||
pub valid: bool,
|
||||
/// What validation found (`name` mismatch, missing or over-long description…).
|
||||
|
||||
@@ -125,9 +125,10 @@ fn file_name(path: &Path) -> Option<String> {
|
||||
path.file_name()?.to_str().map(str::to_owned)
|
||||
}
|
||||
|
||||
/// The `key: value` lines between the leading `---` fences (folded `>` / `|` values joined).
|
||||
struct Frontmatter {
|
||||
fields: Vec<(String, String)>,
|
||||
lists: Vec<(String, Vec<String>)>,
|
||||
/// Where the body starts.
|
||||
body: usize,
|
||||
}
|
||||
|
||||
@@ -137,42 +138,22 @@ impl Frontmatter {
|
||||
let mut lines = text.split_inclusive('\n');
|
||||
let mut offset = 0;
|
||||
let mut fields: Vec<(String, String)> = Vec::new();
|
||||
let mut lists: Vec<(String, Vec<String>)> = Vec::new();
|
||||
match lines.next() {
|
||||
Some(first) if first.trim_end() == "---" => offset += first.len(),
|
||||
_ => return Self { fields, lists, body: 0 },
|
||||
_ => return Self { fields, body: 0 },
|
||||
}
|
||||
for line in lines {
|
||||
offset += line.len();
|
||||
let line = line.trim_end();
|
||||
if line == "---" {
|
||||
return Self { fields, lists, body: offset };
|
||||
return Self { fields, body: offset };
|
||||
}
|
||||
let unindented_list_item = (line == "-" || line.starts_with("- ") || line.starts_with("-\t"))
|
||||
&& fields.last().is_some_and(|(_, v)| v.is_empty());
|
||||
if line.starts_with([' ', '\t']) || unindented_list_item {
|
||||
let trimmed = line.trim();
|
||||
if let Some(rest) = trimmed.strip_prefix('-')
|
||||
&& (rest.is_empty() || rest.starts_with([' ', '\t']))
|
||||
&& let Some((key, _)) = fields.last()
|
||||
{
|
||||
let item = unquote(rest.trim());
|
||||
if !item.is_empty() {
|
||||
if let Some((_, existing)) = lists.iter_mut().find(|(k, _)| k == key) {
|
||||
existing.push(item.to_owned());
|
||||
} else {
|
||||
lists.push((key.clone(), vec![item.to_owned()]));
|
||||
}
|
||||
}
|
||||
if unindented_list_item {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if line.starts_with([' ', '\t']) {
|
||||
if let Some((_, value)) = fields.last_mut() {
|
||||
if !value.is_empty() {
|
||||
value.push(' ');
|
||||
}
|
||||
value.push_str(trimmed);
|
||||
value.push_str(line.trim());
|
||||
}
|
||||
continue;
|
||||
}
|
||||
@@ -183,15 +164,11 @@ impl Frontmatter {
|
||||
}
|
||||
}
|
||||
// No closing fence: not frontmatter.
|
||||
Self { fields: Vec::new(), lists: Vec::new(), body: 0 }
|
||||
Self { fields: Vec::new(), body: 0 }
|
||||
}
|
||||
|
||||
fn get(&self, key: &str) -> Option<&str> {
|
||||
self.fields.iter().find(|(k, _)| k.eq_ignore_ascii_case(key)).map(|(_, v)| v.as_str())
|
||||
}
|
||||
|
||||
fn list(&self, key: &str) -> Option<&[String]> {
|
||||
self.lists.iter().find(|(k, _)| k.eq_ignore_ascii_case(key)).map(|(_, v)| v.as_slice())
|
||||
self.fields.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str())
|
||||
}
|
||||
|
||||
/// `description`, else the body's first line.
|
||||
@@ -528,8 +505,6 @@ fn parse_skill_file(dir: &Path, folder: &str, text: &str, source: AgentSkillSour
|
||||
let hint = meta.get("argument-hint").map(|h| strip_ansi(h).trim().to_owned()).filter(|h| !h.is_empty());
|
||||
let user_invocable = !meta.get("user-invocable").is_some_and(|v| v.eq_ignore_ascii_case("false"));
|
||||
let disable_model_invocation = meta.get("disable-model-invocation").is_some_and(|v| v.eq_ignore_ascii_case("true"));
|
||||
let context_fork = meta.get("context").is_some_and(|v| strip_ansi(v).trim().eq_ignore_ascii_case("fork"));
|
||||
let paths = parse_skill_paths(&meta);
|
||||
AgentSkill {
|
||||
name,
|
||||
description: truncate(&description),
|
||||
@@ -539,35 +514,11 @@ fn parse_skill_file(dir: &Path, folder: &str, text: &str, source: AgentSkillSour
|
||||
also_in: Vec::new(),
|
||||
user_invocable,
|
||||
disable_model_invocation,
|
||||
context_fork,
|
||||
paths,
|
||||
valid: warnings.is_empty(),
|
||||
warnings,
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_skill_paths(meta: &Frontmatter) -> Vec<String> {
|
||||
for key in ["paths", "globs"] {
|
||||
if let Some(items) = meta.list(key) {
|
||||
let cleaned: Vec<String> =
|
||||
items.iter().map(|s| strip_ansi(s).trim().to_owned()).filter(|s| !s.is_empty()).collect();
|
||||
if !cleaned.is_empty() {
|
||||
return cleaned;
|
||||
}
|
||||
}
|
||||
if let Some(raw) = meta.get(key) {
|
||||
let trimmed = strip_ansi(raw);
|
||||
let inner = trimmed.trim().strip_prefix('[').and_then(|s| s.strip_suffix(']')).unwrap_or(trimmed.trim());
|
||||
let cleaned: Vec<String> =
|
||||
inner.split(',').map(|p| unquote(p.trim()).trim().to_owned()).filter(|p| !p.is_empty()).collect();
|
||||
if !cleaned.is_empty() {
|
||||
return cleaned;
|
||||
}
|
||||
}
|
||||
}
|
||||
Vec::new()
|
||||
}
|
||||
|
||||
/// A skill's mode, as one policy layer of the settings has it.
|
||||
type Policies = BTreeMap<String, AgentSkillPolicy>;
|
||||
|
||||
@@ -1083,8 +1034,6 @@ mod tests {
|
||||
also_in: Vec::new(),
|
||||
user_invocable: true,
|
||||
disable_model_invocation: false,
|
||||
context_fork: false,
|
||||
paths: Vec::new(),
|
||||
valid: true,
|
||||
warnings: Vec::new(),
|
||||
}
|
||||
@@ -1486,40 +1435,4 @@ mod tests {
|
||||
let _ = stage(&farm, "claude", &off_states, &ws, Some(&home)).unwrap();
|
||||
assert!(!farm.join(".claude/skills/release-notes").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_context_fork_and_paths_frontmatter_and_preserves_file_on_stage() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let ws = root.join("ws");
|
||||
let raw_md = "---\n\
|
||||
name: verify-ux\n\
|
||||
description: Verify UX layouts in an isolated subagent\n\
|
||||
context: fork\n\
|
||||
paths:\n\
|
||||
- \"src/**/*.tsx\"\n\
|
||||
- crates/ide-agent/**/*.rs\n\
|
||||
---\n\nRun visual checks.\n";
|
||||
write(&ws.join(".openidea/skills/verify-ux/SKILL.md"), raw_md);
|
||||
write(
|
||||
&ws.join(".agents/skills/inline-globs/SKILL.md"),
|
||||
"---\nname: inline-globs\ndescription: Scoped by globs\nglobs: [\"e2e/*.spec.ts\", \"src/ui/*.tsx\"]\n---\n",
|
||||
);
|
||||
|
||||
let found = discover_skills(&ws, None);
|
||||
let verify = found.iter().find(|s| s.name == "verify-ux").unwrap();
|
||||
assert!(verify.context_fork);
|
||||
assert_eq!(verify.paths, ["src/**/*.tsx", "crates/ide-agent/**/*.rs"]);
|
||||
|
||||
let inline = found.iter().find(|s| s.name == "inline-globs").unwrap();
|
||||
assert!(!inline.context_fork);
|
||||
assert_eq!(inline.paths, ["e2e/*.spec.ts", "src/ui/*.tsx"]);
|
||||
|
||||
// Staging passes `SKILL.md` through untouched so native CLIs execute `context: fork` / `paths`.
|
||||
let states = resolve(found, None, &BTreeMap::new(), &BTreeMap::new(), true);
|
||||
let farm = farm_dir(&root.join("store"), "fork-passthrough");
|
||||
let _ = stage(&farm, "copilot", &states, &ws, None).unwrap();
|
||||
let staged_md = std::fs::read_to_string(farm.join("copilot/verify-ux/SKILL.md")).unwrap();
|
||||
assert_eq!(staged_md, raw_md);
|
||||
}
|
||||
}
|
||||
@@ -20,72 +20,7 @@ pub struct IdeError {
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "type", rename_all = "camelCase")]
|
||||
pub enum ErrorData {
|
||||
Tool {
|
||||
tool: String,
|
||||
missing: bool,
|
||||
},
|
||||
/// A non-fast-forward push from the current branch to its configured upstream.
|
||||
PushRejected {
|
||||
source: String,
|
||||
upstream: String,
|
||||
divergence: Option<Box<PushDivergence>>,
|
||||
/// Other refs may already have been published in the same push.
|
||||
#[specta(optional)]
|
||||
report: Option<Box<PushReport>>,
|
||||
},
|
||||
/// Git updated some refs before a later ref or push URL failed.
|
||||
PushPartiallyApplied {
|
||||
report: Box<PushReport>,
|
||||
},
|
||||
/// A conflicted history replay left an amend commit ready to keep separately.
|
||||
AmendConflict {
|
||||
commit: String,
|
||||
},
|
||||
}
|
||||
|
||||
/// Git's reported result for each destination ref. A remote with several push URLs can
|
||||
/// report more than one result for the same ref.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
pub struct PushReport {
|
||||
pub remote: Option<String>,
|
||||
pub refs: Vec<PushRefResult>,
|
||||
}
|
||||
|
||||
impl PushReport {
|
||||
pub fn new(remote: Option<String>) -> Self {
|
||||
Self { remote, refs: Vec::new() }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
pub struct PushRefResult {
|
||||
pub reference: String,
|
||||
pub status: PushRefStatus,
|
||||
/// The number of commits between the tips Git reports for a fast-forward.
|
||||
pub commits: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum PushRefStatus {
|
||||
FastForward,
|
||||
Forced,
|
||||
Created,
|
||||
UpToDate,
|
||||
Deleted,
|
||||
}
|
||||
|
||||
/// The two tips shown in the rejected-push dialog. A retry must use this lease
|
||||
/// even if a fetch advances the remote-tracking branch while the dialog is open.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PushDivergence {
|
||||
pub source: String,
|
||||
pub remote: String,
|
||||
pub target: String,
|
||||
pub local_tip: String,
|
||||
pub remote_tip: String,
|
||||
pub remote_commits: u32,
|
||||
Tool { tool: String, missing: bool },
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -180,13 +115,4 @@ mod tests {
|
||||
serde_json::json!({"kind":"unavailable","message":"no server","data":null})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn older_tracked_push_rejections_need_no_report() {
|
||||
let data: ErrorData = serde_json::from_str(
|
||||
r#"{"type":"pushRejected","source":"main","upstream":"origin/main","divergence":null}"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert!(matches!(data, ErrorData::PushRejected { report: None, .. }));
|
||||
}
|
||||
}
|
||||
@@ -5,10 +5,6 @@ use std::path::Path;
|
||||
#[cfg(windows)]
|
||||
use std::process::Stdio;
|
||||
use std::process::{Child, Command};
|
||||
|
||||
pub const ASKPASS_PORT_ENV: &str = "OPENIDEA_ASKPASS_PORT";
|
||||
/// The IDE's askpass helper may answer with saved credentials only.
|
||||
pub const ASKPASS_SILENT_ENV: &str = "OPENIDEA_ASKPASS_SILENT";
|
||||
use std::sync::{Arc, RwLock};
|
||||
use std::time::Duration;
|
||||
|
||||
|
||||
@@ -1206,7 +1206,6 @@ pub struct LanguagesSettings {
|
||||
pub typescript: TypeScriptSettings,
|
||||
pub prettier: ExternalFormatterSettings,
|
||||
pub oxfmt: ExternalFormatterSettings,
|
||||
pub biome: ExternalFormatterSettings,
|
||||
pub ruff: ExternalFormatterSettings,
|
||||
pub java: JavaSettings,
|
||||
pub ruby: RubySettings,
|
||||
@@ -1227,10 +1226,6 @@ impl Default for LanguagesSettings {
|
||||
typescript: TypeScriptSettings::default(),
|
||||
prettier: ExternalFormatterSettings::default(),
|
||||
oxfmt: ExternalFormatterSettings::default(),
|
||||
biome: ExternalFormatterSettings {
|
||||
languages: BIOME_LANGUAGES.iter().map(|&l| l.into()).collect(),
|
||||
..ExternalFormatterSettings::default()
|
||||
},
|
||||
ruff: ExternalFormatterSettings {
|
||||
languages: vec!["python".into()],
|
||||
..ExternalFormatterSettings::default()
|
||||
@@ -1302,7 +1297,6 @@ impl LanguagesSettings {
|
||||
match tool {
|
||||
ExternalFormatter::Prettier => &self.prettier,
|
||||
ExternalFormatter::Oxfmt => &self.oxfmt,
|
||||
ExternalFormatter::Biome => &self.biome,
|
||||
ExternalFormatter::Ruff => &self.ruff,
|
||||
}
|
||||
}
|
||||
@@ -1314,7 +1308,6 @@ impl LanguagesSettings {
|
||||
pub enum ExternalFormatter {
|
||||
Prettier,
|
||||
Oxfmt,
|
||||
Biome,
|
||||
Ruff,
|
||||
}
|
||||
|
||||
@@ -1324,21 +1317,16 @@ impl ExternalFormatter {
|
||||
match self {
|
||||
Self::Prettier => "prettier",
|
||||
Self::Oxfmt => "oxfmt",
|
||||
Self::Biome => "biome",
|
||||
Self::Ruff => "ruff",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The languages Biome formats (of those Prettier formats).
|
||||
pub const BIOME_LANGUAGES: [&str; 8] =
|
||||
["css", "graphql", "javascript", "javascriptreact", "typescript", "typescriptreact", "json", "jsonc"];
|
||||
|
||||
/// An external formatter (Prettier, oxfmt, Biome, Ruff) and the languages it formats.
|
||||
/// An external formatter (Prettier, oxfmt, Ruff) and the languages it formats.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct ExternalFormatterSettings {
|
||||
/// Empty path: project node_modules (Prettier/oxfmt/Biome), managed installation, then PATH.
|
||||
/// Empty path: project node_modules (Prettier/oxfmt), managed installation, then PATH.
|
||||
pub path: String,
|
||||
/// Ruff only: directory containing its configuration, or a configuration file.
|
||||
pub configuration_directory: String,
|
||||
|
||||
@@ -11,7 +11,6 @@ use std::collections::BTreeMap;
|
||||
pub struct VcsSettings {
|
||||
/// Colour folders that contain changed files (project tree, tabs).
|
||||
pub show_dirty_directories: bool,
|
||||
pub create_changelists_automatically: bool,
|
||||
/// Diffs the user opens show in an editor tab; off, in a separate window.
|
||||
pub diff_as_editor_tab: bool,
|
||||
/// Stop file history (Show History) after `history_limit` commits.
|
||||
@@ -58,7 +57,6 @@ impl Default for VcsSettings {
|
||||
Self {
|
||||
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
|
||||
show_dirty_directories: false,
|
||||
create_changelists_automatically: false,
|
||||
diff_as_editor_tab: true,
|
||||
limit_history: true,
|
||||
history_limit: 1000,
|
||||
@@ -72,66 +70,9 @@ impl Default for VcsSettings {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum EmptyCherryPickAction {
|
||||
#[default]
|
||||
Skip,
|
||||
CreateEmpty,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum StashDiffTarget {
|
||||
#[default]
|
||||
Local,
|
||||
Parent,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum GitSaveChangesPolicy {
|
||||
#[default]
|
||||
Shelve,
|
||||
Stash,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum FetchTagsMode {
|
||||
#[default]
|
||||
Auto,
|
||||
Sync,
|
||||
Always,
|
||||
Never,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum GitAnnotateMovement {
|
||||
#[default]
|
||||
None,
|
||||
WithinFile,
|
||||
AcrossFiles,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct GitAnnotateSettings {
|
||||
pub ignore_whitespace: bool,
|
||||
pub movement: GitAnnotateMovement,
|
||||
}
|
||||
|
||||
impl Default for GitAnnotateSettings {
|
||||
fn default() -> Self {
|
||||
Self { ignore_whitespace: true, movement: GitAnnotateMovement::None }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct GitSettings {
|
||||
pub annotate: GitAnnotateSettings,
|
||||
/// Show blame after the current editor line.
|
||||
pub inline_blame: bool,
|
||||
/// A click (or Enter / Space) on the inline blame label opens its commit; off, the
|
||||
@@ -142,29 +83,20 @@ pub struct GitSettings {
|
||||
pub sync_branch_operations: bool,
|
||||
/// Path to the git executable; empty = auto-detect.
|
||||
pub executable: String,
|
||||
/// Clone all submodules along with the root repository.
|
||||
pub clone_submodules: bool,
|
||||
/// Default of Update Project: `merge` | `rebase`.
|
||||
pub update_method: String,
|
||||
/// Where Git operations keep local changes temporarily.
|
||||
pub save_changes_policy: GitSaveChangesPolicy,
|
||||
/// Push rejected (non-fast-forward): update the branch and push again.
|
||||
pub auto_update_on_push_rejected: bool,
|
||||
pub warn_crlf: bool,
|
||||
pub warn_detached_head: bool,
|
||||
/// Background check for incoming commits: `auto` | `always` | `check` | `never`.
|
||||
/// Background check for incoming commits: `auto` | `always` | `never`.
|
||||
pub incoming_check: String,
|
||||
/// Minutes between background checks for incoming commits.
|
||||
pub incoming_check_interval: u32,
|
||||
/// How an explicit fetch or project update handles remote tags.
|
||||
pub fetch_tags_mode: FetchTagsMode,
|
||||
/// Branch name globs, `;`/`,`-separated; force push to them is prohibited.
|
||||
pub protected_branches: String,
|
||||
/// Initial state of Commit Options › Sign-off Commit.
|
||||
pub sign_off: bool,
|
||||
/// Add Git's origin line when cherry-picking commits from protected remote branches.
|
||||
pub add_cherry_pick_origin: bool,
|
||||
pub empty_cherry_pick: EmptyCherryPickAction,
|
||||
/// Ask before committing files larger than `large_file_mb`.
|
||||
pub warn_large_files: bool,
|
||||
pub large_file_mb: u32,
|
||||
@@ -176,8 +108,6 @@ pub struct GitSettings {
|
||||
pub push_dialog_only_protected: bool,
|
||||
/// Stashes and shelves share one tab.
|
||||
pub combine_stash_and_shelf: bool,
|
||||
/// What the stash browser compares its saved files against.
|
||||
pub stash_diff_target: StashDiffTarget,
|
||||
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
|
||||
/// stage and unstage instead of inclusion checkboxes, and no change lists.
|
||||
pub staging_area: bool,
|
||||
@@ -189,32 +119,25 @@ pub struct GitSettings {
|
||||
impl Default for GitSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
annotate: GitAnnotateSettings::default(),
|
||||
inline_blame: false,
|
||||
inline_blame_clickable: true,
|
||||
show_branch_in_project_view: false,
|
||||
sync_branch_operations: true,
|
||||
executable: String::new(),
|
||||
clone_submodules: true,
|
||||
update_method: "merge".into(),
|
||||
save_changes_policy: GitSaveChangesPolicy::default(),
|
||||
auto_update_on_push_rejected: false,
|
||||
warn_crlf: true,
|
||||
warn_detached_head: true,
|
||||
incoming_check: "auto".into(),
|
||||
incoming_check_interval: 15,
|
||||
fetch_tags_mode: FetchTagsMode::Auto,
|
||||
protected_branches: "master; main".into(),
|
||||
sign_off: false,
|
||||
add_cherry_pick_origin: true,
|
||||
empty_cherry_pick: EmptyCherryPickAction::Skip,
|
||||
warn_large_files: true,
|
||||
large_file_mb: 50,
|
||||
warn_bad_file_names: true,
|
||||
show_push_dialog: true,
|
||||
push_dialog_only_protected: false,
|
||||
combine_stash_and_shelf: false,
|
||||
stash_diff_target: StashDiffTarget::default(),
|
||||
staging_area: false,
|
||||
cli_status: false,
|
||||
}
|
||||
@@ -229,11 +152,9 @@ pub struct CommitSettings {
|
||||
/// window and a Commit dialog.
|
||||
pub non_modal: bool,
|
||||
pub include_changes_by_default: bool,
|
||||
pub commit_all_when_nothing_staged: bool,
|
||||
/// Start with an empty message instead of the last one / the changelist's.
|
||||
pub clear_initial_message: bool,
|
||||
pub analyze_code: bool,
|
||||
pub postpone_slow_checks: bool,
|
||||
pub check_todo: bool,
|
||||
pub reformat: bool,
|
||||
pub optimize_imports: bool,
|
||||
@@ -271,10 +192,8 @@ impl Default for CommitSettings {
|
||||
Self {
|
||||
non_modal: true,
|
||||
include_changes_by_default: true,
|
||||
commit_all_when_nothing_staged: true,
|
||||
clear_initial_message: false,
|
||||
analyze_code: true,
|
||||
postpone_slow_checks: true,
|
||||
check_todo: true,
|
||||
reformat: false,
|
||||
optimize_imports: false,
|
||||
@@ -703,14 +622,6 @@ impl Default for AgentSecuritySettings {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn clone_submodules_defaults_on_and_can_be_disabled() {
|
||||
let missing: GitSettings = serde_json::from_str("{}").unwrap();
|
||||
let off: GitSettings = serde_json::from_str(r#"{"cloneSubmodules":false}"#).unwrap();
|
||||
assert!(missing.clone_submodules);
|
||||
assert!(!off.clone_submodules);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn git_settings_without_sync_key_execute_on_all_repositories() {
|
||||
let missing: GitSettings = serde_json::from_str("{}").unwrap();
|
||||
|
||||
@@ -21,7 +21,7 @@ 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, Instant};
|
||||
use std::time::Duration;
|
||||
|
||||
type Changes = Vec<(OsString, Option<OsString>)>;
|
||||
|
||||
@@ -355,34 +355,20 @@ fn run_post_start(cmd: &LifecycleCommand, root: &Path, sink: &SharedSink, cancel
|
||||
/// Runs `argv` in `root` with the children's environment, its stdout and stderr line by line
|
||||
/// to `on_line`; `Err` says how it failed.
|
||||
fn run_one(argv: &[String], root: &Path, cancel: &CancellationToken, on_line: &dyn Fn(String)) -> Result<(), String> {
|
||||
let (program, args) = argv.split_first().ok_or("empty command")?;
|
||||
let mut command = Command::new(program);
|
||||
command.args(args);
|
||||
run_command(command, root, cancel, None, on_line)
|
||||
}
|
||||
|
||||
pub(crate) fn run_command(
|
||||
mut command: Command,
|
||||
root: &Path,
|
||||
cancel: &CancellationToken,
|
||||
timeout: Option<Duration>,
|
||||
mut on_line: impl FnMut(String),
|
||||
) -> Result<(), String> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err("cancelled".into());
|
||||
}
|
||||
let program = command.get_program().to_string_lossy().into_owned();
|
||||
command
|
||||
let (program, args) = argv.split_first().ok_or("empty command")?;
|
||||
let mut child = ide_core::process::prepare(&mut Command::new(program))
|
||||
.args(args)
|
||||
.current_dir(root)
|
||||
.envs(ide_core::process::shell_env())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped());
|
||||
let mut child = ide_core::process::prepare(ide_core::process::own_group(&mut command))
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()
|
||||
.map_err(|e| format!("cannot start {program}: {e}"))?;
|
||||
let started = Instant::now();
|
||||
let (tx, rx) = std::sync::mpsc::sync_channel::<String>(64);
|
||||
let (tx, rx) = std::sync::mpsc::channel::<String>();
|
||||
let pipes: [Option<Box<dyn Read + Send>>; 2] = [
|
||||
child.stdout.take().map(|p| Box::new(p) as Box<dyn Read + Send>),
|
||||
child.stderr.take().map(|p| Box::new(p) as Box<dyn Read + Send>),
|
||||
@@ -400,31 +386,29 @@ pub(crate) fn run_command(
|
||||
}
|
||||
drop(tx);
|
||||
let status = loop {
|
||||
if cancel.is_cancelled() {
|
||||
ide_core::process::kill_tree(&mut child);
|
||||
return Err("cancelled".into());
|
||||
}
|
||||
if timeout.is_some_and(|duration| started.elapsed() >= duration) {
|
||||
ide_core::process::kill_tree(&mut child);
|
||||
return Err("timed out".into());
|
||||
}
|
||||
match rx.recv_timeout(Duration::from_millis(50)) {
|
||||
Ok(line) => on_line(line),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {}
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => std::thread::sleep(Duration::from_millis(50)),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => break child.wait(),
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return Err("cancelled".into());
|
||||
}
|
||||
// A process it started in the background may keep the pipes open: the command is done.
|
||||
if let Some(status) = child.try_wait().map_err(|e| e.to_string())? {
|
||||
let deadline = Instant::now() + Duration::from_secs(1);
|
||||
if let Ok(Some(status)) = child.try_wait() {
|
||||
let deadline = std::time::Instant::now() + Duration::from_secs(1);
|
||||
while let Ok(line) = rx.recv_timeout(Duration::from_millis(100)) {
|
||||
on_line(line);
|
||||
if Instant::now() > deadline {
|
||||
if std::time::Instant::now() > deadline {
|
||||
break;
|
||||
}
|
||||
}
|
||||
break status;
|
||||
break Ok(status);
|
||||
}
|
||||
};
|
||||
}
|
||||
.map_err(|e| e.to_string())?;
|
||||
match status.code() {
|
||||
Some(0) => Ok(()),
|
||||
Some(code) => Err(format!("exited with code {code}")),
|
||||
|
||||
@@ -2,36 +2,17 @@
|
||||
|
||||
use crate::Host;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::settings::{BIOME_LANGUAGES, ExternalFormatter, LanguagesSettings, Settings};
|
||||
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, IpcPath, LanguageId, Pos, Range, TextEdit};
|
||||
use ide_core::settings::{ExternalFormatter, LanguagesSettings, Settings};
|
||||
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, Pos, Range, TextEdit};
|
||||
use ide_language::{LanguageConfig, PhpAlignment, Syntax};
|
||||
use ide_lsp::types::FormatOptions;
|
||||
use ide_tools::{Tools, formatter};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::path::Path;
|
||||
|
||||
const OXFMT_CONFIGS: [&str; 4] = [".oxfmtrc.json", ".oxfmtrc.jsonc", "oxfmt.config.ts", "oxfmt.config.mts"];
|
||||
/// A Biome configuration, or Biome installed as a project dependency (it then uses its defaults).
|
||||
const BIOME_MARKERS: [&str; 3] = ["biome.json", "biome.jsonc", "node_modules/@biomejs/biome/package.json"];
|
||||
|
||||
/// Reformat Code uses Biome below a Biome configuration or installation, unless the nearest
|
||||
/// configuration turns its formatter off (Biome lints, another tool formats).
|
||||
fn biome_formats(file: &Path) -> bool {
|
||||
let config = ["biome.json", "biome.jsonc"]
|
||||
.iter()
|
||||
.filter_map(|name| formatter::find_up(file, Path::new(name)))
|
||||
.max_by_key(|path| path.components().count());
|
||||
match config {
|
||||
Some(config) => !std::fs::read_to_string(&config)
|
||||
.ok()
|
||||
.and_then(|text| serde_json::from_str::<serde_json::Value>(&ide_core::jsonc::strip(&text)).ok())
|
||||
.is_some_and(|v| v.pointer("/formatter/enabled") == Some(&serde_json::Value::Bool(false))),
|
||||
None => BIOME_MARKERS.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some()),
|
||||
}
|
||||
}
|
||||
|
||||
fn supports_external_format(language: &LanguageConfig, tool: ExternalFormatter) -> bool {
|
||||
match language.formatter.as_ref().map(|f| f.tool.as_str()) {
|
||||
Some("prettier") if tool == ExternalFormatter::Biome => BIOME_LANGUAGES.contains(&language.id.as_str()),
|
||||
Some("prettier") => matches!(tool, ExternalFormatter::Prettier | ExternalFormatter::Oxfmt),
|
||||
Some("ruff") => tool == ExternalFormatter::Ruff,
|
||||
_ => false,
|
||||
@@ -39,9 +20,9 @@ fn supports_external_format(language: &LanguageConfig, tool: ExternalFormatter)
|
||||
}
|
||||
|
||||
/// The external formatter of a file, for a language with an external formatter.
|
||||
/// `forced` names the tool (Reformat with Prettier, oxfmt, Biome, or Ruff). Ruff is
|
||||
/// the base formatter for Python; Biome, then oxfmt, can replace Prettier for their
|
||||
/// languages when configured or selected. A tool that cannot format the language is
|
||||
/// `forced` names the tool (Reformat with Prettier, oxfmt, or Ruff). Ruff is
|
||||
/// the base formatter for Python; oxfmt can replace Prettier for its languages
|
||||
/// when configured or selected. A tool that cannot format the language is
|
||||
/// rejected even when explicitly requested.
|
||||
fn external_tool(
|
||||
forced: Option<ExternalFormatter>,
|
||||
@@ -49,7 +30,7 @@ fn external_tool(
|
||||
file: &Path,
|
||||
settings: &LanguagesSettings,
|
||||
) -> IdeResult<Option<ExternalFormatter>> {
|
||||
use ExternalFormatter::{Biome, Oxfmt, Prettier, Ruff};
|
||||
use ExternalFormatter::{Oxfmt, Prettier, Ruff};
|
||||
let Some(language) = language.filter(|l| l.formatter.is_some()) else {
|
||||
return match forced {
|
||||
Some(tool) => Err(IdeError::invalid(format!(
|
||||
@@ -75,11 +56,8 @@ fn external_tool(
|
||||
if language.formatter.as_ref().is_some_and(|f| f.tool == "ruff") {
|
||||
return Ok(enabled(Ruff).then_some(Ruff));
|
||||
}
|
||||
let found = |names: &[&str]| names.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some());
|
||||
let biome = enabled(Biome) && supports_external_format(language, Biome);
|
||||
Ok(if biome && (settings.biome.prefer || biome_formats(file)) {
|
||||
Some(Biome)
|
||||
} else if enabled(Oxfmt) && (settings.oxfmt.prefer || found(&OXFMT_CONFIGS)) {
|
||||
let oxfmt_config = || OXFMT_CONFIGS.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some());
|
||||
Ok(if enabled(Oxfmt) && (settings.oxfmt.prefer || oxfmt_config()) {
|
||||
Some(Oxfmt)
|
||||
} else {
|
||||
enabled(Prettier).then_some(Prettier)
|
||||
@@ -173,58 +151,10 @@ pub async fn format(
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let project = host.project(window)?;
|
||||
let snap = project.documents.snapshot(doc)?;
|
||||
let source = FormatSource {
|
||||
path: snap.path,
|
||||
language: snap.language,
|
||||
text: snap.text,
|
||||
doc: Some(doc),
|
||||
version: snap.version,
|
||||
read_only: snap.read_only,
|
||||
};
|
||||
format_source(host, window, &project, source, range, options).await
|
||||
}
|
||||
|
||||
/// Format a separate snapshot using the file's language, settings and formatter.
|
||||
pub async fn format_text(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
path: PathBuf,
|
||||
text: String,
|
||||
options: FormatOptions,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let project = host.project(window)?;
|
||||
if !path.is_absolute() || path.file_name().is_none() {
|
||||
return Err(IdeError::invalid("formatting requires a file path"));
|
||||
}
|
||||
if text.len() as u64 > ide_vfs::LARGE_FILE_THRESHOLD {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let language = project.documents.language_of(&path, text.lines().next()).language;
|
||||
let source = FormatSource { path: path.into(), language, text, doc: None, version: 0, read_only: false };
|
||||
format_source(host, window, &project, source, None, options).await
|
||||
}
|
||||
|
||||
struct FormatSource {
|
||||
path: IpcPath,
|
||||
language: LanguageId,
|
||||
text: String,
|
||||
doc: Option<DocId>,
|
||||
version: u32,
|
||||
read_only: bool,
|
||||
}
|
||||
|
||||
async fn format_source(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
project: &crate::Project,
|
||||
snap: FormatSource,
|
||||
range: Option<Range>,
|
||||
options: FormatOptions,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let settings = project.settings.effective();
|
||||
let alignment = php_alignment(&settings, &snap.language);
|
||||
let original = alignment.any().then(|| (snap.language.clone(), snap.text.clone()));
|
||||
let Some(edits) = provider_edits(host, window, project, snap, settings, range, options).await? else {
|
||||
let Some(edits) = provider_edits(host, window, &project, snap, settings, range, options).await? else {
|
||||
return Ok(Vec::new());
|
||||
};
|
||||
let Some((language, text)) = original else {
|
||||
@@ -305,12 +235,12 @@ async fn provider_edits(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
project: &crate::Project,
|
||||
snap: FormatSource,
|
||||
snap: ide_workspace::documents::DocumentInfo,
|
||||
settings: Settings,
|
||||
range: Option<Range>,
|
||||
options: FormatOptions,
|
||||
) -> IdeResult<Option<Vec<TextEdit>>> {
|
||||
let doc = snap.doc;
|
||||
let doc = snap.id;
|
||||
let language = project.languages.get(&snap.language);
|
||||
if options.tool.is_none()
|
||||
&& let Some(id) = settings.languages.plugin_formatters.get(snap.language.as_str()).filter(|s| !s.is_empty())
|
||||
@@ -377,10 +307,7 @@ async fn provider_edits(
|
||||
if let Some(tool) = selected
|
||||
&& options.tool.is_none()
|
||||
&& !settings.languages.formatter(tool).prefer
|
||||
&& match doc {
|
||||
Some(doc) => project.lsp.can_format(doc).await?,
|
||||
None => project.lsp.can_format_text(&snap.path, &snap.language).await,
|
||||
}
|
||||
&& project.lsp.can_format(doc).await?
|
||||
{
|
||||
selected = None;
|
||||
}
|
||||
@@ -388,10 +315,7 @@ async fn provider_edits(
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
}
|
||||
let edits = match doc {
|
||||
Some(doc) => project.lsp.format(doc, range, options).await?,
|
||||
None => project.lsp.format_text(&snap.path, &snap.language, &snap.text, options).await?,
|
||||
};
|
||||
let edits = project.lsp.format(doc, range, options).await?;
|
||||
let text = snap.text;
|
||||
return tokio::task::spawn_blocking(move || Some(minimal_edits(&text, edits)))
|
||||
.await
|
||||
@@ -461,7 +385,7 @@ async fn provider_edits(
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ExternalFormatter::{Biome, Oxfmt, Prettier, Ruff};
|
||||
use ExternalFormatter::{Oxfmt, Prettier, Ruff};
|
||||
use ide_core::LanguageId;
|
||||
use ide_language::LanguageRegistry;
|
||||
|
||||
@@ -504,40 +428,6 @@ mod tests {
|
||||
assert_eq!(prettier.message, "Prettier cannot format Python files");
|
||||
let oxfmt = tool(Some(Oxfmt), "python", file, &settings).unwrap_err();
|
||||
assert_eq!(oxfmt.message, "oxfmt cannot format Python files");
|
||||
let biome = tool(Some(Biome), "python", file, &settings).unwrap_err();
|
||||
assert_eq!(biome.message, "Biome cannot format Python files");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn biome_config_or_dependency_selects_biome_for_its_languages() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
std::fs::create_dir_all(root.join("web/src")).unwrap();
|
||||
let (web, api, readme) = (root.join("web/src/app.ts"), root.join("api/main.ts"), root.join("web/README.md"));
|
||||
let mut settings = LanguagesSettings::default();
|
||||
for marker in BIOME_MARKERS {
|
||||
let path = root.join("web").join(marker);
|
||||
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
std::fs::write(&path, "{}").unwrap();
|
||||
assert_eq!(tool(None, "typescript", &web, &settings).unwrap(), Some(Biome), "{marker}");
|
||||
assert_eq!(tool(None, "typescript", &api, &settings).unwrap(), Some(Prettier), "{marker}");
|
||||
// Biome doesn't format Markdown: Prettier keeps it.
|
||||
assert_eq!(tool(None, "markdown", &readme, &settings).unwrap(), Some(Prettier), "{marker}");
|
||||
std::fs::remove_file(&path).unwrap();
|
||||
}
|
||||
std::fs::write(root.join("web/biome.json"), "{}").unwrap();
|
||||
std::fs::write(root.join("web/.oxfmtrc.json"), "{}").unwrap();
|
||||
assert_eq!(tool(None, "css", &web, &settings).unwrap(), Some(Biome));
|
||||
settings.biome.languages.retain(|l| l != "css");
|
||||
assert_eq!(tool(None, "css", &web, &settings).unwrap(), Some(Oxfmt));
|
||||
// Biome only lints here: Prettier keeps formatting.
|
||||
std::fs::remove_file(root.join("web/.oxfmtrc.json")).unwrap();
|
||||
std::fs::write(root.join("web/biome.json"), r#"{ "formatter": { "enabled": false } }"#).unwrap();
|
||||
assert_eq!(tool(None, "typescript", &web, &settings).unwrap(), Some(Prettier));
|
||||
settings.biome.prefer = true;
|
||||
assert_eq!(tool(None, "typescript", &api, &settings).unwrap(), Some(Biome));
|
||||
let markdown = tool(Some(Biome), "markdown", &readme, &settings).unwrap_err();
|
||||
assert_eq!(markdown.message, "Biome cannot format Markdown files");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -25,7 +25,7 @@ pub mod rpc;
|
||||
pub mod shell_env;
|
||||
pub mod trust;
|
||||
|
||||
pub use project::{Project, history_retention};
|
||||
pub use project::{Project, apply_git_executable, history_retention};
|
||||
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId, SharedSink};
|
||||
use ide_language::{LanguageRegistry, Syntax};
|
||||
@@ -34,7 +34,7 @@ use ide_terminal::TerminalManager;
|
||||
use ide_workspace::SettingsStore;
|
||||
use parking_lot::{Mutex, RwLock};
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, OnceLock};
|
||||
|
||||
/// Event sink for one window (by label).
|
||||
@@ -92,7 +92,6 @@ pub struct Host {
|
||||
/// The window that owns each open heap snapshot; its project's close closes them.
|
||||
pub(crate) heap_windows: Mutex<HashMap<ide_heap::HeapSnapshotId, String>>,
|
||||
pub(crate) heap_requests: ops::heap::HeapRequests,
|
||||
pub(crate) rebase_editors: Arc<ops::vcs::RebaseEditors>,
|
||||
/// SSH connections of Settings › SSH Configurations.
|
||||
pub ssh: Arc<ide_ssh::SshManager>,
|
||||
/// SFTP deployment, remote file editing and runs on run targets.
|
||||
@@ -191,7 +190,6 @@ impl Host {
|
||||
heap: Arc::new(ide_heap::HeapRegistry::new(ide_heap::snapshots_root(&local_data_dir))),
|
||||
heap_windows: Mutex::default(),
|
||||
heap_requests: Default::default(),
|
||||
rebase_editors: Default::default(),
|
||||
languages,
|
||||
syntax,
|
||||
config_dir,
|
||||
@@ -209,7 +207,6 @@ impl Host {
|
||||
};
|
||||
host.apply_proxy();
|
||||
host.apply_added_jdks();
|
||||
host.apply_git_executable();
|
||||
// Before any project starts jdtls; the deleting itself can take a while.
|
||||
let unused =
|
||||
ide_sdk::jdtls_workspaces::take_unused(&host.local_data_dir, ide_sdk::jdtls_workspaces::UNUSED_FOR);
|
||||
@@ -601,14 +598,6 @@ impl Host {
|
||||
let homes = self.global_settings.effective().languages.java.added_jdks;
|
||||
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
|
||||
}
|
||||
|
||||
/// Global Settings › Version Control › Git › Path to Git executable, for git started outside
|
||||
/// a project's repositories (clone, init, agents, gh, plugins). A project's own value stays
|
||||
/// with its repositories ([`Project::repos`]).
|
||||
pub fn apply_git_executable(&self) {
|
||||
let exe = self.global_settings.read_effective(|s| s.vcs.git.executable.trim().to_owned());
|
||||
ide_vcs::set_default_git_executable((!exe.is_empty()).then(|| Path::new(&exe)));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -102,7 +102,9 @@ This is useful to detect all repositories in a multi-repository project.
|
||||
In OpenIDEA each root also tells its current `branch` (absent when HEAD is detached), `headCommit` and a merge, \
|
||||
rebase or cherry-pick in progress (`operationInProgress`).",
|
||||
|call| async move {
|
||||
let roots = crate::ops::vcs::vcs_roots(&call.host(), &call.window).await?;
|
||||
let host = call.host();
|
||||
let window = call.window.clone();
|
||||
let roots = call.host.blocking(move || crate::ops::vcs::vcs_roots(&host, &window)).await?;
|
||||
let list: Vec<Value> = roots
|
||||
.into_iter()
|
||||
.map(|r| {
|
||||
@@ -255,7 +257,10 @@ By default all Git repositories are returned.",
|
||||
let include_ignored = call.flag("includeIgnored", false)?;
|
||||
let page = Page::of(&call, STATUS_DEFAULT_LIMIT)?;
|
||||
let host = call.host();
|
||||
let repos: Vec<(PathBuf, Option<String>)> = crate::ops::vcs::vcs_roots(&host, &call.window)
|
||||
let h = host.clone();
|
||||
let w = call.window.clone();
|
||||
let repos: Vec<(PathBuf, Option<String>)> = host
|
||||
.blocking(move || crate::ops::vcs::vcs_roots(&h, &w))
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|r| (r.root.into_path_buf(), r.head))
|
||||
|
||||
@@ -906,7 +906,6 @@ pub async fn build_run(
|
||||
let detected = project.detected_roots.read().clone();
|
||||
let config_dir = host.config_dir.clone();
|
||||
let token = host.begin_project_request(window, request);
|
||||
let launch_project = project.clone();
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
// Fast path (#2476): an unchanged single-project Maven build skips
|
||||
// Maven entirely. Previous diagnostics stay: nothing changed, so they
|
||||
@@ -1004,12 +1003,7 @@ pub async fn build_run(
|
||||
};
|
||||
let result = compile::run(&root, &plan, &token, &|e| {
|
||||
let _ = on_event.send(e);
|
||||
});
|
||||
if kind == BuildKind::Rebuild {
|
||||
// The clean removed outputs that earlier launch snapshots still hold.
|
||||
launch_project.java_launch_snapshots.lock().forget_reusable_snapshots();
|
||||
}
|
||||
let result = result?;
|
||||
})?;
|
||||
if result.success && single && kind == BuildKind::Build {
|
||||
let model = with_profiles(load(&root, &cache, &settings), &cache);
|
||||
compile::record_menu_build(&cache, &root, &model, file.as_deref(), &token);
|
||||
|
||||
@@ -135,16 +135,6 @@ impl Session {
|
||||
}
|
||||
}
|
||||
|
||||
/// Build › Rebuild replaced the module outputs. The recorded snapshots were copied from
|
||||
/// the outputs before the clean and may hold classes it removed (a class moved to another
|
||||
/// package leaves its old file behind when jdtls wrote it), so none of them is reused:
|
||||
/// the next launch copies the rebuilt outputs.
|
||||
pub(crate) fn forget_reusable_snapshots(&mut self) {
|
||||
if let Err(error) = forget_reusable_snapshots(&self.cache) {
|
||||
tracing::warn!(%error, "Cannot invalidate Java launch snapshots");
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn build(
|
||||
&mut self,
|
||||
root: &Path,
|
||||
@@ -351,32 +341,6 @@ impl Drop for Session {
|
||||
}
|
||||
}
|
||||
|
||||
/// Clears the fingerprint of every launch record under `cache`, so no snapshot matches the
|
||||
/// sources any more. The records stay: their modules keep delegating to Maven.
|
||||
fn forget_reusable_snapshots(cache: &Path) -> std::io::Result<()> {
|
||||
let records = cache.join("java-launch/records");
|
||||
if !records.try_exists()? {
|
||||
return Ok(());
|
||||
}
|
||||
let mut pending = vec![records];
|
||||
while let Some(dir) = pending.pop() {
|
||||
for entry in fs::read_dir(dir)? {
|
||||
let entry = entry?;
|
||||
let kind = entry.file_type()?;
|
||||
if kind.is_dir() {
|
||||
pending.push(entry.path());
|
||||
} else if kind.is_file() && entry.path().extension().is_some_and(|ext| ext == "json") {
|
||||
let outputs: Option<Outputs> = serde_json::from_slice(&fs::read(entry.path())?).unwrap_or(None);
|
||||
if let Some(mut outputs) = outputs.filter(|o| o.fingerprint.is_some()) {
|
||||
outputs.fingerprint = None;
|
||||
write_record(&entry.path(), &outputs).map_err(|e| std::io::Error::other(e.message))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn referenced_snapshots(cache: &Path) -> std::io::Result<HashSet<PathBuf>> {
|
||||
let mut referenced = HashSet::new();
|
||||
let records = cache.join("java-launch/records");
|
||||
@@ -646,34 +610,6 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_menu_rebuild_stops_reusing_snapshots_that_hold_removed_classes() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = fixture(root);
|
||||
let cancel = CancellationToken::new();
|
||||
// A class jdtls wrote for a source since moved to another package; an incremental
|
||||
// Maven build leaves it in target/classes.
|
||||
fs::create_dir_all(root.join("target/classes")).unwrap();
|
||||
fs::write(root.join("target/classes/Stale.class"), "stale").unwrap();
|
||||
let mut session = Session::new(root.join("cache"));
|
||||
let first = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
|
||||
assert!(first.snapshot.join("0/Stale.class").is_file());
|
||||
let reused = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
|
||||
assert_eq!(reused.snapshot, first.snapshot);
|
||||
|
||||
// Build › Rebuild cleans the outputs and compiles again.
|
||||
fs::remove_file(root.join("target/classes/Stale.class")).unwrap();
|
||||
session.forget_reusable_snapshots();
|
||||
assert!(has_record(root, &root.join("cache"), root));
|
||||
let next = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
|
||||
assert_ne!(next.snapshot, first.snapshot);
|
||||
assert!(!next.snapshot.join("0/Stale.class").exists());
|
||||
assert!(next.snapshot.join("0/Main.class").is_file());
|
||||
let again = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
|
||||
assert_eq!(again.snapshot, next.snapshot);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn jdt_errors_reuse_an_unchanged_snapshot_and_rebuild_only_on_a_cache_miss() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -1176,22 +1176,6 @@ pub async fn lsp_prepare_rename(host: &Host, window: &str, doc: DocId, pos: Pos)
|
||||
host.project(window)?.lsp.prepare_rename(doc, pos).await
|
||||
}
|
||||
|
||||
/// The Throwable class the caret at `pos` names, for the exception breakpoint intention.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_exception_class_at(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
) -> IdeResult<Option<ExceptionClassRef>> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.exception_class_at(doc, pos, cancel).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// The class at `pos` and the members Pull Members Up / Push Members Down can move.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_hierarchy_members(
|
||||
@@ -1606,62 +1590,6 @@ pub async fn lsp_format(
|
||||
crate::formatter::format(host, window, doc, range, options).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_format_text(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
path: std::path::PathBuf,
|
||||
text: String,
|
||||
options: FormatOptions,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
crate::formatter::format_text(host, window, path, text, options).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_source_action_text(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
path: std::path::PathBuf,
|
||||
text: String,
|
||||
kind: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let project = host.project(window)?;
|
||||
if !path.is_absolute() || path.file_name().is_none() {
|
||||
return Err(IdeError::invalid("a text snapshot requires a file path"));
|
||||
}
|
||||
if text.len() as u64 > ide_vfs::LARGE_FILE_THRESHOLD {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let language = project.documents.language_of(&path, text.lines().next()).language;
|
||||
let cancel = host.begin_project_read_request(window, request);
|
||||
let result = project.lsp.source_action_text(&path, &language, &text, &kind, &cancel).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_snapshot_diagnostics(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
path: std::path::PathBuf,
|
||||
text: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<ide_core::Diagnostic>> {
|
||||
let project = host.project(window)?;
|
||||
if !path.is_absolute() || path.file_name().is_none() {
|
||||
return Err(IdeError::invalid("a text snapshot requires a file path"));
|
||||
}
|
||||
if text.len() as u64 > ide_vfs::LARGE_FILE_THRESHOLD {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let language = project.documents.language_of(&path, text.lines().next()).language;
|
||||
let cancel = host.begin_project_read_request(window, request);
|
||||
let result = project.lsp.snapshot_diagnostics(&path, &language, &text, &cancel).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn lsp_inlay_hints(host: &Host, window: &str, doc: DocId, range: Range) -> IdeResult<Vec<InlayHint>> {
|
||||
let lsp = host.project(window)?.lsp.clone();
|
||||
@@ -2858,15 +2786,11 @@ ide_command::domain!(
|
||||
lsp_completion,
|
||||
lsp_document_highlights,
|
||||
lsp_document_links,
|
||||
lsp_exception_class_at,
|
||||
lsp_execute_code_action,
|
||||
lsp_execute_command,
|
||||
lsp_extract_interface,
|
||||
lsp_extract_interface_info,
|
||||
lsp_format,
|
||||
lsp_format_text,
|
||||
lsp_snapshot_diagnostics,
|
||||
lsp_source_action_text,
|
||||
lsp_goto,
|
||||
lsp_goto_implementation,
|
||||
lsp_hierarchy_members,
|
||||
|
||||
@@ -391,9 +391,6 @@ pub fn set_settings(
|
||||
if key == "languages" || key == "languages.java" || key.starts_with("languages.java.addedJdks") {
|
||||
host.apply_added_jdks();
|
||||
}
|
||||
if key == "vcs" || key == "vcs.git" || key == "vcs.git.executable" {
|
||||
host.apply_git_executable();
|
||||
}
|
||||
if is_proxy {
|
||||
host.apply_proxy();
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use crate::Host;
|
||||
use crate::{Host, apply_git_executable};
|
||||
use ide_command::command;
|
||||
use ide_core::IdeResult;
|
||||
use ide_vcs::FileStatus;
|
||||
@@ -9,6 +9,9 @@ pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>>
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let settings = project.settings.effective();
|
||||
if project.is_trusted() {
|
||||
apply_git_executable(&settings);
|
||||
}
|
||||
let repos = project.repos();
|
||||
if repos.is_empty() {
|
||||
return Err(ide_core::IdeError::unavailable("project is not a git repository"));
|
||||
@@ -22,21 +25,6 @@ pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>>
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn vcs_ignored_files(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let settings = project.settings.effective();
|
||||
let repos = project.repos();
|
||||
let ignored = settings.ignored_names();
|
||||
for repo in repos.all() {
|
||||
repo.set_ignored_names(ignored.clone());
|
||||
}
|
||||
repos.ignored_files()
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Changes of `paths` only: the dirty-scope refresh after a watcher batch.
|
||||
#[command(trust = always)]
|
||||
pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::PathBuf>) -> IdeResult<Vec<FileStatus>> {
|
||||
@@ -44,6 +32,9 @@ pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::P
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let settings = project.settings.effective();
|
||||
if project.is_trusted() {
|
||||
apply_git_executable(&settings);
|
||||
}
|
||||
let repos = project.repos();
|
||||
if repos.is_empty() {
|
||||
return Err(ide_core::IdeError::unavailable("project is not a git repository"));
|
||||
@@ -58,10 +49,7 @@ pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::P
|
||||
}
|
||||
|
||||
pub mod commands;
|
||||
mod rebase_editor;
|
||||
mod worktree_setup;
|
||||
pub use commands::*;
|
||||
pub(crate) use rebase_editor::RebaseEditors;
|
||||
|
||||
/// Refuses (with `refusal`) to remove or move the worktree that holds the open project.
|
||||
fn check_worktree_away_from_project(
|
||||
@@ -102,4 +90,4 @@ fn check_worktree_away_from_project(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
ide_command::domain!(vcs: vcs_status, vcs_status_paths, vcs_ignored_files);
|
||||
ide_command::domain!(vcs: vcs_status, vcs_status_paths);
|
||||
+165
-1742
File diff suppressed because it is too large.
Load diff
@@ -1,62 +0,0 @@
|
||||
use crate::ops::Channel;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId};
|
||||
use ide_vcs::{RebaseEdit, RebaseEditorReply};
|
||||
use parking_lot::Mutex;
|
||||
use serde::Serialize;
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
use std::sync::mpsc;
|
||||
use std::time::Duration;
|
||||
|
||||
#[derive(Serialize, Type)]
|
||||
pub struct RebaseEditorPrompt {
|
||||
pub index: u32,
|
||||
pub edit: RebaseEdit,
|
||||
}
|
||||
|
||||
type EditorKey = (String, RequestId, u32);
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct RebaseEditors {
|
||||
pending: Mutex<HashMap<EditorKey, mpsc::Sender<Option<RebaseEditorReply>>>>,
|
||||
}
|
||||
|
||||
impl RebaseEditors {
|
||||
pub fn wait(
|
||||
&self,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
prompt: RebaseEditorPrompt,
|
||||
channel: &Channel<RebaseEditorPrompt>,
|
||||
cancel: &CancellationToken,
|
||||
) -> Option<RebaseEditorReply> {
|
||||
let key = (window.to_owned(), request, prompt.index);
|
||||
let (send, recv) = mpsc::channel();
|
||||
self.pending.lock().insert(key.clone(), send);
|
||||
let result = (|| {
|
||||
channel.send(prompt).ok()?;
|
||||
while !cancel.is_cancelled() {
|
||||
match recv.recv_timeout(Duration::from_millis(100)) {
|
||||
Ok(reply) => return reply,
|
||||
Err(mpsc::RecvTimeoutError::Timeout) => continue,
|
||||
Err(mpsc::RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
None
|
||||
})();
|
||||
self.pending.lock().remove(&key);
|
||||
result
|
||||
}
|
||||
|
||||
pub fn reply(
|
||||
&self,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
index: u32,
|
||||
reply: Option<RebaseEditorReply>,
|
||||
) -> IdeResult<()> {
|
||||
let expired = || IdeError::invalid("The Git editor request is no longer active.");
|
||||
let send = self.pending.lock().remove(&(window.to_owned(), request, index)).ok_or_else(expired)?;
|
||||
send.send(reply).map_err(|_| expired())
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
use ide_core::CancellationToken;
|
||||
use std::collections::VecDeque;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
use std::time::Duration;
|
||||
|
||||
pub(super) fn run(script: &Path, worktree: &Path, cancel: &CancellationToken) -> Option<String> {
|
||||
let mut tail = VecDeque::new();
|
||||
let on_line = |line: String| {
|
||||
if tail.len() == 12 {
|
||||
tail.pop_front();
|
||||
}
|
||||
tail.push_back(line.chars().take(500).collect::<String>());
|
||||
};
|
||||
let mut command = script_command(script);
|
||||
command.arg(worktree);
|
||||
let result = crate::environment::run_command(command, worktree, cancel, Some(Duration::from_secs(300)), on_line);
|
||||
if cancel.is_cancelled() {
|
||||
return None;
|
||||
}
|
||||
result.err().map(|error| std::iter::once(error).chain(tail).collect::<Vec<_>>().join("\n"))
|
||||
}
|
||||
|
||||
fn script_command(script: &Path) -> Command {
|
||||
#[cfg(windows)]
|
||||
if script.extension().is_some_and(|ext| ext.eq_ignore_ascii_case("ps1")) {
|
||||
let windows = std::env::var_os("SystemRoot").unwrap_or_else(|| r"C:\Windows".into());
|
||||
let mut command = Command::new(Path::new(&windows).join(r"System32\WindowsPowerShell\v1.0\powershell.exe"));
|
||||
command.args(["-NoProfile", "-NonInteractive", "-File"]).arg(script);
|
||||
return command;
|
||||
}
|
||||
Command::new(script)
|
||||
}
|
||||
@@ -136,10 +136,6 @@ pub trait PluginWorkspace: Send + Sync {
|
||||
fn apply_edits(&self, path: &Path, version: u64, edits: &[TextEdit], background: bool) -> Result<u64, HostError>;
|
||||
/// Code from the project may run (git hooks and config on fetch).
|
||||
fn trusted(&self, root: &Path) -> bool;
|
||||
/// The git executable of the project at `root` (see [`crate::Project::git_executable`]).
|
||||
fn git_executable(&self, _root: &Path) -> Option<PathBuf> {
|
||||
None
|
||||
}
|
||||
/// Root of the project open in `window`.
|
||||
fn project_of(&self, window: &str) -> Option<PathBuf>;
|
||||
/// Windows showing the open project at `root`, the most recently focused first.
|
||||
@@ -1461,7 +1457,6 @@ pub(super) fn commit_draft(
|
||||
};
|
||||
// Both callers have checked that the window's project is trusted.
|
||||
r.set_execution_allowed(true);
|
||||
r.set_git_executable(workspace.git_executable(&repo.root.0).as_deref());
|
||||
let backend = &r as &dyn ide_vcs::Backend;
|
||||
let pending = backend
|
||||
.pending_changes(&repo.options, budget, &|path| Ok(workspace.vcs_encoding(path)))
|
||||
@@ -3729,10 +3724,6 @@ impl PluginWorkspace for HostWorkspace {
|
||||
HostWorkspace::project_covering(self, root).is_some_and(|p| p.is_trusted())
|
||||
}
|
||||
|
||||
fn git_executable(&self, root: &Path) -> Option<PathBuf> {
|
||||
HostWorkspace::project_covering(self, root)?.git_executable()
|
||||
}
|
||||
|
||||
fn project_of(&self, window: &str) -> Option<PathBuf> {
|
||||
self.0.upgrade()?.project(window).ok().map(|p| p.root.clone())
|
||||
}
|
||||
@@ -4737,12 +4728,8 @@ impl PluginApi {
|
||||
/// no upstream. The other reads use [`Self::read_repo`] and never execute.
|
||||
fn repo(&self, root: &Path) -> Result<Option<ide_vcs::Repo>, HostError> {
|
||||
let repo = ide_vcs::Repo::discover(root).map_err(failed)?;
|
||||
if let Some(repo) = &repo
|
||||
&& let Some(workspace) = self.shared.workspace()
|
||||
&& workspace.trusted(root)
|
||||
{
|
||||
repo.set_execution_allowed(true);
|
||||
repo.set_git_executable(workspace.git_executable(root).as_deref());
|
||||
if let Some(repo) = &repo {
|
||||
repo.set_execution_allowed(self.shared.workspace().is_some_and(|w| w.trusted(root)));
|
||||
}
|
||||
Ok(repo)
|
||||
}
|
||||
|
||||
@@ -286,10 +286,6 @@ impl Host {
|
||||
lombok.jar(),
|
||||
);
|
||||
ide_sdk::apply::configure_gradle_runtime(cfg, root, server_root, &effective);
|
||||
let gradle_dirs: Vec<_> = std::iter::once(data_dir.join("gradle"))
|
||||
.chain(dirs::cache_dir().map(|dir| dir.join("openidea").join("gradle")))
|
||||
.collect();
|
||||
ide_sdk::apply::configure_gradle_classpath(cfg, &gradle_dirs);
|
||||
ide_sdk::apply::configure_maven_sources(cfg, &effective);
|
||||
ide_sdk::jdtls::launch_directly(cfg);
|
||||
}
|
||||
@@ -696,10 +692,6 @@ impl Host {
|
||||
roots
|
||||
}));
|
||||
}
|
||||
{
|
||||
let weak = Arc::downgrade(&project);
|
||||
project.agents.set_git_executable_hook(Arc::new(move || weak.upgrade()?.git_executable()));
|
||||
}
|
||||
self.insert_project(window, project.clone());
|
||||
for (key, text, dirty) in &carried {
|
||||
let _ = project.documents.restore_untitled_buffer(key, text, *dirty);
|
||||
@@ -1077,24 +1069,11 @@ impl Project {
|
||||
);
|
||||
}
|
||||
|
||||
/// Settings › Version Control › Git › Path to Git executable, this project's value (its own
|
||||
/// layer over the global one); `None` when it is empty or the project is not trusted.
|
||||
/// Every git started for the project runs it: the project's repositories carry it, and work
|
||||
/// that opens repositories of its own (agent worktrees, gh, plugins) passes it to
|
||||
/// [`ide_vcs::with_git_executable`].
|
||||
pub fn git_executable(&self) -> Option<PathBuf> {
|
||||
let git = self.settings.read_effective(|s| s.vcs.git.executable.trim().to_owned());
|
||||
(self.is_trusted() && !git.is_empty()).then(|| PathBuf::from(git))
|
||||
}
|
||||
|
||||
/// The project's git repositories.
|
||||
pub fn repos(&self) -> Repos {
|
||||
let repos = self.repos.read().clone();
|
||||
let trusted = self.is_trusted();
|
||||
let git = self.git_executable();
|
||||
for repo in repos.all() {
|
||||
repo.set_execution_allowed(trusted);
|
||||
repo.set_git_executable(git.as_deref());
|
||||
repo.set_execution_allowed(self.is_trusted());
|
||||
}
|
||||
repos
|
||||
}
|
||||
@@ -1178,13 +1157,11 @@ impl Project {
|
||||
|
||||
fn run_in<T>(&self, repo: &Repo, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {
|
||||
let settings = self.settings.effective();
|
||||
if self.is_trusted() {
|
||||
apply_git_executable(&settings);
|
||||
}
|
||||
repo.set_ignored_names(settings.ignored_names());
|
||||
repo.set_cli_status(settings.vcs.git.cli_status);
|
||||
repo.set_automatic_shelf(
|
||||
(settings.vcs.git.save_changes_policy == ide_core::workflow_settings::GitSaveChangesPolicy::Shelve)
|
||||
.then(|| ide_core::project_dir::path(&self.root, "shelf")),
|
||||
(!settings.vcs.git.staging_area).then(|| self.root.clone()),
|
||||
);
|
||||
f(repo)
|
||||
}
|
||||
|
||||
@@ -1455,22 +1432,12 @@ impl Project {
|
||||
/// Use the open document's selected encoding, or the same detection/settings as opening it.
|
||||
pub fn vcs_encoding(&self, path: &Path, rev: Option<&str>) -> IdeResult<ide_vcs::TextEncoding> {
|
||||
let charset = self.file_encoding(path, rev)?;
|
||||
Ok(self.vcs_text_encoding(path, charset))
|
||||
}
|
||||
|
||||
pub fn staged_file_encoding(&self, path: &Path, bytes: &[u8]) -> ide_vcs::TextEncoding {
|
||||
let defaults = self.documents.file_defaults();
|
||||
let charset = ide_vfs::detect_encoding(bytes, defaults.fallback_for(path));
|
||||
self.vcs_text_encoding(path, charset)
|
||||
}
|
||||
|
||||
fn vcs_text_encoding(&self, path: &Path, charset: &'static encoding_rs::Encoding) -> ide_vcs::TextEncoding {
|
||||
let encoding = ide_vcs::TextEncoding::from(charset);
|
||||
if self.documents.native_to_ascii_for(path) {
|
||||
Ok(if self.documents.native_to_ascii_for(path) {
|
||||
encoding.with_ascii_conversion(ide_vfs::decode_properties_escapes, ide_vfs::encode_properties_ascii)
|
||||
} else {
|
||||
encoding
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn file_encoding(&self, path: &Path, rev: Option<&str>) -> IdeResult<&'static encoding_rs::Encoding> {
|
||||
@@ -2208,6 +2175,12 @@ fn notify_transfer(sink: &SharedSink, what: &str, path: &Path, result: IdeResult
|
||||
});
|
||||
}
|
||||
|
||||
/// Settings › Version Control › Git › Path to Git executable (empty = auto-detect).
|
||||
pub fn apply_git_executable(settings: &ide_core::settings::Settings) {
|
||||
let exe = settings.vcs.git.executable.trim();
|
||||
ide_vcs::set_git_executable((!exe.is_empty()).then(|| Path::new(exe)));
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod maven_linkage_tests {
|
||||
#[test]
|
||||
|
||||
@@ -113,8 +113,8 @@ async fn external_history_is_readable_and_never_becomes_a_write_target() {
|
||||
Some("historical content\n")
|
||||
);
|
||||
assert!(project.repos().at_root(&external).is_none());
|
||||
assert!(vcs::vcs_checkout(&host, "main", Some(external.clone()), first.clone(), false, None, None).await.is_err());
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(external.clone()), String::new(), None).await.is_err());
|
||||
assert!(vcs::vcs_checkout(&host, "main", Some(external.clone()), first.clone(), false, None).await.is_err());
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(external.clone()), String::new()).await.is_err());
|
||||
assert_eq!(git(&external, &["rev-parse", "HEAD"]), head);
|
||||
assert!(!deleted.exists());
|
||||
host.close_project("main");
|
||||
|
||||
@@ -140,9 +140,7 @@ async fn properties_search_git_and_document_coordinates_agree() {
|
||||
let selected = &hunks[0];
|
||||
let options = ide_vcs::CommitOptions {
|
||||
partial: vec![ide_vcs::PartialCommitFile {
|
||||
prepared: None,
|
||||
path: path.clone().into(),
|
||||
line_hunks: vec![],
|
||||
hunks: vec![ide_vcs::HunkRange {
|
||||
start: selected.start,
|
||||
lines: selected.lines,
|
||||
|
||||
@@ -352,6 +352,7 @@ async fn restricted_git_views_ignore_project_executables_and_mutations_cannot_ru
|
||||
project.with_repo(|repo| repo.commit("trusted", false, false)).unwrap();
|
||||
assert!(root.join("git-executable.marker").exists());
|
||||
assert!(root.join("git-hook.marker").exists());
|
||||
ide_vcs::set_git_executable(None);
|
||||
host.shutdown().await;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,14 +1,15 @@
|
||||
//! Which git executable each window's repositories run. Its own test binary: the default
|
||||
//! executable (global settings) is process-wide.
|
||||
//! The configured Git binary is process-wide, so it has its own test binary.
|
||||
#![cfg(unix)]
|
||||
use ide_core::NullSink;
|
||||
use ide_host::{Host, HostConfig, ops};
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn host(base: &Path) -> Arc<Host> {
|
||||
Arc::new(Host::new(HostConfig {
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn restricted_status_does_not_select_the_project_git_for_other_windows() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let host = Arc::new(Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
@@ -18,126 +19,7 @@ fn host(base: &Path) -> Arc<Host> {
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
}))
|
||||
}
|
||||
|
||||
/// A repository with `tools/git`: it appends a line to `marker`, waits while `gate` exists,
|
||||
/// then runs the real git.
|
||||
fn repo_with_wrapper(root: &Path, marker: &Path, gate: &Path) {
|
||||
std::fs::create_dir_all(root.join(".openidea")).unwrap();
|
||||
std::fs::create_dir_all(root.join("tools")).unwrap();
|
||||
let real = ide_vcs::detected_git_executable().expect("git is installed");
|
||||
let wrapper = root.join("tools/git");
|
||||
let script = format!(
|
||||
"#!/bin/sh\necho run >> '{}'\ni=0\nwhile [ -e '{}' ] && [ $i -lt 400 ]; do sleep 0.05; i=$((i+1)); done\nexec '{}' \"$@\"\n",
|
||||
marker.display(),
|
||||
gate.display(),
|
||||
real.display()
|
||||
);
|
||||
std::fs::write(&wrapper, script).unwrap();
|
||||
std::fs::set_permissions(&wrapper, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let init = std::process::Command::new(&real).arg("init").arg("-q").arg(root).output().unwrap();
|
||||
assert!(init.status.success(), "{}", String::from_utf8_lossy(&init.stderr));
|
||||
}
|
||||
|
||||
fn runs(marker: &Path) -> usize {
|
||||
std::fs::read_to_string(marker).map_or(0, |s| s.lines().count())
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_project_git_executable_stays_with_its_project_while_another_window_runs_git() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let host = host(&base);
|
||||
let (a, c) = (base.join("a"), base.join("c"));
|
||||
let (a_marker, c_marker, gate) = (base.join("a.marker"), base.join("c.marker"), base.join("gate"));
|
||||
repo_with_wrapper(&a, &a_marker, &gate);
|
||||
repo_with_wrapper(&c, &c_marker, &gate);
|
||||
// Relative: resolved against the repository that runs it, so C has a `tools/git` of its own.
|
||||
std::fs::write(a.join(".openidea/settings.toml"), "[vcs.git]\nexecutable = \"tools/git\"\n").unwrap();
|
||||
let project_a = host.open_project("a", &a).unwrap();
|
||||
host.open_project("c", &c).unwrap();
|
||||
for root in [&a, &c] {
|
||||
host.set_project_trust(root, true, false).await.unwrap();
|
||||
}
|
||||
|
||||
// Project A runs two git commands in one go, as `compare_paths` does; window C runs its own
|
||||
// git between them.
|
||||
std::fs::write(&gate, "").unwrap();
|
||||
let two_commands = tokio::task::spawn_blocking(move || {
|
||||
project_a.with_repo(|repo| {
|
||||
repo.remotes()?;
|
||||
repo.remotes()
|
||||
})
|
||||
});
|
||||
for _ in 0..200 {
|
||||
if runs(&a_marker) > 0 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
|
||||
}
|
||||
assert_eq!(runs(&a_marker), 1, "control: project A's first command runs A's git");
|
||||
ops::vcs::vcs_status(&host, "c").await.unwrap();
|
||||
ops::vcs::vcs_remotes(&host, "c", None).await.unwrap();
|
||||
std::fs::remove_file(&gate).unwrap();
|
||||
two_commands.await.unwrap().unwrap();
|
||||
|
||||
assert_eq!(runs(&a_marker), 2, "project A's second command lost A's git once window C ran git");
|
||||
assert_eq!(runs(&c_marker), 0, "project C has no git setting but ran A's relative tools/git");
|
||||
host.shutdown().await;
|
||||
}
|
||||
|
||||
/// An agent task opens repositories of its own (the project's, then its worktree): their git is
|
||||
/// the project's too.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn an_agent_task_worktree_runs_the_project_git() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let host = host(&base);
|
||||
let root = base.join("a");
|
||||
let marker = base.join("a.marker");
|
||||
repo_with_wrapper(&root, &marker, &base.join("no-gate"));
|
||||
let real = ide_vcs::detected_git_executable().unwrap();
|
||||
let commit = std::process::Command::new(&real)
|
||||
.arg("-C")
|
||||
.arg(&root)
|
||||
.args(["-c", "user.name=t", "-c", "[email protected]", "-c", "commit.gpgsign=false"])
|
||||
.args(["commit", "-q", "--allow-empty", "-m", "init"])
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(commit.status.success(), "{}", String::from_utf8_lossy(&commit.stderr));
|
||||
let wrapper = root.join("tools/git");
|
||||
std::fs::write(root.join(".openidea/settings.toml"), format!("[vcs.git]\nexecutable = {wrapper:?}\n")).unwrap();
|
||||
host.open_project("a", &root).unwrap();
|
||||
host.set_project_trust(&root, true, false).await.unwrap();
|
||||
|
||||
let task = ops::agent::agent_create(
|
||||
&host,
|
||||
"a",
|
||||
ide_agent::NewAgentTask {
|
||||
prompt: ide_agent::AgentPrompt { text: "Say hi".into(), ..Default::default() },
|
||||
provider: "codex".into(),
|
||||
isolation: ide_agent::Isolation::Worktree,
|
||||
idle: true,
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(task.cwd.0.join(".git").exists(), "the task has its worktree");
|
||||
let created = runs(&marker);
|
||||
assert!(created > 0, "creating the task's worktree ran another git than the project's");
|
||||
|
||||
ops::agent::agent_delete(&host, "a", task.id, true).await.unwrap();
|
||||
assert!(runs(&marker) > created, "removing the task's worktree ran another git than the project's");
|
||||
host.shutdown().await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn restricted_status_does_not_select_the_project_git_for_other_windows() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let host = host(&base);
|
||||
}));
|
||||
let root = base.join("malicious");
|
||||
std::fs::create_dir_all(root.join(".openidea")).unwrap();
|
||||
let marker = base.join("git.marker");
|
||||
|
||||
@@ -11,7 +11,7 @@ use std::process::{Command, Stdio};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// Allowed in Restricted Mode and not swept: none of them starts git for the project.
|
||||
const NOT_THE_PROJECT_REPOSITORY: [&str; 8] = [
|
||||
const NOT_THE_PROJECT_REPOSITORY: [&str; 7] = [
|
||||
"vcs_clone", // clones a URL the user gives into a new folder
|
||||
"vcs_diff_hunks", // compares two texts
|
||||
"vcs_detected_git", // looks for the git executable
|
||||
@@ -19,7 +19,6 @@ const NOT_THE_PROJECT_REPOSITORY: [&str; 8] = [
|
||||
"vcs_shelf_patch",
|
||||
"vcs_changelists_load",
|
||||
"vcs_write_patch", // writes a patch the UI already holds
|
||||
"vcs_read_patch", // reads patch text without running Git
|
||||
];
|
||||
|
||||
fn git(root: &Path, args: &[&str]) -> String {
|
||||
@@ -166,30 +165,25 @@ async fn restricted_vcs_commands_run_no_program_of_the_repository() {
|
||||
($command, $what, Box::pin(async { $call.await.is_ok() }) as Pin<Box<dyn Future<Output = bool> + '_>>)
|
||||
};
|
||||
}
|
||||
macro_rules! sync {
|
||||
($command:literal, $what:literal, $call:expr) => {
|
||||
($command, $what, Box::pin(async { $call.is_ok() }) as Pin<Box<dyn Future<Output = bool> + '_>>)
|
||||
};
|
||||
}
|
||||
let calls: Vec<Call> = vec![
|
||||
call!("vcs_status", "", ops::vcs::vcs_status(host, w)),
|
||||
call!("vcs_ignored_files", "", ops::vcs::vcs_ignored_files(host, w)),
|
||||
call!("vcs_status_paths", "", ops::vcs::vcs_status_paths(host, w, vec![file.clone()])),
|
||||
call!("vcs_roots", "", vcs::vcs_roots(host, w)),
|
||||
call!("vcs_project_update_plan", "", vcs::vcs_project_update_plan(host, w, vec![root()])),
|
||||
sync!("vcs_roots", "", vcs::vcs_roots(host, w)),
|
||||
call!("vcs_detected_roots", "", vcs::vcs_detected_roots(host, w)),
|
||||
call!("vcs_branch_info", "", vcs::vcs_branch_info(host, w, root())),
|
||||
call!("vcs_line_hunks", "", vcs::vcs_line_hunks(host, w, file.clone())),
|
||||
call!("vcs_staging_line_hunks", "", vcs::vcs_staging_line_hunks(host, w, file.clone(), None)),
|
||||
call!("vcs_file_at", "", vcs::vcs_file_at(host, w, file.clone(), None)),
|
||||
call!(
|
||||
"vcs_diff_entries",
|
||||
"",
|
||||
vcs::vcs_diff_entries(host, w, vec![vcs::DiffEntryRequest { path: file.clone().into(), rev: "WT".into() }])
|
||||
),
|
||||
call!("vcs_blame", "", vcs::vcs_blame(host, w, file.clone(), None, None)),
|
||||
call!("vcs_block_history", "", vcs::vcs_block_history(host, w, RequestId(1), file.clone(), None, (0, 1))),
|
||||
call!("vcs_log", "", vcs::vcs_log(host, w, root(), Default::default())),
|
||||
call!("vcs_log_refs", "", vcs::vcs_log_refs(host, w, root())),
|
||||
call!("vcs_log_users", "", vcs::vcs_log_users(host, w, root())),
|
||||
call!("vcs_log_details", "", vcs::vcs_log_details(host, w, root(), project.head.clone())),
|
||||
call!("vcs_invalidate_log_signatures", "", vcs::vcs_invalidate_log_signatures(host, w, project.root.clone())),
|
||||
call!("vcs_signing_config", "", vcs::vcs_signing_config(host, w, project.root.clone())),
|
||||
call!(
|
||||
"vcs_log_details_batch",
|
||||
"",
|
||||
@@ -220,26 +214,9 @@ async fn restricted_vcs_commands_run_no_program_of_the_repository() {
|
||||
call!("vcs_conflict_versions", "", vcs::vcs_conflict_versions(host, w, file.clone())),
|
||||
call!("vcs_diff_text", "", vcs::vcs_diff_text(host, w, file.clone(), false)),
|
||||
call!("vcs_config_get", "", vcs::vcs_config_get(host, w, root(), "user.name".into())),
|
||||
call!("vcs_config_get_bool", "", vcs::vcs_config_get_bool(host, w, root(), "log.showSignature".into())),
|
||||
call!("vcs_watch_commit_messages", "", async {
|
||||
let request = RequestId(30);
|
||||
let (send, mut messages) = tokio::sync::mpsc::channel(1);
|
||||
let channel = ops::Channel::new(move |message| {
|
||||
let _ = send.try_send(message);
|
||||
});
|
||||
let watch = vcs::vcs_watch_commit_messages(host, w, root(), request, channel);
|
||||
let stop = async {
|
||||
let initial = tokio::time::timeout(std::time::Duration::from_secs(10), messages.recv()).await;
|
||||
host.cancel_request(request);
|
||||
assert!(matches!(initial, Ok(Some(_))), "missing initial commit messages");
|
||||
};
|
||||
let (result, ()) = tokio::join!(watch, stop);
|
||||
result
|
||||
}),
|
||||
call!("vcs_tags", "", vcs::vcs_tags(host, w, root())),
|
||||
call!("vcs_remotes", "", vcs::vcs_remotes(host, w, root())),
|
||||
call!("vcs_worktrees", "", vcs::vcs_worktrees(host, w, root())),
|
||||
call!("vcs_worktree_include", "", vcs::vcs_worktree_include(host, w, root())),
|
||||
call!("vcs_diff_with_worktree", "", vcs::vcs_diff_with_worktree(host, w, root(), "HEAD".into())),
|
||||
call!("vcs_compare_scope", "", vcs::vcs_compare_scope(host, w, vec![project.root.clone()])),
|
||||
call!(
|
||||
@@ -258,28 +235,6 @@ async fn restricted_vcs_commands_run_no_program_of_the_repository() {
|
||||
vcs::vcs_diff_numstat(host, w, root(), project.first.clone(), project.head.clone(), Vec::new())
|
||||
),
|
||||
call!("vcs_merge_base", "", vcs::vcs_merge_base(host, w, root(), project.first.clone(), project.head.clone())),
|
||||
call!("vcs_has_commit", "", vcs::vcs_has_commit(host, w, root(), project.head.clone())),
|
||||
call!(
|
||||
"vcs_not_cherry_picked",
|
||||
"",
|
||||
vcs::vcs_not_cherry_picked(host, w, root(), project.head.clone(), project.first.clone(), RequestId(4))
|
||||
),
|
||||
call!(
|
||||
"vcs_commit_selection_changes",
|
||||
"",
|
||||
vcs::vcs_commit_selection_changes(host, w, root(), vec![project.head.clone()], RequestId(5))
|
||||
),
|
||||
call!("vcs_default_push_target", "", vcs::vcs_default_push_target(host, w, root(), None)),
|
||||
call!(
|
||||
"vcs_commit_push_target",
|
||||
"",
|
||||
vcs::vcs_commit_push_target(host, w, root(), RequestId(6), project.head.clone())
|
||||
),
|
||||
call!(
|
||||
"vcs_push_target_choices",
|
||||
"commit",
|
||||
vcs::vcs_push_target_choices(host, w, root(), RequestId(7), None, Some(project.head.clone()))
|
||||
),
|
||||
call!("vcs_has_hook", "", vcs::vcs_has_hook(host, w, root(), "pre-push".into())),
|
||||
// A worktree outside the project, opened for its history only.
|
||||
call!("vcs_open_external_log", "", vcs::vcs_open_external_log(host, w, external.root.clone())),
|
||||
@@ -293,40 +248,8 @@ async fn restricted_vcs_commands_run_no_program_of_the_repository() {
|
||||
),
|
||||
call!("vcs_revision_files", "external", vcs::vcs_revision_files(host, w, log(), external.head.clone())),
|
||||
call!("vcs_commit_files", "external", vcs::vcs_commit_files(host, w, log(), external.head.clone())),
|
||||
(
|
||||
"vcs_review_apply_commit",
|
||||
"paused cherry-pick",
|
||||
Box::pin(async {
|
||||
git(
|
||||
&project.root,
|
||||
&["-c", "core.fsmonitor=false", "-c", "filter.marker.clean=", "add", "--", "src/a.txt"],
|
||||
);
|
||||
let marker = project.root.join(".git/CHERRY_PICK_HEAD");
|
||||
let message = project.root.join(".git/MERGE_MSG");
|
||||
std::fs::write(&marker, format!("{}\n", project.head)).unwrap();
|
||||
std::fs::write(&message, "Review staged changes\n").unwrap();
|
||||
let result = vcs::vcs_review_apply_commit(host, w, root(), RequestId(8)).await;
|
||||
std::fs::remove_file(marker).unwrap();
|
||||
std::fs::remove_file(message).unwrap();
|
||||
git(
|
||||
&project.root,
|
||||
&[
|
||||
"-c",
|
||||
"core.fsmonitor=false",
|
||||
"-c",
|
||||
"filter.marker.clean=",
|
||||
"reset",
|
||||
"-q",
|
||||
"HEAD",
|
||||
"--",
|
||||
"src/a.txt",
|
||||
],
|
||||
);
|
||||
result.ok().flatten().is_some_and(|review| review.paths.len() == 1 && review.paths[0].0 == file)
|
||||
}),
|
||||
),
|
||||
// Last: it rewrites nothing of an existing repository, but it does touch it.
|
||||
call!("vcs_init", "", vcs::vcs_init(host, w, project.root.clone())),
|
||||
call!("vcs_init", "", vcs::vcs_init(host, project.root.clone())),
|
||||
];
|
||||
|
||||
// The sweep covers every `vcs_*` command declared `trust = always`: a newly allowed one fails
|
||||
|
||||
@@ -85,7 +85,7 @@ impl Drop for Fixture {
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn checkout_reloads_clean_open_documents_before_returning() {
|
||||
let f = Fixture::new().await;
|
||||
vcs::vcs_checkout(&f.host, "main", None, "other".into(), false, None, None).await.unwrap();
|
||||
vcs::vcs_checkout(&f.host, "main", None, "other".into(), false, None).await.unwrap();
|
||||
f.assert_clean(OTHER);
|
||||
}
|
||||
|
||||
@@ -104,8 +104,7 @@ async fn stash_and_unstash_reload_clean_open_documents_before_returning() {
|
||||
f.saved_edit(&edited);
|
||||
vcs::vcs_stash_push(&f.host, "main", None, None, false, false, None).await.unwrap();
|
||||
f.assert_clean(ORIGINAL);
|
||||
let selected = vcs::vcs_stashes(&f.host, "main", None).await.unwrap().remove(0);
|
||||
vcs::vcs_stash_apply(&f.host, "main", None, selected, true, false, None).await.unwrap();
|
||||
vcs::vcs_stash_apply(&f.host, "main", None, 0, true, false, None).await.unwrap();
|
||||
f.assert_clean(&edited);
|
||||
}
|
||||
|
||||
@@ -115,39 +114,17 @@ async fn applying_patch_reloads_clean_open_documents_before_returning() {
|
||||
std::fs::write(&f.path, OTHER).unwrap();
|
||||
let patch = git(&f.project.root, &["diff"]);
|
||||
git(&f.project.root, &["restore", "."]);
|
||||
vcs::vcs_apply_patch(&f.host, "main", None, patch, None).await.unwrap();
|
||||
vcs::vcs_apply_patch(&f.host, "main", None, patch).await.unwrap();
|
||||
f.assert_clean(OTHER);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn writing_patch_file_reloads_its_clean_open_document() {
|
||||
let f = Fixture::new().await;
|
||||
vcs::vcs_write_patch(&f.host, "main", f.path.clone(), OTHER.into(), None).await.unwrap();
|
||||
vcs::vcs_write_patch(&f.host, "main", f.path.clone(), OTHER.into()).await.unwrap();
|
||||
f.assert_clean(OTHER);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn patch_file_encoding_round_trips_without_normalizing_hunks() {
|
||||
let f = Fixture::new().await;
|
||||
let path = f.project.root.join("export.patch");
|
||||
let patch =
|
||||
"diff --git a/notes.txt b/notes.txt\n--- a/notes.txt\n+++ b/notes.txt\n@@ -1 +1 @@\n-Café\r\n+Voilà\r\n";
|
||||
vcs::vcs_write_patch(&f.host, "main", path.clone(), patch.into(), Some("utf-16le".into())).await.unwrap();
|
||||
assert!(std::fs::read(&path).unwrap().starts_with(&[0xff, 0xfe]));
|
||||
assert_eq!(vcs::vcs_read_patch(&f.host, "main", path.clone()).await.unwrap(), patch);
|
||||
|
||||
vcs::vcs_write_patch(&f.host, "main", path.clone(), patch.into(), Some("windows-1252".into())).await.unwrap();
|
||||
let encoded = std::fs::read(&path).unwrap();
|
||||
assert!(encoded.windows(5).any(|bytes| bytes == b"Caf\xe9\r"));
|
||||
assert!(
|
||||
vcs::vcs_write_patch(&f.host, "main", path.clone(), "你好".into(), Some("windows-1252".into())).await.is_err()
|
||||
);
|
||||
assert_eq!(std::fs::read(&path).unwrap(), encoded);
|
||||
|
||||
std::fs::write(&path, patch).unwrap();
|
||||
assert_eq!(vcs::vcs_read_patch(&f.host, "main", path).await.unwrap(), patch);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn directory_compare_overwrite_reloads_clean_open_documents() {
|
||||
let f = Fixture::new().await;
|
||||
@@ -207,7 +184,7 @@ async fn working_tree_operation_does_not_discard_unsaved_edits() {
|
||||
.documents
|
||||
.edit(f.doc, version, ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: "-- local\n".into() }] })
|
||||
.unwrap();
|
||||
vcs::vcs_checkout(&f.host, "main", None, "other".into(), false, None, None).await.unwrap();
|
||||
vcs::vcs_checkout(&f.host, "main", None, "other".into(), false, None).await.unwrap();
|
||||
let snapshot = f.project.documents.snapshot(f.doc).unwrap();
|
||||
assert_eq!(snapshot.text, format!("-- local\n{ORIGINAL}"));
|
||||
assert!(snapshot.dirty);
|
||||
@@ -258,6 +235,6 @@ async fn worktree_checkout_hook_reloads_clean_open_documents() {
|
||||
std::fs::write(&hook, "#!/bin/sh\nprintf 'SELECT hook;' > ../project/node_modules/query.sql\n").unwrap();
|
||||
std::fs::set_permissions(&hook, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let linked = f.project.root.parent().unwrap().join("linked");
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked, "other".into(), None, None, None).await.unwrap();
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked, "other".into(), None).await.unwrap();
|
||||
f.assert_clean("SELECT hook;");
|
||||
}
|
||||
@@ -151,11 +151,7 @@ async fn change_commit_branch_stash_and_merge_a_conflict() {
|
||||
assert!(ops::vcs::vcs_line_hunks(&f.host, WINDOW, lib_path.clone()).await.unwrap().is_empty());
|
||||
|
||||
// A branch changes the line its way.
|
||||
let created =
|
||||
ops::vcs::vcs_create_branch(&f.host, WINDOW, None, "feature".into(), None, true, None, None, None, None)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(created.created.is_some());
|
||||
ops::vcs::vcs_create_branch(&f.host, WINDOW, None, "feature".into(), None, true, None).await.unwrap();
|
||||
let theirs = "pub fn format_price(cents: u64) -> String { // feature";
|
||||
f.edit_line(lib, theirs).await;
|
||||
f.save(lib).await;
|
||||
@@ -164,7 +160,7 @@ async fn change_commit_branch_stash_and_merge_a_conflict() {
|
||||
assert!(branches.iter().any(|b| b.name == "feature" && b.current), "{branches:?}");
|
||||
|
||||
// Back on main, the open file shows main's text.
|
||||
ops::vcs::vcs_checkout(&f.host, WINDOW, None, "main".into(), false, None, None).await.unwrap();
|
||||
ops::vcs::vcs_checkout(&f.host, WINDOW, None, "main".into(), false, None).await.unwrap();
|
||||
assert!(f.text(lib).await.contains(base));
|
||||
|
||||
// Stash: work in progress put aside and brought back.
|
||||
@@ -177,7 +173,7 @@ async fn change_commit_branch_stash_and_merge_a_conflict() {
|
||||
assert!(!f.text(main_rs).await.contains("work in progress"));
|
||||
let stashes = ops::vcs::vcs_stashes(&f.host, WINDOW, None).await.unwrap();
|
||||
assert!(matches!(&stashes[..], [s] if s.message.contains("wip")), "{stashes:?}");
|
||||
ops::vcs::vcs_stash_apply(&f.host, WINDOW, None, stashes[0].clone(), true, false, None).await.unwrap();
|
||||
ops::vcs::vcs_stash_apply(&f.host, WINDOW, None, 0, true, false, None).await.unwrap();
|
||||
assert_eq!(f.text(main_rs).await, wip);
|
||||
assert!(ops::vcs::vcs_stashes(&f.host, WINDOW, None).await.unwrap().is_empty());
|
||||
ops::vcs::vcs_discard(&f.host, WINDOW, vec![f.root.join("src/main.rs")]).await.unwrap();
|
||||
@@ -188,8 +184,7 @@ async fn change_commit_branch_stash_and_merge_a_conflict() {
|
||||
f.edit_line(lib, ours).await;
|
||||
f.save(lib).await;
|
||||
f.commit(&["src/lib.rs"], "Main's change").await;
|
||||
let merged = ops::vcs::vcs_merge(&f.host, WINDOW, None, "feature".into(), None, false).await;
|
||||
assert!(matches!(merged, Ok(ide_vcs::MergeOutcome::Conflicts)), "{merged:?}");
|
||||
let merged = ops::vcs::vcs_merge(&f.host, WINDOW, None, "feature".into()).await;
|
||||
let status = f.status().await;
|
||||
let conflicted = changed(&status, "src/lib.rs").map(|s| (s.staged, s.unstaged));
|
||||
assert!(
|
||||
@@ -219,7 +214,7 @@ async fn checkout_reports_a_branch_held_by_another_worktree() {
|
||||
let linked = f._tmp.path().join("linked");
|
||||
git(&f.root, &["worktree", "add", "-q", "-b", "topic", linked.to_str().unwrap()]);
|
||||
|
||||
let outcome = ops::vcs::vcs_checkout(&f.host, WINDOW, None, "topic".into(), false, None, None).await.unwrap();
|
||||
let outcome = ops::vcs::vcs_checkout(&f.host, WINDOW, None, "topic".into(), false, None).await.unwrap();
|
||||
assert_eq!(
|
||||
outcome,
|
||||
ide_vcs::CheckoutOutcome::CheckedOutInWorktree {
|
||||
|
||||
@@ -23,10 +23,6 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("same.txt"), format!("root {i}\n")).unwrap();
|
||||
let source = root.join("located/src");
|
||||
std::fs::create_dir_all(&source).unwrap();
|
||||
std::fs::write(source.join("settings.txt"), format!("port={}\n", if i == 0 { 900 } else { 100 })).unwrap();
|
||||
std::fs::write(source.join("report.txt"), "total=100\n").unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
std::fs::write(root.join("same.txt"), format!("changed {i}\n")).unwrap();
|
||||
@@ -47,452 +43,27 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
host.trust.decide(&project_root, true, false).unwrap();
|
||||
let project = host.open_project("main", &project_root).unwrap();
|
||||
for _ in 0..500 {
|
||||
if project.repos().all().len() == 2
|
||||
&& !project.index.status().indexing
|
||||
&& project.index.files_named("settings.txt").len() == 2
|
||||
{
|
||||
if project.repos().all().len() == 2 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(project.repos().all().len(), 2);
|
||||
|
||||
let source = roots[1].join("located/src");
|
||||
let original = source.join("report.txt");
|
||||
let renamed = source.join("new report.txt");
|
||||
git(&roots[1], &["mv", "located/src/report.txt", "located/src/new report.txt"]);
|
||||
let patch = vcs::vcs_create_patch(
|
||||
&host,
|
||||
"main",
|
||||
None,
|
||||
vcs::PatchSource::Changes { paths: vec![original.into(), renamed.into()], reverse: false },
|
||||
Some(roots[1].join("located")),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(patch.contains("rename from src/report.txt\n"));
|
||||
let preview =
|
||||
vcs::vcs_patch_preview(&host, "main", Some(roots[1].clone()), patch, Some(vcs::PatchTarget::Repository), None)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(preview.files.len(), 1);
|
||||
assert_eq!(preview.files[0].old_path.as_deref(), Some("src/report.txt"));
|
||||
assert_eq!(preview.files[0].path, "src/new report.txt");
|
||||
git(&roots[1], &["reset", "--hard", "HEAD"]);
|
||||
|
||||
for (i, root) in roots.iter().enumerate() {
|
||||
let patch = vcs::vcs_create_patch(
|
||||
&host,
|
||||
"main",
|
||||
Some(root.clone()),
|
||||
vcs::PatchSource::Commits { commits: vec![revisions[i].clone()], reverse: true },
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(patch.contains(&format!("-changed {i}")));
|
||||
let preview =
|
||||
vcs::vcs_patch_preview(&host, "main", Some(root.clone()), patch.clone(), None, None).await.unwrap();
|
||||
assert!(preview.base.is_none());
|
||||
assert_eq!(preview.files.len(), 1);
|
||||
vcs::vcs_apply_patch(&host, "main", Some(root.clone()), patch, Some(vec!["same.txt".into()])).await.unwrap();
|
||||
assert_eq!(vcs::vcs_patch_preview(&host, "main", Some(root.clone()), patch.clone()).await.unwrap().len(), 1);
|
||||
vcs::vcs_apply_patch(&host, "main", Some(root.clone()), patch).await.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(root.join("same.txt")).unwrap(), format!("root {i}\n"));
|
||||
}
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new(), None).await.is_err());
|
||||
|
||||
for (i, root) in roots.iter().enumerate() {
|
||||
std::fs::write(root.join("same.txt"), format!("project patch {i}\n")).unwrap();
|
||||
}
|
||||
let entries = roots
|
||||
.iter()
|
||||
.map(|root| ide_vcs::StagingPatchEntry {
|
||||
path: root.join("same.txt").into(),
|
||||
renamed_from: None,
|
||||
side: ide_vcs::StagingPatchSide::Unstaged,
|
||||
})
|
||||
.collect();
|
||||
let patch = vcs::vcs_create_patch(&host, "main", None, vcs::PatchSource::Staging { entries, reverse: false }, None)
|
||||
.await
|
||||
.unwrap();
|
||||
let selected_changes = || vcs::PatchSource::Changes {
|
||||
paths: roots.iter().map(|root| root.join("same.txt").into()).collect(),
|
||||
reverse: false,
|
||||
};
|
||||
let combined =
|
||||
vcs::vcs_create_patch(&host, "main", None, selected_changes(), Some(project_root.clone())).await.unwrap();
|
||||
assert!(combined.contains("diff --git a/front/same.txt b/front/same.txt"));
|
||||
assert!(combined.contains("diff --git a/back/same.txt b/back/same.txt"));
|
||||
let error =
|
||||
vcs::vcs_create_patch(&host, "main", None, selected_changes(), Some(roots[0].clone())).await.unwrap_err();
|
||||
assert_eq!(error.message, "The base directory must contain every selected path");
|
||||
for root in &roots {
|
||||
git(root, &["restore", "--", "same.txt"]);
|
||||
}
|
||||
let preview =
|
||||
vcs::vcs_patch_preview(&host, "main", Some(roots[0].clone()), patch.clone(), None, None).await.unwrap();
|
||||
assert_eq!(preview.base.unwrap(), project_root);
|
||||
assert_eq!(
|
||||
preview.files.iter().map(|file| file.path.as_str()).collect::<Vec<_>>(),
|
||||
["back/same.txt", "front/same.txt"]
|
||||
);
|
||||
assert!(preview.files.iter().all(|file| file.applies));
|
||||
let diff = vcs::vcs_patch_file_diff(
|
||||
&host,
|
||||
"main",
|
||||
Some(roots[1].clone()),
|
||||
Some(project_root.clone()),
|
||||
patch.clone(),
|
||||
"front/same.txt".into(),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(diff.path, roots[0].join("same.txt"));
|
||||
assert!(matches!(
|
||||
diff.content,
|
||||
ide_vcs::PatchDiffContent::Text { before: Some(before), after: Some(after) }
|
||||
if before == "changed 0\n" && after == "project patch 0\n"
|
||||
));
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join("same.txt")).unwrap(), "changed 0\n");
|
||||
|
||||
let explicit_repo = vcs::vcs_patch_preview(
|
||||
&host,
|
||||
"main",
|
||||
Some(roots[0].clone()),
|
||||
patch.clone(),
|
||||
Some(vcs::PatchTarget::Repository),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(explicit_repo.base.is_none());
|
||||
assert!(explicit_repo.files.iter().all(|file| !file.applies));
|
||||
assert!(vcs::vcs_apply_project_patch(&host, "main", base.join("outside"), patch.clone(), None).await.is_err());
|
||||
let cross_root_rename = "diff --git a/front/same.txt b/back/moved.txt\nsimilarity index 100%\nrename from front/same.txt\nrename to back/moved.txt\n";
|
||||
assert!(
|
||||
vcs::vcs_apply_project_patch(&host, "main", project_root.clone(), cross_root_rename.into(), None)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
let selected = vcs::vcs_apply_project_patch(
|
||||
&host,
|
||||
"main",
|
||||
project_root.clone(),
|
||||
patch.clone(),
|
||||
Some(vec!["front/same.txt".into()]),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(selected.outcome.applied, ["front/same.txt"]);
|
||||
assert!(selected.failures.is_empty());
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join("same.txt")).unwrap(), "project patch 0\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[1].join("same.txt")).unwrap(), "changed 1\n");
|
||||
git(&roots[0], &["restore", "--", "same.txt"]);
|
||||
std::fs::write(roots[1].join("same.txt"), "local edit\n").unwrap();
|
||||
|
||||
let partial = vcs::vcs_apply_project_patch(&host, "main", project_root.clone(), patch.clone(), None).await.unwrap();
|
||||
assert_eq!(partial.outcome.applied, ["front/same.txt"]);
|
||||
assert!(partial.outcome.conflicts.is_empty());
|
||||
assert_eq!(partial.failures.len(), 1);
|
||||
assert_eq!(partial.failures[0].root, roots[1]);
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join("same.txt")).unwrap(), "project patch 0\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[1].join("same.txt")).unwrap(), "local edit\n");
|
||||
for root in &roots {
|
||||
assert!(git(root, &["diff", "--cached", "--name-only"]).is_empty());
|
||||
}
|
||||
git(&roots[0], &["restore", "--", "same.txt"]);
|
||||
git(&roots[1], &["commit", "-am", "conflicting local commit"]);
|
||||
let conflicted = vcs::vcs_apply_project_patch(&host, "main", project_root, patch, None).await.unwrap();
|
||||
assert_eq!(conflicted.outcome.applied, ["front/same.txt"]);
|
||||
assert_eq!(conflicted.outcome.conflicts, ["back/same.txt"]);
|
||||
assert_eq!(conflicted.conflicted_repositories, [roots[1].clone()]);
|
||||
assert!(conflicted.failures.is_empty());
|
||||
assert_eq!(git(&roots[1], &["diff", "--name-only", "--diff-filter=U"]), "same.txt");
|
||||
let conflict = roots[1].join("same.txt");
|
||||
let versions = vcs::vcs_conflict_versions(&host, "main", conflict.clone()).await.unwrap();
|
||||
assert_eq!(versions.sides.operation.as_deref(), Some("apply-patch"));
|
||||
assert!(!versions.sides.reversed);
|
||||
assert_eq!(versions.ours.as_deref(), Some("local edit\n"));
|
||||
assert_eq!(versions.theirs.as_deref(), Some("project patch 1\n"));
|
||||
vcs::vcs_accept_conflict_side(&host, "main", vec![conflict.clone()], ide_vcs::ConflictSide::Theirs).await.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(conflict).unwrap(), "project patch 1\n");
|
||||
|
||||
git(&roots[1], &["restore", "--source=HEAD", "--staged", "--worktree", "--", "same.txt"]);
|
||||
let target = roots[1].join("moved here");
|
||||
std::fs::create_dir_all(&target).unwrap();
|
||||
std::fs::write(target.join("before.txt"), "content\n").unwrap();
|
||||
let source = "legacy/path/after.txt";
|
||||
let patch = concat!(
|
||||
"diff --git a/legacy/path/before.txt b/legacy/path/after.txt\n",
|
||||
"similarity index 100%\nrename from legacy/path/before.txt\nrename to legacy/path/after.txt\n",
|
||||
"diff --git a/same.txt b/same.txt\n--- a/same.txt\n+++ b/same.txt\n",
|
||||
"@@ -1 +1 @@\n-project patch 0\n+unselected\n"
|
||||
);
|
||||
let mapping = || ide_vcs::PatchPathMapping {
|
||||
path: source.into(),
|
||||
directory: Some(target.clone().into()),
|
||||
strip: 2,
|
||||
file: None,
|
||||
};
|
||||
let make_invalid = |directory| ide_vcs::PatchPathMapping {
|
||||
path: "same.txt".into(),
|
||||
directory: Some(directory),
|
||||
strip: 0,
|
||||
file: None,
|
||||
};
|
||||
let preview = vcs::vcs_patch_preview(
|
||||
&host,
|
||||
"main",
|
||||
Some(roots[0].clone()),
|
||||
patch.into(),
|
||||
Some(vcs::PatchTarget::Repository),
|
||||
Some(vec![mapping(), make_invalid(base.clone().into())]),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(preview.files[0].applies);
|
||||
assert!(!preview.files[1].applies);
|
||||
let placements = preview.placements.unwrap();
|
||||
assert_eq!(placements[0].target.as_ref().unwrap(), &target.join("after.txt"));
|
||||
assert!(placements[1].error.is_some());
|
||||
let diff = vcs::vcs_patch_file_diff(
|
||||
&host,
|
||||
"main",
|
||||
Some(roots[0].clone()),
|
||||
None,
|
||||
patch.into(),
|
||||
source.into(),
|
||||
Some(vec![mapping()]),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(diff.path, target.join("after.txt"));
|
||||
assert_eq!(diff.old_path.unwrap(), target.join("before.txt"));
|
||||
assert!(
|
||||
matches!(diff.content, ide_vcs::PatchDiffContent::Text { before: Some(before), after: Some(after) } if before == "content\n" && before == after)
|
||||
);
|
||||
assert!(target.join("before.txt").exists());
|
||||
assert!(!target.join("after.txt").exists());
|
||||
assert!(
|
||||
vcs::vcs_apply_mapped_patch(
|
||||
&host,
|
||||
"main",
|
||||
Some(roots[0].clone()),
|
||||
None,
|
||||
patch.into(),
|
||||
None,
|
||||
vec![mapping(), make_invalid(base.into())],
|
||||
)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert!(target.join("before.txt").exists());
|
||||
let applied = vcs::vcs_apply_mapped_patch(
|
||||
&host,
|
||||
"main",
|
||||
Some(roots[0].clone()),
|
||||
None,
|
||||
patch.into(),
|
||||
Some(vec![source.into()]),
|
||||
vec![mapping()],
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(applied.failures.is_empty());
|
||||
assert_eq!(applied.outcome.applied, [ide_core::ipc_path::to_ipc(&target.join("after.txt"))]);
|
||||
assert!(!target.join("before.txt").exists());
|
||||
assert_eq!(std::fs::read_to_string(target.join("after.txt")).unwrap(), "content\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join("same.txt")).unwrap(), "project patch 0\n");
|
||||
|
||||
let patch = concat!(
|
||||
"diff --git a/legacy/original.txt b/legacy/renamed.txt\n",
|
||||
"similarity index 55%\nrename from legacy/original.txt\nrename to legacy/renamed.txt\n",
|
||||
"--- a/legacy/original.txt\n+++ b/legacy/renamed.txt\n",
|
||||
"@@ -1 +1 @@\n-content\n+repaired content\n",
|
||||
);
|
||||
let source = "legacy/renamed.txt";
|
||||
let existing = target.join("local name.txt");
|
||||
std::fs::write(&existing, "content\n").unwrap();
|
||||
let to_file = |path: &std::path::Path| ide_vcs::PatchPathMapping {
|
||||
path: source.into(),
|
||||
directory: None,
|
||||
strip: 0,
|
||||
file: Some(path.into()),
|
||||
};
|
||||
let root = Some(roots[0].clone());
|
||||
let preview = vcs::vcs_patch_preview(&host, "main", root.clone(), patch.into(), None, None).await.unwrap();
|
||||
assert!(preview.files[0].missing_base);
|
||||
let invalid = vcs::vcs_patch_preview(&host, "main", root.clone(), patch.into(), None, Some(vec![to_file(&target)]))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(invalid.placements.unwrap()[0].error.is_some());
|
||||
let mapped =
|
||||
vcs::vcs_patch_preview(&host, "main", root.clone(), patch.into(), None, Some(vec![to_file(&existing)]))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(mapped.files[0].path, source);
|
||||
assert!(!mapped.files[0].missing_base);
|
||||
assert!(mapped.files[0].applies);
|
||||
assert_eq!(mapped.placements.unwrap()[0].target.as_ref().unwrap(), &existing);
|
||||
let diff = vcs::vcs_patch_file_diff(
|
||||
&host,
|
||||
"main",
|
||||
root.clone(),
|
||||
None,
|
||||
patch.into(),
|
||||
source.into(),
|
||||
Some(vec![to_file(&existing)]),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(diff.path, existing);
|
||||
assert!(diff.old_path.is_none());
|
||||
assert!(matches!(diff.content, ide_vcs::PatchDiffContent::Text { before: Some(before), after: Some(after) }
|
||||
if before == "content\n" && after == "repaired content\n"));
|
||||
let applied = vcs::vcs_apply_mapped_patch(&host, "main", root, None, patch.into(), None, vec![to_file(&existing)])
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(applied.failures.is_empty());
|
||||
assert_eq!(applied.outcome.applied, [ide_core::ipc_path::to_ipc(&existing)]);
|
||||
assert_eq!(std::fs::read_to_string(&existing).unwrap(), "repaired content\n");
|
||||
assert!(!roots[0].join(source).exists() && !target.join("renamed.txt").exists());
|
||||
|
||||
let patch = concat!(
|
||||
"diff --git a/checkout/src/settings.txt b/checkout/src/settings.txt\n",
|
||||
"--- a/checkout/src/settings.txt\n+++ b/checkout/src/settings.txt\n",
|
||||
"@@ -1 +1 @@\n-port=100\n+port=200\n",
|
||||
"diff --git a/checkout/src/report.txt b/checkout/src/report.txt\n",
|
||||
"--- a/checkout/src/report.txt\n+++ b/checkout/src/report.txt\n",
|
||||
"@@ -1 +1 @@\n-total=100\n+total=200\n",
|
||||
);
|
||||
let root = Some(roots[0].clone());
|
||||
let preview = vcs::vcs_patch_preview(&host, "main", root.clone(), patch.into(), None, None).await.unwrap();
|
||||
let automatic = preview.automatic_mappings;
|
||||
assert_eq!(automatic.len(), 1);
|
||||
assert_eq!(automatic[0].path, "checkout/src/settings.txt");
|
||||
assert_eq!(automatic[0].directory.as_ref().unwrap(), &roots[1].join("located"));
|
||||
assert_eq!(automatic[0].strip, 1);
|
||||
assert!(preview.files[0].applies && !preview.files[0].missing_base);
|
||||
assert!(preview.files[1].missing_base);
|
||||
assert_eq!(preview.directory_matches[0].candidates[0].applies, Some(true));
|
||||
assert_eq!(preview.directory_matches[0].candidates[1].applies, Some(false));
|
||||
assert_eq!(preview.directory_matches[1].candidates.len(), 2);
|
||||
assert!(preview.directory_matches[1].candidates.iter().all(|candidate| candidate.applies == Some(true)));
|
||||
let repo_only =
|
||||
vcs::vcs_patch_preview(&host, "main", root.clone(), patch.into(), Some(vcs::PatchTarget::Repository), None)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(repo_only.automatic_mappings.is_empty());
|
||||
assert!(repo_only.files.iter().all(|file| file.missing_base));
|
||||
assert!(repo_only.directory_matches.iter().all(|matches| matches.candidates.len() == 1));
|
||||
let report = preview.directory_matches[1]
|
||||
.candidates
|
||||
.iter()
|
||||
.find(|candidate| candidate.source.starts_with(&roots[0]))
|
||||
.unwrap();
|
||||
let selected = ide_vcs::PatchPathMapping {
|
||||
path: "checkout/src/report.txt".into(),
|
||||
directory: Some(report.directory.clone()),
|
||||
strip: report.strip,
|
||||
file: None,
|
||||
};
|
||||
let reset = ide_vcs::PatchPathMapping { path: automatic[0].path.clone(), directory: None, strip: 0, file: None };
|
||||
let reset_preview =
|
||||
vcs::vcs_patch_preview(&host, "main", root.clone(), patch.into(), None, Some(vec![reset])).await.unwrap();
|
||||
assert!(reset_preview.automatic_mappings.is_empty());
|
||||
assert!(reset_preview.files[0].missing_base);
|
||||
let mappings = [automatic, vec![selected]].concat();
|
||||
let diff = vcs::vcs_patch_file_diff(
|
||||
&host,
|
||||
"main",
|
||||
root.clone(),
|
||||
None,
|
||||
patch.into(),
|
||||
mappings[0].path.clone(),
|
||||
Some(mappings.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(diff.path, roots[1].join("located/src/settings.txt"));
|
||||
let applied = vcs::vcs_apply_mapped_patch(&host, "main", root, None, patch.into(), None, mappings).await.unwrap();
|
||||
assert!(applied.failures.is_empty());
|
||||
assert_eq!(applied.outcome.applied.len(), 2);
|
||||
assert_eq!(std::fs::read_to_string(&*report.source).unwrap(), "total=200\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[1].join("located/src/report.txt")).unwrap(), "total=100\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[1].join("located/src/settings.txt")).unwrap(), "port=200\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join("located/src/settings.txt")).unwrap(), "port=900\n");
|
||||
|
||||
// Empty folders never appear in the filename index. The patch should still preserve
|
||||
// the new subfolder beneath the matched parent and leave a tie at the original path.
|
||||
let mail = roots[1].join("modules/mail/templates");
|
||||
let ignored = roots[0].join("cache/mail/templates");
|
||||
for path in [&mail, &ignored, &roots[0].join("alpha/widgets/templates"), &roots[1].join("beta/widgets/templates")] {
|
||||
std::fs::create_dir_all(path).unwrap();
|
||||
}
|
||||
std::fs::write(roots[0].join(".git/info/exclude"), "/cache/\n").unwrap();
|
||||
let new_mail = "checkout/mail/templates/emails/welcome.txt";
|
||||
let new_widget = "checkout/widgets/templates/banner.txt";
|
||||
let existing_parent = "located/src/new-settings.txt";
|
||||
let generic_parent = "checkout/src/new-module.txt";
|
||||
let patch = [new_mail, new_widget, existing_parent, generic_parent]
|
||||
.iter()
|
||||
.map(|path| {
|
||||
format!("diff --git a/{path} b/{path}\nnew file mode 100644\n--- /dev/null\n+++ b/{path}\n@@ -0,0 +1 @@\n+new content\n")
|
||||
})
|
||||
.collect::<String>();
|
||||
let root = Some(roots[0].clone());
|
||||
let preview = vcs::vcs_patch_preview(&host, "main", root.clone(), patch.clone(), None, None).await.unwrap();
|
||||
assert!(preview.files.iter().all(|file| file.applies && !file.missing_base));
|
||||
assert_eq!(preview.automatic_mappings.len(), 1);
|
||||
assert_eq!(preview.automatic_mappings[0].path, new_mail);
|
||||
assert_eq!(preview.automatic_mappings[0].strip, 1);
|
||||
assert_eq!(preview.automatic_mappings[0].directory.as_ref().unwrap(), &roots[1].join("modules"));
|
||||
assert_eq!(preview.directory_matches.len(), 2);
|
||||
assert_eq!(preview.directory_matches[0].path, new_mail);
|
||||
assert_eq!(preview.directory_matches[0].candidates.len(), 1);
|
||||
assert_eq!(preview.directory_matches[1].path, new_widget);
|
||||
assert_eq!(preview.directory_matches[1].candidates.len(), 2);
|
||||
let expected = mail.join("emails/welcome.txt");
|
||||
let placement = |path: &str| {
|
||||
let placements = preview.placements.as_ref().unwrap();
|
||||
placements.iter().find(|entry| entry.path == path).unwrap().target.as_ref().unwrap()
|
||||
};
|
||||
assert_eq!(placement(new_mail), &expected);
|
||||
assert_eq!(placement(new_widget), &roots[0].join(new_widget));
|
||||
assert_eq!(placement(existing_parent), &roots[0].join(existing_parent));
|
||||
assert_eq!(placement(generic_parent), &roots[0].join(generic_parent));
|
||||
let diff = vcs::vcs_patch_file_diff(
|
||||
&host,
|
||||
"main",
|
||||
root.clone(),
|
||||
None,
|
||||
patch.clone(),
|
||||
new_mail.into(),
|
||||
Some(preview.automatic_mappings.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(diff.path, expected);
|
||||
assert!(
|
||||
matches!(diff.content, ide_vcs::PatchDiffContent::Text { before: None, after: Some(after) } if after == "new content\n")
|
||||
);
|
||||
let applied = vcs::vcs_apply_mapped_patch(
|
||||
&host,
|
||||
"main",
|
||||
root,
|
||||
None,
|
||||
patch,
|
||||
Some(vec![new_mail.into(), new_widget.into()]),
|
||||
preview.automatic_mappings,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(applied.failures.is_empty());
|
||||
assert_eq!(applied.outcome.applied.len(), 2);
|
||||
assert_eq!(std::fs::read_to_string(expected).unwrap(), "new content\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join(new_widget)).unwrap(), "new content\n");
|
||||
assert!(!ignored.join("emails/welcome.txt").exists());
|
||||
assert!(!roots[0].join(existing_parent).exists());
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new()).await.is_err());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
|
||||
@@ -8,7 +8,27 @@ fn git(root: &Path, args: &[&str]) {
|
||||
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
|
||||
}
|
||||
|
||||
async fn open_project(base: &Path, root: &Path, repo_count: usize) -> Host {
|
||||
async fn check_shelves(layout: &str) {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let project_root = base.join("project");
|
||||
let roots = match layout {
|
||||
"same" => vec![project_root.clone()],
|
||||
"below" => vec![base.clone()],
|
||||
"two" => vec![project_root.join("项目A"), project_root.join("repoB")],
|
||||
_ => vec![project_root.join("项目A")],
|
||||
};
|
||||
std::fs::create_dir_all(project_root.join("dirB")).unwrap();
|
||||
for (i, root) in roots.iter().enumerate() {
|
||||
std::fs::create_dir_all(root.join("src")).unwrap();
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
std::fs::write(root.join("src/same.txt"), format!("base {i}\n")).unwrap();
|
||||
git(root, &["add", "src"]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
std::fs::write(root.join("src/same.txt"), format!("shelved {i}\n")).unwrap();
|
||||
}
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
@@ -20,99 +40,22 @@ async fn open_project(base: &Path, root: &Path, repo_count: usize) -> Host {
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(root, true, false).unwrap();
|
||||
let project = host.open_project("main", root).unwrap();
|
||||
host.trust.decide(&project_root, true, false).unwrap();
|
||||
let project = host.open_project("main", &project_root).unwrap();
|
||||
for _ in 0..500 {
|
||||
if project.repos().all().len() == repo_count {
|
||||
if project.repos().all().len() == roots.len() {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(project.repos().all().len(), repo_count);
|
||||
host
|
||||
}
|
||||
|
||||
async fn check_shelves(layout: &str) {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let project_root = base.join("project");
|
||||
let roots = match layout {
|
||||
"same" => vec![project_root.clone()],
|
||||
"below" => vec![base.clone()],
|
||||
"two" => vec![project_root.join("项目A"), project_root.join("repo B")],
|
||||
_ => vec![project_root.join("项目A")],
|
||||
};
|
||||
std::fs::create_dir_all(project_root.join("dirB")).unwrap();
|
||||
for (i, root) in roots.iter().enumerate() {
|
||||
std::fs::create_dir_all(root.join("src")).unwrap();
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("src/same.txt"), format!("base {i}\n")).unwrap();
|
||||
git(root, &["add", "src"]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
std::fs::write(root.join("src/same.txt"), format!("shelved {i}\n")).unwrap();
|
||||
}
|
||||
let host = open_project(&base, &project_root, roots.len()).await;
|
||||
let project = host.project("main").unwrap();
|
||||
assert_eq!(project.repos().all().len(), roots.len());
|
||||
let primary = project.repos().primary().unwrap().root().to_path_buf();
|
||||
if roots.len() == 2 {
|
||||
assert!(
|
||||
vcs::vcs_shelve(
|
||||
&host,
|
||||
"main",
|
||||
"outside".into(),
|
||||
vec![roots[0].join("src/same.txt"), project_root.join("dirB/unmapped.txt")],
|
||||
)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
let entry =
|
||||
vcs::vcs_shelve(&host, "main", "mixed".into(), roots.iter().map(|r| r.join("src/same.txt")).collect())
|
||||
.await
|
||||
.unwrap();
|
||||
let key = |root: &Path| format!("{}/src/same.txt", root.file_name().unwrap().to_str().unwrap());
|
||||
assert_eq!(entry.repo.as_deref(), Some(project_root.as_path()));
|
||||
assert_eq!(entry.files.len(), 2);
|
||||
let listed = vcs::vcs_shelves(&host, "main").await.unwrap();
|
||||
assert_eq!(listed.len(), 1);
|
||||
let diffs = vcs::vcs_shelf_diff(&host, "main", entry.id.clone()).await.unwrap();
|
||||
for (i, root) in roots.iter().enumerate() {
|
||||
let diff = diffs.iter().find(|diff| diff.path == key(root)).unwrap();
|
||||
assert_eq!(diff.before.as_deref(), Some(format!("base {i}\n").as_str()));
|
||||
assert_eq!(diff.after.as_deref(), Some(format!("shelved {i}\n").as_str()));
|
||||
assert_eq!(std::fs::read_to_string(root.join("src/same.txt")).unwrap(), format!("base {i}\n"));
|
||||
}
|
||||
let saved = ide_core::project_dir::path(&project_root, "shelf").join(&entry.id).join("shelf.json");
|
||||
let original = std::fs::read(&saved).unwrap();
|
||||
std::fs::remove_file(&saved).unwrap();
|
||||
assert!(vcs::vcs_unshelve(&host, "main", entry.id.clone(), true, None).await.is_err());
|
||||
let mut metadata: serde_json::Value = serde_json::from_slice(&original).unwrap();
|
||||
metadata["repositories"][1]["root"] = serde_json::json!(base.join("missing-repository"));
|
||||
std::fs::write(&saved, serde_json::to_vec(&metadata).unwrap()).unwrap();
|
||||
assert!(vcs::vcs_unshelve(&host, "main", entry.id.clone(), true, None).await.is_err());
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join("src/same.txt")).unwrap(), "base 0\n");
|
||||
std::fs::write(saved, original).unwrap();
|
||||
let chosen = key(&roots[1]);
|
||||
let patch = vcs::vcs_shelf_patch(&host, "main", entry.id.clone(), Some(chosen.clone()), None).await.unwrap();
|
||||
assert!(patch.contains(&format!("a/{chosen}")));
|
||||
assert!(!patch.contains("+shelved 0"));
|
||||
let relocated =
|
||||
vcs::vcs_shelf_patch(&host, "main", entry.id.clone(), Some(chosen.clone()), Some(roots[1].join("src")))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(relocated.contains("diff --git a/same.txt b/same.txt"));
|
||||
assert!(relocated.contains("+shelved 1"));
|
||||
assert!(!relocated.contains("+shelved 0"));
|
||||
let outcome = vcs::vcs_unshelve(&host, "main", entry.id.clone(), true, Some(chosen.clone())).await.unwrap();
|
||||
assert_eq!(outcome.applied, [chosen]);
|
||||
assert_eq!(std::fs::read_to_string(roots[0].join("src/same.txt")).unwrap(), "base 0\n");
|
||||
assert_eq!(std::fs::read_to_string(roots[1].join("src/same.txt")).unwrap(), "shelved 1\n");
|
||||
let remainder = vcs::vcs_shelves(&host, "main").await.unwrap();
|
||||
assert_eq!(remainder[0].files.iter().map(|file| file.path.as_str()).collect::<Vec<_>>(), [key(&roots[0])]);
|
||||
let outcome = vcs::vcs_unshelve(&host, "main", entry.id.clone(), true, None).await.unwrap();
|
||||
assert_eq!(outcome.applied, [key(&roots[0])]);
|
||||
.is_err()
|
||||
);
|
||||
assert!(vcs::vcs_shelves(&host, "main").await.unwrap().is_empty());
|
||||
}
|
||||
for (i, root) in roots.iter().enumerate() {
|
||||
@@ -125,7 +68,7 @@ async fn check_shelves(layout: &str) {
|
||||
assert_eq!(diffs[0].before.as_deref(), Some(format!("base {i}\n").as_str()));
|
||||
assert_eq!(diffs[0].after.as_deref(), Some(format!("shelved {i}\n").as_str()));
|
||||
vcs::vcs_shelf_rename(&host, "main", entry.id.clone(), "renamed".into()).await.unwrap();
|
||||
let patch = vcs::vcs_shelf_patch(&host, "main", entry.id.clone(), None, None).await.unwrap();
|
||||
let patch = vcs::vcs_shelf_patch(&host, "main", entry.id.clone(), None).await.unwrap();
|
||||
vcs::vcs_shelf_import(&host, "main", Some(root.clone()), "imported".into(), patch).await.unwrap();
|
||||
let imported =
|
||||
vcs::vcs_shelves(&host, "main").await.unwrap().into_iter().find(|s| s.name == "imported").unwrap();
|
||||
@@ -160,23 +103,6 @@ async fn check_shelves(layout: &str) {
|
||||
);
|
||||
}
|
||||
}
|
||||
if roots.len() == 2 {
|
||||
let entry =
|
||||
vcs::vcs_shelve(&host, "main", "conflicts".into(), roots.iter().map(|r| r.join("src/same.txt")).collect())
|
||||
.await
|
||||
.unwrap();
|
||||
std::fs::write(roots[0].join("src/same.txt"), "new HEAD\n").unwrap();
|
||||
git(&roots[0], &["commit", "-am", "conflicting change"]);
|
||||
let outcome = vcs::vcs_unshelve(&host, "main", entry.id.clone(), true, None).await.unwrap();
|
||||
let qualified = |root: &Path| format!("{}/src/same.txt", root.file_name().unwrap().to_str().unwrap());
|
||||
assert_eq!(outcome.conflicts, [qualified(&roots[0])]);
|
||||
assert_eq!(outcome.applied, [qualified(&roots[1])]);
|
||||
assert_eq!(std::fs::read_to_string(roots[1].join("src/same.txt")).unwrap(), "shelved 1\n");
|
||||
let listed = vcs::vcs_shelves(&host, "main").await.unwrap();
|
||||
let pending = listed.iter().find(|s| s.id == entry.id).unwrap();
|
||||
assert_eq!(pending.files.len(), 1);
|
||||
assert_eq!(pending.files[0].path, qualified(&roots[0]));
|
||||
}
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
@@ -196,85 +122,3 @@ async fn shelves_in_two_repositories() {
|
||||
async fn shelf_in_project_below_repository() {
|
||||
check_shelves("below").await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn automatic_shelf_batch_restores_repositories_independently() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let project_root = base.join("project");
|
||||
let clean = project_root.join("repo A");
|
||||
let paused = project_root.join("repo B");
|
||||
for root in [&clean, &paused] {
|
||||
std::fs::create_dir_all(root.join("src")).unwrap();
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
for file in ["src/same.txt", "src/deleted-shelf-file.txt", "merge.txt"] {
|
||||
std::fs::write(root.join(file), "base\n").unwrap();
|
||||
}
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "base"]);
|
||||
git(root, &["switch", "-c", "topic"]);
|
||||
std::fs::write(root.join("merge.txt"), "topic\n").unwrap();
|
||||
git(root, &["commit", "-am", "topic"]);
|
||||
git(root, &["switch", "main"]);
|
||||
}
|
||||
std::fs::write(paused.join("merge.txt"), "main\n").unwrap();
|
||||
git(&paused, &["commit", "-am", "main"]);
|
||||
std::fs::write(clean.join("src/same.txt"), "staged in A\n").unwrap();
|
||||
git(&clean, &["add", "src/same.txt"]);
|
||||
std::fs::write(clean.join("src/deleted-shelf-file.txt"), "remove from shelf\n").unwrap();
|
||||
std::fs::write(paused.join("src/same.txt"), "saved in B\n").unwrap();
|
||||
|
||||
let host = open_project(&base, &project_root, 2).await;
|
||||
let batch = uuid::Uuid::new_v4().to_string();
|
||||
let merge = |repo| vcs::vcs_merge(&host, "main", Some(repo), "topic".into(), Some(batch.clone()), true);
|
||||
assert_eq!(merge(clean.clone()).await.unwrap(), ide_vcs::MergeOutcome::Done);
|
||||
assert_eq!(merge(paused.clone()).await.unwrap(), ide_vcs::MergeOutcome::Conflicts);
|
||||
assert_eq!(std::fs::read_to_string(clean.join("src/same.txt")).unwrap(), "base\n");
|
||||
assert_eq!(std::fs::read_to_string(paused.join("src/same.txt")).unwrap(), "base\n");
|
||||
let shelves = vcs::vcs_shelves(&host, "main").await.unwrap();
|
||||
assert_eq!(shelves.len(), 1);
|
||||
let shelf = &shelves[0];
|
||||
assert_eq!(shelf.repo.as_deref(), Some(project_root.as_path()));
|
||||
assert_eq!(shelf.files.len(), 3);
|
||||
let diffs = vcs::vcs_shelf_diff(&host, "main", shelf.id.clone()).await.unwrap();
|
||||
for (path, after) in [("repo A/src/same.txt", "staged in A\n"), ("repo B/src/same.txt", "saved in B\n")] {
|
||||
let diff = diffs.iter().find(|diff| diff.path == path).unwrap();
|
||||
assert_eq!(diff.before.as_deref(), Some("base\n"));
|
||||
assert_eq!(diff.after.as_deref(), Some(after));
|
||||
}
|
||||
|
||||
let repositories = vec![Some(clean.clone()), Some(paused.clone())];
|
||||
vcs::vcs_finish_shelf_batch(&host, "main", uuid::Uuid::new_v4().to_string(), repositories.clone()).await.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(clean.join("src/same.txt")).unwrap(), "base\n");
|
||||
vcs::vcs_shelf_delete(&host, "main", shelf.id.clone(), Some("repo A/src/deleted-shelf-file.txt".into()))
|
||||
.await
|
||||
.unwrap();
|
||||
vcs::vcs_finish_shelf_batch(&host, "main", batch, repositories).await.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(clean.join("src/same.txt")).unwrap(), "staged in A\n");
|
||||
assert_eq!(std::fs::read_to_string(clean.join("src/deleted-shelf-file.txt")).unwrap(), "base\n");
|
||||
let index = Command::new("git").current_dir(&clean).args(["show", ":src/same.txt"]).output().unwrap();
|
||||
assert!(index.status.success());
|
||||
assert_eq!(index.stdout, b"staged in A\n");
|
||||
assert_eq!(std::fs::read_to_string(paused.join("src/same.txt")).unwrap(), "base\n");
|
||||
let pending = vcs::vcs_shelves(&host, "main").await.unwrap();
|
||||
assert_eq!(pending.len(), 1);
|
||||
assert_eq!(pending[0].id, shelf.id);
|
||||
assert_eq!(pending[0].files.len(), 1);
|
||||
assert_eq!(pending[0].files[0].path, "repo B/src/same.txt");
|
||||
vcs::vcs_operation(
|
||||
&host,
|
||||
"main",
|
||||
Some(paused.clone()),
|
||||
ide_core::RequestId(1),
|
||||
vcs::GitOperation::Abort { expected: Some("merge".into()), expected_rebase: None },
|
||||
ide_host::ops::Channel::new(|_| {}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(paused.join("src/same.txt")).unwrap(), "saved in B\n");
|
||||
assert!(vcs::vcs_shelves(&host, "main").await.unwrap().is_empty());
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
use ide_core::{NullSink, RequestId};
|
||||
use ide_core::NullSink;
|
||||
use ide_host::{Host, HostConfig, Project, ops::vcs};
|
||||
use std::{path::PathBuf, process::Command, sync::Arc, time::Duration};
|
||||
|
||||
@@ -62,38 +62,15 @@ impl Drop for Fixture {
|
||||
}
|
||||
}
|
||||
|
||||
fn setup_script(root: &std::path::Path, unix: &str, windows: &str) -> PathBuf {
|
||||
let file = root.join(if cfg!(windows) { "local setup.cmd" } else { "local setup.sh" });
|
||||
if cfg!(windows) {
|
||||
std::fs::write(&file, format!("@echo off\r\n{}", windows.replace('\n', "\r\n"))).unwrap();
|
||||
} else {
|
||||
std::fs::write(&file, format!("#!/bin/sh\n{unix}")).unwrap();
|
||||
}
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
std::fs::set_permissions(&file, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
}
|
||||
file
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn command_added_worktree_joins_the_repository_set() {
|
||||
let f = Fixture::new().await;
|
||||
let linked = f.root.join("linked");
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "main".into(), Some("topic".into()), None, None)
|
||||
.await
|
||||
.unwrap();
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "main".into(), Some("topic".into())).await.unwrap();
|
||||
let roots = f.project.repos().roots();
|
||||
assert!(roots.contains(&linked), "worktree below the project did not join the repository set: {roots:?}");
|
||||
assert_eq!(roots.len(), 2);
|
||||
std::fs::write(f.root.join(".worktreeinclude"), ".env\n").unwrap();
|
||||
let primary = vcs::vcs_worktree_include(&f.host, "main", Some(f.root.clone())).await.unwrap();
|
||||
let include = vcs::vcs_worktree_include(&f.host, "main", Some(linked.clone())).await.unwrap();
|
||||
assert!(primary.exists);
|
||||
assert!(!include.exists);
|
||||
assert_eq!(include.path.into_path_buf(), linked.join(".worktreeinclude"));
|
||||
let roots = vcs::vcs_roots(&f.host, "main").await.unwrap();
|
||||
let roots = vcs::vcs_roots(&f.host, "main").unwrap();
|
||||
assert_eq!(roots[0].root, f.root);
|
||||
assert_eq!(roots[0].branch_root, f.root);
|
||||
assert_eq!(roots[0].head.as_deref(), Some("main"));
|
||||
@@ -106,176 +83,12 @@ async fn command_added_worktree_joins_the_repository_set() {
|
||||
async fn removed_worktree_leaves_the_repository_set() {
|
||||
let f = Fixture::new().await;
|
||||
let linked = f.root.join("linked");
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "main".into(), Some("topic".into()), None, None)
|
||||
.await
|
||||
.unwrap();
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "main".into(), Some("topic".into())).await.unwrap();
|
||||
assert_eq!(f.project.repos().all().len(), 2);
|
||||
vcs::vcs_remove_worktree(&f.host, "main", None, linked, false).await.unwrap();
|
||||
assert_eq!(f.project.repos().all().len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn new_worktree_copies_requested_local_configuration() {
|
||||
let f = Fixture::new().await;
|
||||
let write = |name: &str, contents: &str| std::fs::write(f.root.join(name), contents).unwrap();
|
||||
write(".env.target", "checkout content");
|
||||
git(&f.root, &["add", ".env.target"]);
|
||||
git(&f.root, &["commit", "-m", "track a destination file"]);
|
||||
git(&f.root, &["branch", "older"]);
|
||||
git(&f.root, &["rm", ".env.target"]);
|
||||
write("old-only.txt", "committed");
|
||||
git(&f.root, &["add", "old-only.txt"]);
|
||||
git(&f.root, &["commit", "-m", "track another file"]);
|
||||
std::fs::create_dir_all(f.root.join(".openidea")).unwrap();
|
||||
write(".openidea/settings.toml", "local settings");
|
||||
write(".env", "local environment");
|
||||
write(".env.secret", "excluded by negated pattern");
|
||||
write(".env.staged", "local staged addition");
|
||||
write(".env.target", "local collision");
|
||||
git(&f.root, &["add", ".env.staged"]);
|
||||
write("file.txt", "local edits to a committed file");
|
||||
write(".worktreeinclude", ".openidea/settings.toml\n.env*\n!.env.secret\nfile.txt\nold-only.txt\n");
|
||||
|
||||
let linked = f.root.with_file_name("with config");
|
||||
let result = vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "older".into(), None, Some(true), None)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(result.copy_warning, None);
|
||||
for (name, contents) in [
|
||||
(".openidea/settings.toml", "local settings"),
|
||||
(".env", "local environment"),
|
||||
(".env.staged", "local staged addition"),
|
||||
(".env.target", "checkout content"),
|
||||
("file.txt", "original\n"),
|
||||
] {
|
||||
assert_eq!(std::fs::read_to_string(linked.join(name)).unwrap(), contents);
|
||||
}
|
||||
assert!(!linked.join(".env.secret").exists());
|
||||
assert!(!linked.join("old-only.txt").exists());
|
||||
|
||||
let no_copy = f.root.with_file_name("without config");
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, no_copy.clone(), "main".into(), Some("opt-out".into()), None, None)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(!no_copy.join(".env").exists());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn configuration_copy_failure_keeps_the_created_worktree() {
|
||||
let f = Fixture::new().await;
|
||||
std::fs::create_dir(f.root.join(".worktreeinclude")).unwrap();
|
||||
let include = vcs::vcs_worktree_include(&f.host, "main", None).await;
|
||||
assert!(matches!(include, Err(err) if err.kind == ide_core::error::ErrorKind::InvalidInput));
|
||||
let linked = f.root.with_file_name("still created");
|
||||
let result = vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "HEAD".into(), None, Some(true), None)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(result.copy_warning.is_some_and(|error| error.contains(".worktreeinclude")));
|
||||
assert!(linked.join("file.txt").exists());
|
||||
assert_eq!(vcs::vcs_worktrees(&f.host, "main", None).await.unwrap().len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn setup_runs_after_copy_in_the_new_worktree() {
|
||||
let f = Fixture::new().await;
|
||||
std::fs::write(f.root.join(".worktreeinclude"), ".env\n").unwrap();
|
||||
std::fs::write(f.root.join(".env"), "copied contents").unwrap();
|
||||
let script = setup_script(
|
||||
&f.root,
|
||||
"test \"$#\" -eq 1 || exit 11\npwd >setup-cwd.txt\nprintf '%s' \"$1\" >setup-arg.txt\ncat .env >setup-copy.txt\n",
|
||||
"if not \"%~2\"==\"\" exit /b 11\ncd >setup-cwd.txt\necho %1>setup-arg.txt\ntype .env >setup-copy.txt\n",
|
||||
);
|
||||
let linked = f.root.with_file_name("initialized worktree");
|
||||
let setup = vcs::WorktreeSetup { script, request: RequestId(1) };
|
||||
let result =
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "HEAD".into(), None, Some(true), Some(setup))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(result.copy_warning, None);
|
||||
assert_eq!(result.setup_warning, None);
|
||||
for name in ["setup-cwd.txt", "setup-arg.txt"] {
|
||||
let value = std::fs::read_to_string(linked.join(name)).unwrap();
|
||||
assert_eq!(dunce::canonicalize(value.trim().trim_matches('"')).unwrap(), linked);
|
||||
}
|
||||
assert_eq!(std::fs::read_to_string(linked.join("setup-copy.txt")).unwrap(), "copied contents");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn invalid_setup_refuses_creation_and_failed_setup_keeps_the_checkout() {
|
||||
let f = Fixture::new().await;
|
||||
let linked = f.root.with_file_name("failed setup");
|
||||
let setup = vcs::WorktreeSetup { script: f.root.join("does-not-exist"), request: RequestId(1) };
|
||||
assert!(
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "HEAD".into(), None, None, Some(setup))
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert!(!linked.exists());
|
||||
let script = setup_script(&f.root, "echo failed-script >&2\nexit 7\n", "echo failed-script 1>&2\nexit /b 7\n");
|
||||
let setup = vcs::WorktreeSetup { script, request: RequestId(2) };
|
||||
let result = vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "HEAD".into(), None, None, Some(setup))
|
||||
.await
|
||||
.unwrap();
|
||||
let warning = result.setup_warning.unwrap();
|
||||
assert!(warning.contains("code 7") && warning.contains("failed-script"), "{warning}");
|
||||
assert!(linked.join("file.txt").exists());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn skipping_setup_stops_the_process_and_keeps_the_checkout() {
|
||||
let f = Fixture::new().await;
|
||||
let script = setup_script(&f.root, "touch started\nsleep 45\n", "echo started>started\n:wait\ngoto wait\n");
|
||||
let linked = f.root.with_file_name("skipped setup");
|
||||
let request = RequestId(3);
|
||||
let setup = vcs::WorktreeSetup { script, request };
|
||||
let (result, ()) = tokio::join!(
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "HEAD".into(), None, None, Some(setup)),
|
||||
async {
|
||||
let started = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !linked.join("started").is_file() {
|
||||
tokio::time::sleep(Duration::from_millis(25)).await;
|
||||
}
|
||||
})
|
||||
.await;
|
||||
f.host.cancel_request(request);
|
||||
started.unwrap();
|
||||
},
|
||||
);
|
||||
assert_eq!(result.unwrap().setup_warning, None);
|
||||
assert!(linked.join("file.txt").exists());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn tagged_worktree_can_be_locked_unlocked_and_pruned() {
|
||||
let f = Fixture::new().await;
|
||||
// The tag and branch share a short name but point to different commits.
|
||||
git(&f.root, &["tag", "release"]);
|
||||
let first = vcs::vcs_worktrees(&f.host, "main", None).await.unwrap()[0].head.clone();
|
||||
git(&f.root, &["commit", "--allow-empty", "-m", "next"]);
|
||||
git(&f.root, &["branch", "release"]);
|
||||
|
||||
let linked = f.root.with_file_name("release copy");
|
||||
vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "refs/tags/release".into(), None, None, None)
|
||||
.await
|
||||
.unwrap();
|
||||
let list = vcs::vcs_worktrees(&f.host, "main", None).await.unwrap();
|
||||
assert_eq!(list.len(), 2);
|
||||
assert_eq!(list[1].branch, None);
|
||||
assert_eq!(list[1].head, first);
|
||||
|
||||
vcs::vcs_set_worktree_locked(&f.host, "main", None, linked.clone(), true).await.unwrap();
|
||||
assert!(vcs::vcs_worktrees(&f.host, "main", None).await.unwrap()[1].locked);
|
||||
vcs::vcs_prune_worktrees(&f.host, "main", None).await.unwrap();
|
||||
assert!(linked.join("file.txt").exists());
|
||||
vcs::vcs_set_worktree_locked(&f.host, "main", None, linked.clone(), false).await.unwrap();
|
||||
assert!(!vcs::vcs_worktrees(&f.host, "main", None).await.unwrap()[1].locked);
|
||||
|
||||
std::fs::remove_dir_all(&linked).unwrap();
|
||||
assert!(vcs::vcs_worktrees(&f.host, "main", None).await.unwrap()[1].prunable);
|
||||
vcs::vcs_prune_worktrees(&f.host, "main", None).await.unwrap();
|
||||
assert_eq!(vcs::vcs_worktrees(&f.host, "main", None).await.unwrap().len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn watcher_picks_up_a_worktree_added_below_the_project() {
|
||||
let f = Fixture::new().await;
|
||||
|
||||
@@ -8,8 +8,6 @@
|
||||
|
||||
use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
|
||||
use ignore::{WalkBuilder, WalkState};
|
||||
use std::collections::HashSet;
|
||||
use std::ffi::OsStr;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc;
|
||||
@@ -305,27 +303,6 @@ impl PathFilter {
|
||||
builder.build().flatten().filter(|e| e.file_type().is_some_and(|t| t.is_dir())).map(|e| e.into_path()).collect()
|
||||
}
|
||||
|
||||
pub(crate) fn directories_with_names(&self, names: &HashSet<&OsStr>) -> Vec<PathBuf> {
|
||||
let matches = parking_lot::Mutex::new(Vec::new());
|
||||
for root in self.roots() {
|
||||
let Some(mut builder) = self.walker(root) else { continue };
|
||||
builder.standard_filters(true).hidden(false).require_git(ide_core::ignored::inside_git_repo(root));
|
||||
let matches = &matches;
|
||||
builder.build_parallel().run(|| {
|
||||
Box::new(move |entry| {
|
||||
if let Ok(entry) = entry
|
||||
&& entry.file_type().is_some_and(|ty| ty.is_dir())
|
||||
&& names.contains(entry.file_name())
|
||||
{
|
||||
matches.lock().push(entry.into_path());
|
||||
}
|
||||
WalkState::Continue
|
||||
})
|
||||
});
|
||||
}
|
||||
matches.into_inner()
|
||||
}
|
||||
|
||||
/// All indexable files at or below `dir`, walked in parallel.
|
||||
/// Stops early (returning what was found so far) once `cancel` is set.
|
||||
pub(crate) fn walk(&self, dir: &Path, cancel: &AtomicBool) -> Vec<Found> {
|
||||
|
||||
@@ -8,8 +8,7 @@ use ide_language::{LanguageRegistry, Syntax};
|
||||
use parking_lot::Mutex;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::ffi::OsStr;
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::Ordering;
|
||||
@@ -281,28 +280,6 @@ impl ProjectIndex {
|
||||
files.into_iter().map(|file| file.path.clone()).collect()
|
||||
}
|
||||
|
||||
/// Find exact basenames across the indexed workspace in a single pass.
|
||||
pub fn files_with_names(&self, names: &HashSet<&OsStr>) -> Vec<PathBuf> {
|
||||
if names.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
self.shared
|
||||
.data
|
||||
.read()
|
||||
.files
|
||||
.iter()
|
||||
.flatten()
|
||||
.filter(|file| !file.ignored && file.path.file_name().is_some_and(|name| names.contains(name)))
|
||||
.map(|file| file.path.clone())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Exact folder names in the project scope, including empty folders absent from file search.
|
||||
/// Run off the caller's request thread because discovering those folders walks the disk.
|
||||
pub fn directories_with_names(&self, names: &HashSet<&OsStr>) -> Vec<PathBuf> {
|
||||
if names.is_empty() { Vec::new() } else { self.shared.filter().directories_with_names(names) }
|
||||
}
|
||||
|
||||
/// Up to `limit` indexed files below `dir` (VCS-ignored ones left out) whose path relative to
|
||||
/// `dir` satisfies `matches`: a file list without walking the disk. `None` while nothing is
|
||||
/// indexed yet (first scan without a cache).
|
||||
|
||||
@@ -156,8 +156,7 @@ pub struct LanguageServerConfig {
|
||||
pub requires_env: Vec<String>,
|
||||
/// Files whose presence marks a workspace root, e.g. `Cargo.toml`;
|
||||
/// `file#table` requires the TOML file to contain that dotted table, e.g.
|
||||
/// `pyproject.toml#tool.ruff`, or the JSON file that dotted key, e.g.
|
||||
/// `package.json#devDependencies.tailwindcss`.
|
||||
/// `pyproject.toml#tool.ruff`.
|
||||
#[serde(default)]
|
||||
pub root_markers: Vec<String>,
|
||||
/// Serve only files below a root marker, not the whole project: a framework's
|
||||
|
||||
@@ -58,12 +58,11 @@ pub fn arduino_sketch_root(project: &Path, path: &Path) -> Option<PathBuf> {
|
||||
|
||||
/// `dir` contains `marker`: a relative path, a file name pattern with one
|
||||
/// `*` (`*.csproj`), or a TOML or JSON file name (no pattern) and a dotted table
|
||||
/// or JSON key it must contain (`pyproject.toml#tool.ruff`, `package.json#eslintConfig`,
|
||||
/// `package.json#devDependencies.tailwindcss`).
|
||||
/// it must contain (`pyproject.toml#tool.ruff`, `package.json#eslintConfig`).
|
||||
fn has_marker(dir: &Path, marker: &str) -> bool {
|
||||
if let Some((file, table)) = marker.split_once('#') {
|
||||
return if file.ends_with(".json") {
|
||||
has_json_key(&dir.join(file), table)
|
||||
has_json_object(&dir.join(file), table)
|
||||
} else {
|
||||
has_toml_table(&dir.join(file), table)
|
||||
};
|
||||
@@ -89,12 +88,11 @@ fn has_toml_table(file: &Path, table: &str) -> bool {
|
||||
table.split('.').try_fold(&value, |v, key| v.get(key)).is_some_and(toml::Value::is_table)
|
||||
}
|
||||
|
||||
/// `file` parses as JSON and has the dotted `key` with a value other than `null`:
|
||||
/// an object (`eslintConfig`) or a dependency's version (`dependencies.tailwindcss`).
|
||||
fn has_json_key(file: &Path, key: &str) -> bool {
|
||||
/// `file` parses as JSON and has the dotted object `key` (`eslintConfig`).
|
||||
fn has_json_object(file: &Path, key: &str) -> bool {
|
||||
let Ok(text) = std::fs::read_to_string(file) else { return false };
|
||||
let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) else { return false };
|
||||
key.split('.').try_fold(&value, |v, key| v.get(key)).is_some_and(|v| !v.is_null())
|
||||
key.split('.').try_fold(&value, |v, key| v.get(key)).is_some_and(serde_json::Value::is_object)
|
||||
}
|
||||
|
||||
/// `path` is (or, after its creation or removal, was) a root marker of the
|
||||
@@ -179,20 +177,6 @@ mod tests {
|
||||
assert!(!is_marker_path(&root.join("svc/setup.cfg"), "pyproject.toml#tool.ruff"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn json_markers_need_their_key() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
let marker = "package.json#devDependencies.tailwindcss";
|
||||
std::fs::write(dir.join("package.json"), r#"{"devDependencies": {"vite": "^7.0.0"}}"#).unwrap();
|
||||
assert!(!has_marker(dir, marker));
|
||||
std::fs::write(dir.join("package.json"), r#"{"devDependencies": {"tailwindcss": "^4.1.0"}}"#).unwrap();
|
||||
assert!(has_marker(dir, marker) && !has_marker(dir, "package.json#dependencies.tailwindcss"));
|
||||
std::fs::write(dir.join("package.json"), r#"{"eslintConfig": null}"#).unwrap();
|
||||
assert!(!has_marker(dir, "package.json#eslintConfig"));
|
||||
assert!(is_marker_path(&dir.join("package.json"), marker));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn patterns_match_file_names() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -715,20 +715,9 @@ mod tests {
|
||||
// it); before the HTML server (hover, rename and symbols take the first).
|
||||
assert_eq!(
|
||||
names("typescript"),
|
||||
[
|
||||
"vtsls",
|
||||
"typescript-language-server",
|
||||
"angular-language-server",
|
||||
"oxlint",
|
||||
"eslint",
|
||||
"biome",
|
||||
"tailwindcss-language-server"
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
names("html"),
|
||||
["angular-language-server", "vscode-html-language-server", "tailwindcss-language-server"]
|
||||
["vtsls", "typescript-language-server", "angular-language-server", "oxlint", "eslint"]
|
||||
);
|
||||
assert_eq!(names("html"), ["angular-language-server", "vscode-html-language-server"]);
|
||||
for lang in ["typescript", "html"] {
|
||||
let cfg = reg.get(&LanguageId::new(lang)).unwrap();
|
||||
let angular = cfg.language_servers.iter().find(|s| s.name == "angular-language-server").unwrap();
|
||||
@@ -755,34 +744,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn biome_lints_files_below_its_config_or_installation() {
|
||||
let reg = reg();
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
for dir in ["apps/web/src", "apps/admin/node_modules/@biomejs/biome", "apps/api"] {
|
||||
std::fs::create_dir_all(root.join(dir)).unwrap();
|
||||
}
|
||||
std::fs::write(root.join("apps/web/biome.jsonc"), "{}").unwrap();
|
||||
for lang in
|
||||
["javascript", "javascriptreact", "typescript", "typescriptreact", "json", "jsonc", "css", "graphql"]
|
||||
{
|
||||
let cfg = reg.get(&LanguageId::new(lang)).unwrap();
|
||||
let biome = cfg.language_servers.iter().find(|s| s.name == "biome").unwrap();
|
||||
assert_eq!(
|
||||
(biome.command.as_str(), biome.args.as_slice()),
|
||||
("biome", ["lsp-proxy".to_string()].as_slice())
|
||||
);
|
||||
assert!(biome.require_root_marker && !biome.fallback, "{lang}");
|
||||
// Reformat Code runs `biome format`: the server's formatting would race the language's own.
|
||||
assert_eq!(biome.features, ["code-action", "diagnostics"], "{lang}");
|
||||
let served = |file: &str| crate::marked_root(Some(root), &root.join(file), &biome.root_markers);
|
||||
assert_eq!(served("apps/web/src/main.ts"), Some(root.join("apps/web")), "{lang}");
|
||||
assert_eq!(served("apps/admin/main.ts"), Some(root.join("apps/admin")), "{lang}");
|
||||
assert_eq!(served("apps/api/main.ts"), None, "{lang}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn eslint_serves_js_files_only_below_its_config() {
|
||||
let reg = reg();
|
||||
@@ -810,60 +771,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tailwind_serves_web_files_only_in_tailwind_projects() {
|
||||
let reg = reg();
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
for dir in ["v3/src", "v4/src", "plain/src"] {
|
||||
std::fs::create_dir_all(root.join(dir)).unwrap();
|
||||
}
|
||||
std::fs::write(root.join("v3/tailwind.config.js"), "module.exports = {};").unwrap();
|
||||
std::fs::write(root.join("v4/package.json"), r#"{"devDependencies": {"tailwindcss": "^4.1.0"}}"#).unwrap();
|
||||
std::fs::write(root.join("plain/package.json"), r#"{"devDependencies": {"vite": "^7.0.0"}}"#).unwrap();
|
||||
for lang in
|
||||
["html", "css", "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "svelte", "astro"]
|
||||
{
|
||||
let cfg = reg.get(&LanguageId::new(lang)).unwrap();
|
||||
// Last: the language's own servers answer hover first.
|
||||
let tailwind = cfg.language_servers.last().unwrap();
|
||||
assert_eq!(tailwind.name, "tailwindcss-language-server", "{lang}");
|
||||
assert_eq!(tailwind.args, ["--stdio"], "{lang}");
|
||||
assert!(tailwind.require_root_marker && !tailwind.fallback, "{lang}");
|
||||
let served = |file: &str| crate::marked_root(Some(root), &root.join(file), &tailwind.root_markers);
|
||||
assert_eq!(served("v3/src/app.css"), Some(root.join("v3")), "{lang}");
|
||||
assert_eq!(served("v4/src/app.css"), Some(root.join("v4")), "{lang}");
|
||||
assert_eq!(served("plain/src/app.css"), None, "{lang}: package.json without tailwindcss");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stylelint_serves_style_sheets_only_below_its_config() {
|
||||
let reg = reg();
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
for dir in ["apps/web/src", "apps/admin/src", "apps/api"] {
|
||||
std::fs::create_dir_all(root.join(dir)).unwrap();
|
||||
}
|
||||
std::fs::write(root.join("apps/web/stylelint.config.mjs"), "export default {};").unwrap();
|
||||
std::fs::write(root.join("apps/admin/package.json"), r#"{"stylelint": {"extends": []}}"#).unwrap();
|
||||
std::fs::write(root.join("apps/api/package.json"), r#"{"name": "api"}"#).unwrap();
|
||||
for lang in ["css", "scss", "less"] {
|
||||
let cfg = reg.get(&LanguageId::new(lang)).unwrap();
|
||||
let stylelint = cfg.language_servers.iter().find(|s| s.name == "stylelint").unwrap();
|
||||
assert_eq!(stylelint.command, "stylelint-language-server", "{lang}");
|
||||
assert!(stylelint.require_root_marker && !stylelint.fallback, "{lang}");
|
||||
assert_eq!(stylelint.features, ["code-action", "diagnostics"], "{lang}");
|
||||
// The server lints only the languages in `validate` (CSS alone by default).
|
||||
let validate = stylelint.settings.as_ref().unwrap().get("validate").unwrap();
|
||||
assert_eq!(validate, &serde_json::json!(["css", "scss", "less"]), "{lang}");
|
||||
let served = |file: &str| crate::marked_root(Some(root), &root.join(file), &stylelint.root_markers);
|
||||
assert_eq!(served("apps/web/src/app.css"), Some(root.join("apps/web")), "{lang}");
|
||||
assert_eq!(served("apps/admin/src/app.css"), Some(root.join("apps/admin")), "{lang}");
|
||||
assert_eq!(served("apps/api/app.css"), None, "{lang}: package.json without stylelint");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn laravel_lsp_serves_php_files_only_below_artisan() {
|
||||
let reg = reg();
|
||||
@@ -1242,7 +1149,6 @@ mod tests {
|
||||
(".env", "dotenv"),
|
||||
(".env.local", "dotenv"),
|
||||
(".gitignore", "ignore"),
|
||||
(".worktreeinclude", "ignore"),
|
||||
(".gitattributes", "gitattributes"),
|
||||
("server.log", "log"),
|
||||
("player.gd", "gdscript"),
|
||||
|
||||
@@ -360,9 +360,6 @@ impl ClientHandler {
|
||||
else {
|
||||
return;
|
||||
};
|
||||
if self.server.redirect_transient_diagnostics(&path, self.generation, params.version, &mut params.diagnostics) {
|
||||
return;
|
||||
}
|
||||
if self.server.name == crate::compose::SERVER {
|
||||
// Maven resource-filtering placeholders (`@profileActive@`) parse as invalid
|
||||
// YAML but are replaced before the file is ever read: their parser error is noise.
|
||||
@@ -380,8 +377,9 @@ impl ClientHandler {
|
||||
return;
|
||||
}
|
||||
// Files opened only for a request (references search) are not the user's problems.
|
||||
if self.server.external_diagnostics.load(std::sync::atomic::Ordering::Acquire)
|
||||
&& !mgr.docs.lock().values().any(|d| d.path == path)
|
||||
if (self.server.external_diagnostics.load(std::sync::atomic::Ordering::Acquire)
|
||||
&& !mgr.docs.lock().values().any(|d| d.path == path))
|
||||
|| self.server.suppresses_diagnostics(&path)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -9,11 +9,10 @@
|
||||
|
||||
use crate::convert;
|
||||
use crate::server::Server;
|
||||
use crate::text::DocText;
|
||||
use crate::{LspManager, Outcome, Target, scope};
|
||||
use crate::{LspManager, Target};
|
||||
use futures::StreamExt;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{CancellationToken, Diagnostic, DocId, IdeError, IdeResult, LanguageId};
|
||||
use ide_core::{CancellationToken, Diagnostic, DocId, IdeError, IdeResult};
|
||||
use lsp_types as lsp;
|
||||
use serde_json::{Value, json};
|
||||
use std::path::{Path, PathBuf};
|
||||
@@ -226,48 +225,6 @@ impl LspManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks a snapshot without publishing to Problems or changing the live document.
|
||||
pub async fn snapshot_diagnostics(
|
||||
&self,
|
||||
path: &Path,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<Diagnostic>> {
|
||||
let targets = tokio::select! {
|
||||
r = self.snapshot_targets(path, language, "snapshot diagnostics", |c| c.restriction.diagnostics()) => r?,
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
};
|
||||
let snapshot = scope::snapshot_path(path, "diagnostics")?;
|
||||
let doc = Arc::new(DocText::new(text));
|
||||
let mut result = Outcome::<Vec<_>>::new();
|
||||
let opts = InspectOptions { timeout: Duration::from_secs(2), ..Default::default() };
|
||||
let reports = targets.iter().map(|t| async {
|
||||
let mut opened = scope::TransientFiles::empty(self, t);
|
||||
let raw = if t.caps().has("diagnosticProvider") {
|
||||
opened.hold(&snapshot, language, text);
|
||||
self.pull_diagnostics(t, &opened.files[0].1, cancel, opts.timeout).await
|
||||
} else {
|
||||
let receiver = opened.hold_for_diagnostics(&snapshot, language, text);
|
||||
wait_for_snapshot_publish(receiver, opts, cancel).await
|
||||
};
|
||||
raw.map(|items| {
|
||||
let conv = convert::Conv::new(t.enc(), |_| Some(doc.clone()));
|
||||
items.into_iter().map(|d| convert::diagnostic(&conv, path, d, &t.server.name)).collect::<Vec<_>>()
|
||||
})
|
||||
});
|
||||
for report in futures::future::join_all(reports).await {
|
||||
match report {
|
||||
Ok(items) => result.value.get_or_insert_with(Vec::new).extend(items),
|
||||
Err(error) => result.fail(error),
|
||||
}
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
result.finish(Vec::new())
|
||||
}
|
||||
|
||||
/// Fresh diagnostics of the open document `doc`, whose text the caller just synced
|
||||
/// (`changed`: at that instant, so diagnostics published before it are stale). Tells the
|
||||
/// servers the document was saved, since checks that run on save (rust-analyzer's
|
||||
@@ -377,22 +334,6 @@ impl LspManager {
|
||||
}
|
||||
}
|
||||
|
||||
async fn wait_for_snapshot_publish(
|
||||
mut receiver: tokio::sync::watch::Receiver<Vec<lsp::Diagnostic>>,
|
||||
opts: InspectOptions,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<lsp::Diagnostic>> {
|
||||
let listen = async {
|
||||
if receiver.changed().await.is_ok() {
|
||||
while matches!(tokio::time::timeout(opts.settle, receiver.changed()).await, Ok(Ok(()))) {}
|
||||
}
|
||||
};
|
||||
tokio::select! {
|
||||
_ = tokio::time::timeout(opts.timeout, listen) => Ok(receiver.borrow().clone()),
|
||||
() = cancel.cancelled() => Err(IdeError::cancelled()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Waits until `server` published diagnostics for `path` (after `since`, if
|
||||
/// given) and no further publish arrived for `opts.settle`, or `opts.timeout`
|
||||
/// passed; returns the server's current diagnostics for the file.
|
||||
|
||||
@@ -21,7 +21,6 @@ const GENERATED_SOURCES: &str = "openidea.java.generatedSources";
|
||||
|
||||
pub(crate) mod configuration;
|
||||
pub(crate) mod exception_breakpoints;
|
||||
mod exception_type;
|
||||
mod extract_interface;
|
||||
mod formatter;
|
||||
mod generated;
|
||||
|
||||
@@ -1,38 +0,0 @@
|
||||
//! The exception class at a caret, for the exception breakpoint intention, through the
|
||||
//! app-owned JDT extension (`java/java-usages`).
|
||||
use super::COMMAND_TIMEOUT;
|
||||
use crate::LspManager;
|
||||
use crate::types::ExceptionClassRef;
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
|
||||
use serde_json::json;
|
||||
|
||||
const EXCEPTION_TYPE: &str = "openidea.java.exceptionType";
|
||||
|
||||
impl LspManager {
|
||||
/// The Throwable class the caret at `pos` names; `None` when there is none, or when no
|
||||
/// server of the document has the command.
|
||||
pub async fn exception_class_at(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<Option<ExceptionClassRef>> {
|
||||
let snap = self.snapshot(doc)?;
|
||||
let mut targets = self.ready_targets(&snap.servers, |c| c.commands().iter().any(|c| c == EXCEPTION_TYPE)).await;
|
||||
if targets.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let t = targets.swap_remove(0);
|
||||
let at = snap.position(&t, pos);
|
||||
let params = json!({
|
||||
"command": EXCEPTION_TYPE,
|
||||
"arguments": [snap.uri, at.line, at.character],
|
||||
});
|
||||
let found: Option<ExceptionClassRef> =
|
||||
self.call(&t, "workspace/executeCommand", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
Ok(found)
|
||||
}
|
||||
}
|
||||
@@ -35,7 +35,6 @@ mod plugin_requests;
|
||||
mod pull;
|
||||
mod scope;
|
||||
mod server;
|
||||
mod source_actions;
|
||||
mod tcp;
|
||||
mod text;
|
||||
mod ts_file_moves;
|
||||
@@ -3190,67 +3189,6 @@ impl LspManager {
|
||||
Ok(!self.ready_targets(&snap.servers, |c| c.has("documentFormattingProvider")).await.is_empty())
|
||||
}
|
||||
|
||||
async fn snapshot_targets(
|
||||
&self,
|
||||
path: &Path,
|
||||
language: &LanguageId,
|
||||
feature: &str,
|
||||
supports: impl Fn(&ServerCaps) -> bool,
|
||||
) -> IdeResult<Vec<Target>> {
|
||||
let supports = |caps: &ServerCaps| caps.open_close && supports(caps);
|
||||
let servers = self.servers_for(language, path);
|
||||
for server in &servers {
|
||||
self.ensure_started(server);
|
||||
}
|
||||
let mut targets = self.ready_targets(&servers, supports).await;
|
||||
if targets.is_empty() {
|
||||
// A primary server can become unavailable while it initializes.
|
||||
let candidates = self.servers_for(language, path);
|
||||
if candidates.iter().any(|server| !servers.iter().any(|old| old.id == server.id)) {
|
||||
for server in &candidates {
|
||||
self.ensure_started(server);
|
||||
}
|
||||
targets = self.ready_targets(&candidates, supports).await;
|
||||
}
|
||||
}
|
||||
if targets.is_empty() {
|
||||
return Err(unsupported(&servers, feature));
|
||||
}
|
||||
Ok(targets)
|
||||
}
|
||||
|
||||
async fn text_format_targets(&self, path: &Path, language: &LanguageId) -> IdeResult<Vec<Target>> {
|
||||
self.snapshot_targets(path, language, "snapshot formatting", |c| c.has("documentFormattingProvider")).await
|
||||
}
|
||||
|
||||
pub async fn can_format_text(&self, path: &Path, language: &LanguageId) -> bool {
|
||||
self.text_format_targets(path, language).await.is_ok()
|
||||
}
|
||||
|
||||
/// Use a transient URI so requests in the editor still see the working buffer.
|
||||
pub async fn format_text(
|
||||
&self,
|
||||
path: &Path,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
options: FormatOptions,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let path_to_snapshot = scope::snapshot_path(path, "format")?;
|
||||
let targets = self.text_format_targets(path, language).await?;
|
||||
let target = &targets[0];
|
||||
let mut opened = scope::TransientFiles::empty(self, target);
|
||||
opened.hold(&path_to_snapshot, language, text);
|
||||
let params = json!({
|
||||
"textDocument": { "uri": opened.files[0].1 },
|
||||
"options": { "tabSize": options.tab_size, "insertSpaces": options.insert_spaces },
|
||||
});
|
||||
let edits: Option<Vec<lsp::TextEdit>> =
|
||||
self.call(target, "textDocument/formatting", params, None, DEFAULT_TIMEOUT).await?;
|
||||
let text = Arc::new(DocText::new(text));
|
||||
let converter = Conv::new(target.enc(), |_| Some(text.clone()));
|
||||
Ok(converter.text_edits(&path_to_snapshot, edits.unwrap_or_default()))
|
||||
}
|
||||
|
||||
pub async fn format(&self, doc: DocId, range: Option<Range>, options: FormatOptions) -> IdeResult<Vec<TextEdit>> {
|
||||
let (method, cap, feature) = match range {
|
||||
None => ("textDocument/formatting", "documentFormattingProvider", "formatting"),
|
||||
|
||||
@@ -464,22 +464,6 @@ impl LspManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// A separate URI in the source directory, with the language's existing extension.
|
||||
pub(crate) fn snapshot_path(path: &Path, purpose: &str) -> IdeResult<PathBuf> {
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
let name = path.file_name().ok_or_else(|| IdeError::invalid("a text snapshot requires a file path"))?;
|
||||
static NEXT: AtomicU64 = AtomicU64::new(0);
|
||||
loop {
|
||||
let serial = NEXT.fetch_add(1, Ordering::Relaxed);
|
||||
let mut unique = std::ffi::OsString::from(format!(".openidea-{purpose}-{}-{serial}-", std::process::id()));
|
||||
unique.push(name);
|
||||
let candidate = path.with_file_name(unique);
|
||||
if !candidate.exists() {
|
||||
return Ok(candidate);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Files opened by [`LspManager::open_transient`]; closed on drop.
|
||||
pub(crate) struct TransientFiles<'a> {
|
||||
mgr: &'a LspManager,
|
||||
@@ -493,30 +477,9 @@ pub(crate) struct TransientFiles<'a> {
|
||||
impl TransientFiles<'_> {
|
||||
/// Opens one file outside a references search (a file operation needs a loaded project).
|
||||
pub(crate) fn hold(&mut self, path: &Path, language: &LanguageId, text: &str) {
|
||||
self.hold_file(path, language, text, false);
|
||||
}
|
||||
|
||||
pub(crate) fn hold_for_diagnostics(
|
||||
&mut self,
|
||||
path: &Path,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
) -> tokio::sync::watch::Receiver<Vec<lsp::Diagnostic>> {
|
||||
self.hold_file(path, language, text, true).expect("diagnostics subscription")
|
||||
}
|
||||
|
||||
fn hold_file(
|
||||
&mut self,
|
||||
path: &Path,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
diagnostics: bool,
|
||||
) -> Option<tokio::sync::watch::Receiver<Vec<lsp::Diagnostic>>> {
|
||||
let _docs = self.mgr.docs.lock();
|
||||
let uri = crate::uri::path_to_uri(path);
|
||||
let open = self.server.hold_transient(path, self.run.generation);
|
||||
let receiver = diagnostics.then(|| self.server.watch_transient_diagnostics(path));
|
||||
if open {
|
||||
if self.server.hold_transient(path, self.run.generation) {
|
||||
let params =
|
||||
json!({ "textDocument": { "uri": uri, "languageId": language.as_str(), "version": 0, "text": text } });
|
||||
if let Err(e) = self.run.peer.notify("textDocument/didOpen", params) {
|
||||
@@ -524,7 +487,6 @@ impl TransientFiles<'_> {
|
||||
}
|
||||
}
|
||||
self.files.push((path.to_owned(), uri));
|
||||
receiver
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -66,7 +66,6 @@ struct Transient {
|
||||
/// The user opened the file meanwhile: its `didOpen` replaced ours.
|
||||
taken: bool,
|
||||
closed_at: Option<Instant>,
|
||||
diagnostics: Option<watch::Sender<Vec<lsp::Diagnostic>>>,
|
||||
}
|
||||
|
||||
pub struct Progress {
|
||||
@@ -727,15 +726,10 @@ impl Server {
|
||||
pub fn hold_transient(&self, path: &Path, generation: u64) -> bool {
|
||||
let mut map = self.transient.lock();
|
||||
map.retain(|_, t| t.holders > 0 || t.closed_at.is_some_and(|c| c.elapsed() < TRANSIENT_GRACE));
|
||||
let t = map.entry(path.to_owned()).or_insert(Transient {
|
||||
holders: 0,
|
||||
generation,
|
||||
taken: false,
|
||||
closed_at: None,
|
||||
diagnostics: None,
|
||||
});
|
||||
let t =
|
||||
map.entry(path.to_owned()).or_insert(Transient { holders: 0, generation, taken: false, closed_at: None });
|
||||
if t.holders == 0 || t.generation != generation {
|
||||
*t = Transient { holders: 1, generation, taken: false, closed_at: None, diagnostics: None };
|
||||
*t = Transient { holders: 1, generation, taken: false, closed_at: None };
|
||||
return true;
|
||||
}
|
||||
t.holders += 1;
|
||||
@@ -754,7 +748,6 @@ impl Server {
|
||||
if t.holders > 0 {
|
||||
return false;
|
||||
}
|
||||
t.diagnostics = None;
|
||||
let close = !t.taken && t.generation == generation;
|
||||
if close {
|
||||
t.closed_at = Some(Instant::now());
|
||||
@@ -772,7 +765,6 @@ impl Server {
|
||||
let open = t.holders > 0 && !t.taken && t.generation == generation;
|
||||
if t.holders > 0 {
|
||||
t.taken = true;
|
||||
t.diagnostics = None;
|
||||
} else {
|
||||
map.remove(path);
|
||||
}
|
||||
@@ -788,34 +780,6 @@ impl Server {
|
||||
.is_some_and(|t| !t.taken && (t.holders > 0 || t.closed_at.is_some_and(|c| c.elapsed() < TRANSIENT_GRACE)))
|
||||
}
|
||||
|
||||
pub(crate) fn watch_transient_diagnostics(&self, path: &Path) -> watch::Receiver<Vec<lsp::Diagnostic>> {
|
||||
let (sender, receiver) = watch::channel(Vec::new());
|
||||
if let Some(transient) = self.transient.lock().get_mut(path) {
|
||||
transient.diagnostics = Some(sender);
|
||||
}
|
||||
receiver
|
||||
}
|
||||
|
||||
/// Delivers a snapshot report privately. Other transient files discard their reports.
|
||||
pub(crate) fn redirect_transient_diagnostics(
|
||||
&self,
|
||||
path: &Path,
|
||||
generation: u64,
|
||||
version: Option<i32>,
|
||||
items: &mut Vec<lsp::Diagnostic>,
|
||||
) -> bool {
|
||||
let transients = self.transient.lock();
|
||||
let Some(t) = transients.get(path).filter(|t| !t.taken && t.generation == generation) else {
|
||||
return false;
|
||||
};
|
||||
if let Some(sender) = &t.diagnostics
|
||||
&& version.is_none_or(|v| v == 0)
|
||||
{
|
||||
sender.send_replace(std::mem::take(items));
|
||||
}
|
||||
t.holders > 0 || t.closed_at.is_some_and(|c| c.elapsed() < TRANSIENT_GRACE)
|
||||
}
|
||||
|
||||
// ---- bookkeeping ----
|
||||
|
||||
pub fn push_stderr(&self, generation: u64, line: String) {
|
||||
|
||||
@@ -1,119 +0,0 @@
|
||||
use crate::convert::Conv;
|
||||
use crate::text::DocText;
|
||||
use crate::{DEFAULT_TIMEOUT, LspManager, Outcome, Target, scope};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, LanguageId, Pos, TextEdit};
|
||||
use lsp_types as lsp;
|
||||
use serde_json::json;
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
|
||||
impl LspManager {
|
||||
/// Reads a source action for an isolated text snapshot. The caller owns the text and applies the edits.
|
||||
pub async fn source_action_text(
|
||||
&self,
|
||||
path: &Path,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
kind: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
if !kind.starts_with("source.") {
|
||||
return Err(IdeError::invalid("a text snapshot requires a source action"));
|
||||
}
|
||||
let targets =
|
||||
self.snapshot_targets(path, language, "snapshot source actions", |c| c.has("codeActionProvider")).await?;
|
||||
let path = scope::snapshot_path(path, "source")?;
|
||||
let mut out = Outcome::new();
|
||||
for target in &targets {
|
||||
match self.snapshot_action(target, &path, language, text, kind, cancel).await {
|
||||
Ok(edits) if !edits.is_empty() => return Ok(edits),
|
||||
Ok(edits) => out.value = Some(edits),
|
||||
Err(error) if cancel.is_cancelled() => return Err(error),
|
||||
Err(error) => out.fail(error),
|
||||
}
|
||||
}
|
||||
out.finish(Vec::new())
|
||||
}
|
||||
|
||||
async fn snapshot_action(
|
||||
&self,
|
||||
target: &Target,
|
||||
path: &Path,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
kind: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let mut opened = scope::TransientFiles::empty(self, target);
|
||||
opened.hold(path, language, text);
|
||||
let uri = &opened.files[0].1;
|
||||
let doc = Arc::new(DocText::new(text));
|
||||
let last = doc.line_count() - 1;
|
||||
let end = doc.ide_to_lsp(target.enc(), Pos::new(last as u32, doc.line(last).encode_utf16().count() as u32));
|
||||
let params = json!({
|
||||
"textDocument": { "uri": uri },
|
||||
"range": lsp::Range::new(lsp::Position::new(0, 0), end),
|
||||
"context": { "diagnostics": [], "only": [kind], "triggerKind": 1 },
|
||||
});
|
||||
let actions: Option<Vec<lsp::CodeActionOrCommand>> =
|
||||
self.call(target, "textDocument/codeAction", params, Some(cancel), DEFAULT_TIMEOUT).await?;
|
||||
let (restriction, resolve) = {
|
||||
let caps = target.caps();
|
||||
(caps.restriction.clone(), caps.has_sub("codeActionProvider", "resolveProvider"))
|
||||
};
|
||||
let mut actions: Vec<_> = actions
|
||||
.unwrap_or_default()
|
||||
.into_iter()
|
||||
.filter_map(|action| match action {
|
||||
lsp::CodeActionOrCommand::CodeAction(action)
|
||||
if action.disabled.is_none()
|
||||
&& action.command.is_none()
|
||||
&& action.kind.as_ref().is_some_and(|k| {
|
||||
let value = k.as_str();
|
||||
restriction.keeps_action(Some(value))
|
||||
&& (value == kind || value.strip_prefix(kind).is_some_and(|rest| rest.starts_with('.')))
|
||||
}) =>
|
||||
{
|
||||
Some(action)
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
actions.sort_by_key(|action| action.is_preferred != Some(true));
|
||||
for mut action in actions {
|
||||
if action.edit.is_none() && action.data.is_some() && resolve {
|
||||
action = self.call(target, "codeAction/resolve", action, Some(cancel), DEFAULT_TIMEOUT).await?;
|
||||
}
|
||||
if action.disabled.is_none()
|
||||
&& action.command.is_none()
|
||||
&& let Some(edits) = action.edit.and_then(|edit| snapshot_edits(edit, uri))
|
||||
&& !edits.is_empty()
|
||||
{
|
||||
return Ok(Conv::new(target.enc(), |_| Some(doc.clone())).text_edits(path, edits));
|
||||
}
|
||||
}
|
||||
Ok(Vec::new())
|
||||
}
|
||||
}
|
||||
|
||||
fn snapshot_edits(edit: lsp::WorkspaceEdit, uri: &lsp::Uri) -> Option<Vec<lsp::TextEdit>> {
|
||||
match (edit.changes, edit.document_changes) {
|
||||
(Some(mut changes), None) if changes.len() == 1 => changes.remove(uri),
|
||||
(None, Some(lsp::DocumentChanges::Edits(mut edits))) if edits.len() == 1 => {
|
||||
let edit = edits.pop()?;
|
||||
if edit.text_document.uri != *uri || edit.text_document.version.is_some_and(|version| version != 0) {
|
||||
return None;
|
||||
}
|
||||
Some(
|
||||
edit.edits
|
||||
.into_iter()
|
||||
.map(|edit| match edit {
|
||||
lsp::OneOf::Left(edit) => edit,
|
||||
lsp::OneOf::Right(edit) => edit.text_edit,
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
@@ -467,16 +467,6 @@ pub struct HierarchyMember {
|
||||
pub abstractable: bool,
|
||||
}
|
||||
|
||||
/// The exception class a caret names: a reference to it, its declaration, or a throw of it.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ExceptionClassRef {
|
||||
/// The binary name (`app.Outer$Failure`), as exception breakpoints take it.
|
||||
pub qualified_name: String,
|
||||
/// The simple name (`Failure`).
|
||||
pub display_name: String,
|
||||
}
|
||||
|
||||
/// The class at a position and what can move: pull-up destinations, or the subclasses
|
||||
/// members are pushed into.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
|
||||
@@ -3770,36 +3770,6 @@ async fn exception_breakpoints_send_the_whole_list_and_decode_states() {
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn exception_class_at_asks_the_extension_and_is_none_without_it() {
|
||||
let mut caps = incremental_caps();
|
||||
caps["executeCommandProvider"] = json!({"commands": ["openidea.java.exceptionType"]});
|
||||
let h = harness_for("java", "java", &[("jdtls", caps)], &[]);
|
||||
let (doc, path) = h.open("Main.java", "class Main {\n void f() { throw new Failure(); }\n}");
|
||||
h.wait_status("jdtls", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("jdtls");
|
||||
s.respond("workspace/executeCommand", json!({"qualifiedName": "app.Main$Failure", "displayName": "Failure"}));
|
||||
let found = h.mgr.exception_class_at(doc, Pos::new(1, 23), Default::default()).await.unwrap();
|
||||
assert_eq!(
|
||||
found,
|
||||
Some(ide_lsp::types::ExceptionClassRef {
|
||||
qualified_name: "app.Main$Failure".into(),
|
||||
display_name: "Failure".into()
|
||||
})
|
||||
);
|
||||
let asked = s.requested("workspace/executeCommand");
|
||||
assert_eq!(asked[0]["command"], "openidea.java.exceptionType");
|
||||
assert_eq!(asked[0]["arguments"], json!([uri_of(&path), 1, 23]));
|
||||
s.respond("workspace/executeCommand", json!(null));
|
||||
assert_eq!(h.mgr.exception_class_at(doc, Pos::new(0, 1), Default::default()).await.unwrap(), None);
|
||||
|
||||
let plain = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
|
||||
let (doc, _) = plain.open("Main.java", "class Main {}");
|
||||
plain.wait_status("jdtls", ServerStatus::Ready).await;
|
||||
assert_eq!(plain.mgr.exception_class_at(doc, Pos::new(0, 7), Default::default()).await.unwrap(), None);
|
||||
assert!(plain.launcher.state("jdtls").requested("workspace/executeCommand").is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn debug_server_port_maps_to_module() {
|
||||
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
|
||||
@@ -4205,156 +4175,6 @@ async fn java_dependency_implementations_point_at_the_method() {
|
||||
assert!(commands.iter().any(|r| r["command"] == "openidea.java.implementationLocations"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn formatting_a_snapshot_never_changes_an_open_document() {
|
||||
let caps = json!({
|
||||
"positionEncoding": "utf-8",
|
||||
"textDocumentSync": { "openClose": true, "change": 2 },
|
||||
"documentFormattingProvider": true,
|
||||
});
|
||||
let h = harness(&[("mock", caps)]);
|
||||
let (_, path) = h.open("a.mk", "different working text\n");
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("mock");
|
||||
s.respond(
|
||||
"textDocument/formatting",
|
||||
json!([{ "range": { "start": { "line": 0, "character": 4 }, "end": { "line": 0, "character": 5 } }, "newText": "X" }]),
|
||||
);
|
||||
let options = FormatOptions { tab_size: 2, insert_spaces: true, on_save: false, tool: None };
|
||||
let edits = h.mgr.format_text(&path, &LanguageId("mock".into()), "🙂b\n", options).await.unwrap();
|
||||
assert_eq!(edits, vec![ide_core::TextEdit { range: rng(0, 2, 0, 3), new_text: "X".into() }]);
|
||||
|
||||
let uri = uri_of(&path);
|
||||
let requests = s.requested("textDocument/formatting");
|
||||
let shadow = requests[0]["textDocument"]["uri"].as_str().unwrap();
|
||||
assert_ne!(shadow, uri);
|
||||
let opens = s.notified("textDocument/didOpen");
|
||||
let snapshot = opens.iter().find(|n| n["textDocument"]["uri"] == shadow).unwrap();
|
||||
assert_eq!(snapshot["textDocument"]["text"], "🙂b\n");
|
||||
assert!(s.notified("textDocument/didChange").is_empty());
|
||||
eventually(|| uris(&s.notified("textDocument/didClose")) == vec![shadow.to_owned()]).await;
|
||||
assert!(s.docs.lock().contains_key(&uri));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn snapshot_diagnostics_collect_pull_and_push_without_publishing_problems() {
|
||||
let mut pull_caps = incremental_caps();
|
||||
pull_caps["diagnosticProvider"] = json!({ "interFileDependencies": false, "workspaceDiagnostics": false });
|
||||
let mut push_caps = incremental_caps();
|
||||
push_caps["positionEncoding"] = json!("utf-8");
|
||||
let h = harness(&[("mock", pull_caps), ("push", push_caps)]);
|
||||
let pull = h.launcher.state("mock");
|
||||
*pull.responder.lock() = Some(pull_responder());
|
||||
let (_, path) = h.open("a.mk", "clean editor\n");
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
h.wait_status("push", ServerStatus::Ready).await;
|
||||
let push = h.launcher.state("push");
|
||||
let live = uri_of(&path);
|
||||
let shadow = || {
|
||||
push.notified("textDocument/didOpen")
|
||||
.into_iter()
|
||||
.find(|n| n["textDocument"]["text"] == "🙂bad\n")
|
||||
.and_then(|n| n["textDocument"]["uri"].as_str().map(str::to_owned))
|
||||
};
|
||||
let send = async {
|
||||
eventually(|| shadow().is_some()).await;
|
||||
let uri = shadow().unwrap();
|
||||
for (version, message) in [(1, "wrong version"), (0, "snapshot only")] {
|
||||
push.peer()
|
||||
.notify(
|
||||
"textDocument/publishDiagnostics",
|
||||
json!({
|
||||
"uri": uri, "version": version, "diagnostics": [{
|
||||
"range": {"start": {"line":0,"character":4}, "end": {"line":0,"character":7}},
|
||||
"severity": 2, "message": message
|
||||
}]
|
||||
}),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
uri
|
||||
};
|
||||
let language = LanguageId("mock".into());
|
||||
let cancel = Default::default();
|
||||
let (result, shadow) = tokio::join!(h.mgr.snapshot_diagnostics(&path, &language, "🙂bad\n", &cancel), send);
|
||||
assert_ne!(shadow, live);
|
||||
let mut items = result.unwrap();
|
||||
items.sort_by(|a, b| a.message.cmp(&b.message));
|
||||
assert_eq!(items.iter().map(|d| d.message.as_str()).collect::<Vec<_>>(), ["bad", "snapshot only"]);
|
||||
assert_eq!(items[1].range, rng(0, 2, 0, 5));
|
||||
eventually(|| uris(&push.notified("textDocument/didClose")) == vec![shadow.clone()]).await;
|
||||
assert!(uris(&push.notified("textDocument/didChange")).is_empty());
|
||||
assert!(push.docs.lock().contains_key(&live));
|
||||
assert!(!h.events.lock().iter().any(|event| matches!(
|
||||
event,
|
||||
IdeEvent::Diagnostics { items, .. } if !items.is_empty()
|
||||
)));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn source_actions_use_snapshot_text_and_accept_only_its_passive_edits() {
|
||||
let caps = json!({
|
||||
"positionEncoding": "utf-8",
|
||||
"textDocumentSync": { "openClose": true, "change": 2 },
|
||||
"codeActionProvider": { "resolveProvider": true },
|
||||
});
|
||||
let h = harness(&[("mock", caps)]);
|
||||
let (_, path) = h.open("a.mk", "the live editor\n");
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("mock");
|
||||
let uri = uri_of(&path);
|
||||
let original = uri.clone();
|
||||
*s.responder.lock() = Some(Arc::new(move |_, method, params| {
|
||||
let edit = json!({ "range": {
|
||||
"start": { "line": 0, "character": 4 }, "end": { "line": 0, "character": 5 }
|
||||
}, "newText": "X" });
|
||||
match method {
|
||||
"textDocument/codeAction" => {
|
||||
let shadow = params["textDocument"]["uri"].as_str().unwrap();
|
||||
assert_ne!(shadow, original);
|
||||
assert_eq!(params["range"]["end"], json!({ "line": 0, "character": 5 }));
|
||||
assert_eq!(params["context"]["diagnostics"], json!([]));
|
||||
let kind = params["context"]["only"][0].as_str().unwrap();
|
||||
if kind == "source.fixAll" {
|
||||
return Some(json!([{ "title": "Cleanup", "kind": kind, "edit": { "documentChanges": [{
|
||||
"textDocument": { "uri": shadow, "version": 0 }, "edits": [edit]
|
||||
}] }}]));
|
||||
}
|
||||
assert_eq!(kind, "source.organizeImports");
|
||||
Some(json!([
|
||||
{ "title": "Cross-file edit", "kind": kind, "isPreferred": true,
|
||||
"edit": { "changes": { shadow: [edit.clone()], original.clone(): [edit.clone()] } } },
|
||||
{ "title": "Command", "kind": kind, "isPreferred": true,
|
||||
"command": { "title": "Command", "command": "mock.organize" },
|
||||
"edit": { "changes": { shadow: [edit] } } },
|
||||
{ "title": "Organize", "kind": kind, "data": { "snapshot": shadow } }
|
||||
]))
|
||||
}
|
||||
"codeAction/resolve" => {
|
||||
let shadow = params["data"]["snapshot"].as_str().unwrap();
|
||||
Some(json!({ "title": "Organize", "edit": { "changes": { shadow: [edit] } } }))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}));
|
||||
for kind in ["source.organizeImports", "source.fixAll"] {
|
||||
let edits = h
|
||||
.mgr
|
||||
.source_action_text(&path, &LanguageId("mock".into()), "🙂b", kind, &Default::default())
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(edits, vec![ide_core::TextEdit { range: rng(0, 2, 0, 3), new_text: "X".into() }]);
|
||||
}
|
||||
assert!(s.requested("workspace/executeCommand").is_empty());
|
||||
assert!(s.notified("textDocument/didChange").is_empty());
|
||||
eventually(|| s.notified("textDocument/didClose").len() == 2).await;
|
||||
let snapshots: Vec<_> =
|
||||
s.notified("textDocument/didOpen").into_iter().filter(|notice| notice["textDocument"]["uri"] != uri).collect();
|
||||
assert_eq!(snapshots.len(), 2);
|
||||
assert!(snapshots.iter().all(|notice| notice["textDocument"]["text"] == "🙂b"));
|
||||
assert!(s.docs.lock().contains_key(&uri));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn navigation_rename_format_and_decorations() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
|
||||
@@ -947,73 +947,6 @@ async fn angular_language_server_end_to_end() {
|
||||
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
|
||||
}
|
||||
|
||||
/// The Tailwind CSS server on `fixtures/tailwind-app` (Tailwind 4, `@theme` colours), with
|
||||
/// the built-in definitions: class completion in JSX and `@apply`, hover with the generated
|
||||
/// CSS, and the class conflict warning. Set `OPENIDEA_TEST_NPM_TOOLS` to a dir with
|
||||
/// `npm i @tailwindcss/language-server`; the fixture's own `tailwindcss` isn't needed.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires @tailwindcss/language-server (OPENIDEA_TEST_NPM_TOOLS)"]
|
||||
async fn tailwindcss_language_server_end_to_end() {
|
||||
let tools = std::path::PathBuf::from(std::env::var("OPENIDEA_TEST_NPM_TOOLS").expect("OPENIDEA_TEST_NPM_TOOLS"));
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
let fixture = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../fixtures/tailwind-app");
|
||||
for file in ["package.json", "index.html", "src/app.css", "src/App.tsx"] {
|
||||
std::fs::create_dir_all(root.join(file).parent().unwrap()).unwrap();
|
||||
std::fs::copy(fixture.join(file), root.join(file)).unwrap();
|
||||
}
|
||||
let builtin = LanguageRegistry::load(None).unwrap();
|
||||
let languages = ["typescriptreact", "css"].map(|id| {
|
||||
let mut cfg = builtin.get(&LanguageId::new(id)).unwrap();
|
||||
cfg.language_servers.retain(|s| s.name == "tailwindcss-language-server");
|
||||
let bin = tools.join("node_modules/.bin/tailwindcss-language-server");
|
||||
cfg.language_servers[0].command = bin.to_string_lossy().into_owned();
|
||||
cfg
|
||||
});
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(languages.to_vec()));
|
||||
let (tsx, css) = (DocId::next(), DocId::next());
|
||||
let tsx_path = root.join("src/App.tsx");
|
||||
let css_path = root.join("src/app.css");
|
||||
let tsx_text = std::fs::read_to_string(&tsx_path).unwrap();
|
||||
let css_text = std::fs::read_to_string(&css_path).unwrap();
|
||||
mgr.did_open(tsx, &tsx_path, &LanguageId::new("typescriptreact"), 1, &tsx_text);
|
||||
mgr.did_open(css, &css_path, &LanguageId::new("css"), 1, &css_text);
|
||||
let at = |text: &str, needle: &str, offset: usize| {
|
||||
let (line, l) = text.lines().enumerate().find(|(_, l)| l.contains(needle)).unwrap();
|
||||
Pos::new(line as u32, (l.find(needle).unwrap() + offset) as u32)
|
||||
};
|
||||
|
||||
// The project's own `@theme` colour, in `className` and after `@apply`.
|
||||
let in_class = at(&tsx_text, "className=\"flex flex-col", "className=\"".len());
|
||||
let in_apply = at(&css_text, "@apply rounded-md", "@apply ".len());
|
||||
for (doc, pos) in [(tsx, in_class), (css, in_apply)] {
|
||||
retry("class completion", Duration::from_secs(60), || {
|
||||
let mgr = mgr.clone();
|
||||
async move {
|
||||
let list = mgr.completion(doc, pos, None, Default::default()).await.ok()?;
|
||||
list.items.iter().any(|i| i.label == "bg-brand-500").then_some(())
|
||||
}
|
||||
})
|
||||
.await;
|
||||
}
|
||||
let hover = mgr.hover(tsx, at(&tsx_text, "bg-white", 1), Default::default()).await.unwrap().unwrap();
|
||||
assert!(hover.contents.value.contains("background-color"), "{}", hover.contents.value);
|
||||
let hover = mgr.hover(tsx, at(&tsx_text, "text-brand-700", 1), Default::default()).await.unwrap().unwrap();
|
||||
assert!(hover.contents.value.contains("--color-brand-700"), "{}", hover.contents.value);
|
||||
|
||||
// `flex block`: both set `display`.
|
||||
retry("class conflict", Duration::from_secs(30), || {
|
||||
let found = events.lock().iter().any(|e| {
|
||||
matches!(e, IdeEvent::Diagnostics { path, items, .. }
|
||||
if path.ends_with("src/App.tsx")
|
||||
&& items.iter().any(|d| d.message.contains("applies the same CSS properties")))
|
||||
});
|
||||
async move { found.then_some(()) }
|
||||
})
|
||||
.await;
|
||||
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
|
||||
}
|
||||
|
||||
/// A notebook's code cells on basedpyright and Ruff (LSP 3.17 notebook sync): names flow from
|
||||
/// earlier cells, IPython magics parse, and locations and diagnostics name the cells.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
|
||||
@@ -244,16 +244,13 @@ pub(crate) fn is_test_script(name: &str) -> bool {
|
||||
}
|
||||
|
||||
/// The test runner a `package.json` script starts, when its output and test selection differ
|
||||
/// from Jest / Vitest's: `playwright test`, `mocha`, or `node --test` (`tsx --test`) with Node's own
|
||||
/// from Jest / Vitest's: `playwright test`, or `node --test` (`tsx --test`) with Node's own
|
||||
/// reporters (the IDE adds its reporter next to them, which a reporter chosen here would clash with).
|
||||
fn script_test_runner(script: &str) -> Option<&'static str> {
|
||||
let tokens: Vec<&str> = script.split(|c: char| c.is_whitespace() || matches!(c, '&' | '|' | ';')).collect();
|
||||
if tokens.windows(2).any(|w| w[0] == "playwright" && w[1] == "test") {
|
||||
return Some("playwright");
|
||||
}
|
||||
if tokens.iter().any(|t| matches!(t.rsplit('/').next(), Some("mocha" | "_mocha"))) {
|
||||
return Some("mocha");
|
||||
}
|
||||
let node = tokens.iter().position(|t| matches!(*t, "node" | "tsx"))?;
|
||||
// Node's own options: up to the script (`node server.js --test` passes `--test` to the program).
|
||||
let mut options = Vec::new();
|
||||
|
||||
@@ -92,20 +92,6 @@ fn node_test_scripts() {
|
||||
assert_eq!(find(&c, "npm:start").extras.test_runner, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mocha_scripts() {
|
||||
let dir = project(&[(
|
||||
"package.json",
|
||||
r#"{"scripts":{"spec":"mocha --recursive","test":"nyc ./node_modules/.bin/mocha","lint":"eslint mocha.config.js"}}"#,
|
||||
)]);
|
||||
let c = detect(dir.path());
|
||||
let spec = find(&c, "npm:spec");
|
||||
assert!(spec.is_test);
|
||||
assert_eq!(spec.extras.test_runner.as_deref(), Some("mocha"));
|
||||
assert_eq!(find(&c, "npm:test").extras.test_runner.as_deref(), Some("mocha"));
|
||||
assert!(!find(&c, "npm:lint").is_test);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn package_manager_selection() {
|
||||
for (lock, pm) in [("yarn.lock", "yarn"), ("bun.lockb", "bun"), ("bun.lock", "bun"), ("package-lock.json", "npm")] {
|
||||
|
||||
@@ -6,7 +6,6 @@ edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
dirs.workspace = true
|
||||
dunce.workspace = true
|
||||
ignore.workspace = true
|
||||
ide-core.workspace = true
|
||||
|
||||
@@ -537,42 +537,6 @@ pub fn configure_gradle_runtime(cfg: &mut LanguageServerConfig, root: &Path, bui
|
||||
merge(cfg.settings.get_or_insert_with(|| json!({})), json!({"java": {"import": {"gradle": gradle}}}));
|
||||
}
|
||||
|
||||
/// Gradle's Eclipse model, which jdtls imports the build through, leaves out project dependencies
|
||||
/// a source set only compiles against (`compileOnly(project(":a"))`) and marks some as test-only,
|
||||
/// so their classes don't resolve in the editor although Gradle compiles. jdtls's Gradle import
|
||||
/// runs an init script that adds them, written to the first of `dirs` whose path has no
|
||||
/// whitespace: Buildship stores the import's arguments joined by spaces and splits them again,
|
||||
/// so `Application Support` would break the path. The name carries the script's hash, so
|
||||
/// releases running side by side never overwrite each other's script.
|
||||
pub fn configure_gradle_classpath(cfg: &mut LanguageServerConfig, dirs: &[PathBuf]) {
|
||||
const SCRIPT: &str = include_str!("gradle-classpath.init.gradle");
|
||||
if cfg.name != "jdtls" {
|
||||
return;
|
||||
}
|
||||
let mut hash = 0xcbf29ce484222325u64;
|
||||
for byte in SCRIPT.bytes() {
|
||||
hash = (hash ^ u64::from(byte)).wrapping_mul(0x100000001b3);
|
||||
}
|
||||
let name = format!("openidea-classpath-{hash:016x}.init.gradle");
|
||||
let Some(script) = dirs
|
||||
.iter()
|
||||
.map(|dir| dir.join(&name))
|
||||
.filter(|script| !script.to_string_lossy().contains(char::is_whitespace))
|
||||
.find(|script| {
|
||||
std::fs::read(script).ok().as_deref() == Some(SCRIPT.as_bytes())
|
||||
|| script.parent().is_some_and(|dir| std::fs::create_dir_all(dir).is_ok())
|
||||
&& std::fs::write(script, SCRIPT).is_ok()
|
||||
})
|
||||
else {
|
||||
tracing::warn!("no directory without spaces for the Gradle classpath init script: {dirs:?}");
|
||||
return;
|
||||
};
|
||||
merge(
|
||||
cfg.settings.get_or_insert_with(|| json!({})),
|
||||
json!({"java": {"import": {"gradle": {"arguments": ["--init-script", script.to_string_lossy()]}}}}),
|
||||
);
|
||||
}
|
||||
|
||||
/// Settings › Build Tools › Maven › Automatically download sources and Always update
|
||||
/// snapshots → jdtls `java.maven.downloadSources` / `java.maven.updateSnapshots`.
|
||||
pub fn configure_maven_sources(cfg: &mut LanguageServerConfig, s: &Settings) {
|
||||
@@ -1460,14 +1424,6 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
|
||||
if name == astro::SERVER {
|
||||
astro::configure(cfg, root, server_root, s);
|
||||
}
|
||||
// Biome lints with the project's own version (its configuration follows that version's
|
||||
// schema); an explicit executable setting still wins.
|
||||
if name == "biome"
|
||||
&& cfg.command == "biome"
|
||||
&& let Some(bin) = crate::npm::project_bin("biome", root, server_root)
|
||||
{
|
||||
cfg.command = bin.to_string_lossy().into_owned();
|
||||
}
|
||||
if name == crate::arduino::SERVER {
|
||||
crate::arduino::configure(cfg, root, server_root, s);
|
||||
}
|
||||
@@ -2565,33 +2521,6 @@ mod maven_linkage_tests {
|
||||
assert_eq!(gradle["user"]["home"], resolved("/caches/gradle"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gradle_import_adds_the_projects_a_source_set_compiles_against() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let spaced = temp.path().join("Application Support").join("gradle");
|
||||
let plain = temp.path().join("cache").join("gradle");
|
||||
let mut cfg = custom_server("jdtls", &LanguageServerSettings::default());
|
||||
cfg.settings = Some(json!({"java": {"import": {"gradle": {"enabled": true}}}}));
|
||||
configure_gradle_classpath(&mut cfg, &[spaced.clone(), plain.clone()]);
|
||||
let gradle = &cfg.settings.as_ref().unwrap()["java"]["import"]["gradle"];
|
||||
assert_eq!(gradle["enabled"], json!(true), "merged, not replaced");
|
||||
let args = gradle["arguments"].as_array().unwrap();
|
||||
assert_eq!(args[0], json!("--init-script"));
|
||||
let script = PathBuf::from(args[1].as_str().unwrap());
|
||||
assert_eq!(script.parent(), Some(plain.as_path()), "Buildship splits arguments at spaces");
|
||||
assert!(!spaced.exists());
|
||||
let text = std::fs::read_to_string(&script).unwrap();
|
||||
assert!(text.contains("compileClasspath") && text.contains("whenMerged"));
|
||||
|
||||
let mut other = custom_server("pyright", &LanguageServerSettings::default());
|
||||
configure_gradle_classpath(&mut other, &[plain]);
|
||||
assert!(other.settings.is_none(), "only jdtls imports Gradle builds");
|
||||
|
||||
let mut nowhere = custom_server("jdtls", &LanguageServerSettings::default());
|
||||
configure_gradle_classpath(&mut nowhere, &[spaced]);
|
||||
assert!(nowhere.settings.is_none(), "no usable directory: the import runs without it");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gradle_import_of_a_gradle_build_runs_on_the_project_jdk_like_the_ides_builds() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
@@ -2814,42 +2743,3 @@ mod conda_activation_tests {
|
||||
assert_eq!(conda_activation(&plain.join("bin").join("python"), "bash", Some(conda), None), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod biome_tests {
|
||||
use super::*;
|
||||
|
||||
fn binary(dir: &Path) -> PathBuf {
|
||||
let bin = dir.join(if cfg!(windows) { "biome.cmd" } else { "biome" });
|
||||
std::fs::create_dir_all(dir).unwrap();
|
||||
std::fs::write(&bin, "").unwrap();
|
||||
#[cfg(unix)]
|
||||
std::fs::set_permissions(&bin, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
|
||||
bin
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn biome_runs_the_projects_own_biome_unless_an_executable_is_set() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("project");
|
||||
let web = root.join("apps/web");
|
||||
let configured = |s: &Settings, server_root: &Path| {
|
||||
let mut cfg = custom_server("biome", &LanguageServerSettings::default());
|
||||
cfg.command = "biome".into();
|
||||
configure_server(&mut cfg, &root, server_root, s);
|
||||
PathBuf::from(cfg.command)
|
||||
};
|
||||
let workspace = binary(&root.join("node_modules/.bin"));
|
||||
assert_eq!(configured(&Settings::default(), &web), workspace);
|
||||
let member = binary(&web.join("node_modules/.bin"));
|
||||
assert_eq!(configured(&Settings::default(), &web), member);
|
||||
// Outside the project: not the project's installation.
|
||||
binary(&tmp.path().join("node_modules/.bin"));
|
||||
assert_eq!(configured(&Settings::default(), &tmp.path().join("other")), PathBuf::from("biome"));
|
||||
let custom = binary(&tmp.path().join("custom"));
|
||||
let mut s = Settings::default();
|
||||
s.tools
|
||||
.insert("biome".into(), ide_core::settings::ToolSettings { path: custom.to_string_lossy().into_owned() });
|
||||
assert_eq!(configured(&s, &web), custom);
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Astro (Volar) requires a TypeScript language-service library at initialize.
|
||||
|
||||
use crate::apply::{merge_init_options, setting_path, tsdk};
|
||||
use crate::npm::{has_ts_api, own_typescript, package_dir, project_bin};
|
||||
use crate::npm::{has_ts_api, own_typescript, package_dir};
|
||||
use ide_core::settings::Settings;
|
||||
use ide_core::tool_path::{find_command, search_path};
|
||||
use ide_language::LanguageServerConfig;
|
||||
@@ -20,7 +20,10 @@ pub(crate) fn configure(cfg: &mut LanguageServerConfig, root: &Path, server_root
|
||||
// A project's installation wins over managed / global tools. Explicit
|
||||
// executable settings still win, as they do for other language servers.
|
||||
if cfg.command == SERVER
|
||||
&& let Some(bin) = project_bin(SERVER, root, server_root)
|
||||
&& let Some(bin) = server_root
|
||||
.ancestors()
|
||||
.take_while(|dir| dir.starts_with(root))
|
||||
.find_map(|dir| find_command(SERVER, dir.join("node_modules/.bin").as_os_str(), server_root))
|
||||
{
|
||||
cfg.command = bin.to_string_lossy().into_owned();
|
||||
}
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
// Gradle's Eclipse model leaves out project dependencies a source set only compiles against
|
||||
// (compileOnly, compileOnlyApi), and marks some as test-only. Add each project the main or test
|
||||
// compile classpath names, so Java code sees the classes it compiles against.
|
||||
allprojects {
|
||||
plugins.withId('java') {
|
||||
apply plugin: 'eclipse'
|
||||
eclipse.classpath.file.whenMerged { classpath ->
|
||||
def projectOf = { dep ->
|
||||
def path
|
||||
try { path = dep.path } catch (MissingPropertyException ignored) { path = dep.dependencyProject.path }
|
||||
rootProject.findProject(path)
|
||||
}
|
||||
def wanted = [:]
|
||||
['testCompileClasspath', 'compileClasspath'].each { name ->
|
||||
def configuration = configurations.findByName(name)
|
||||
if (configuration == null) return
|
||||
configuration.allDependencies.withType(ProjectDependency).each { dep ->
|
||||
def target = projectOf(dep)
|
||||
if (target == null || target == project) return
|
||||
def eclipseName = target.extensions.findByName('eclipse')?.project?.name ?: target.name
|
||||
wanted['/' + eclipseName] = name == 'compileClasspath'
|
||||
}
|
||||
}
|
||||
def existing = classpath.entries.findAll { it instanceof org.gradle.plugins.ide.eclipse.model.ProjectDependency }
|
||||
wanted.each { path, main ->
|
||||
def entry = existing.find { it.path == path }
|
||||
if (entry == null) {
|
||||
entry = new org.gradle.plugins.ide.eclipse.model.ProjectDependency(path)
|
||||
entry.entryAttributes['without_test_code'] = 'true'
|
||||
classpath.entries.add(entry)
|
||||
}
|
||||
if (main) entry.entryAttributes.remove('test')
|
||||
else if (!entry.entryAttributes.containsKey('test')) entry.entryAttributes['test'] = 'true'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1629,7 +1629,7 @@ pub fn usages_bundle(data_dir: &Path) -> Option<PathBuf> {
|
||||
install_bundle(
|
||||
data_dir,
|
||||
"java-usages",
|
||||
"1.17.0",
|
||||
"1.16.0",
|
||||
include_bytes!("../../../java/java-usages/openidea-java-usages.jar"),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -287,8 +287,8 @@ pub fn launch_directly(cfg: &mut LanguageServerConfig) {
|
||||
return;
|
||||
}
|
||||
let Some(script) = script_for(cfg) else { return };
|
||||
let home = jdtls_home(&script);
|
||||
let Some(install) = home.as_deref().and_then(|h| find_install(h, std::env::consts::OS, std::env::consts::ARCH))
|
||||
let Some(install) =
|
||||
jdtls_home(&script).and_then(|h| find_install(&h, std::env::consts::OS, std::env::consts::ARCH))
|
||||
else {
|
||||
return;
|
||||
};
|
||||
@@ -307,60 +307,14 @@ pub fn launch_directly(cfg: &mut LanguageServerConfig) {
|
||||
cfg.launch_error = Some(error);
|
||||
return;
|
||||
}
|
||||
let area = home.as_deref().and_then(|home| configuration_area(home, &cfg.args, dirs::cache_dir()));
|
||||
cfg.args = java_args(&install, jdk.major, &cfg.args);
|
||||
if let Some(area) = area
|
||||
&& let Some(jar) = cfg.args.iter().position(|a| a == "-jar")
|
||||
{
|
||||
cfg.args.insert(jar, format!("-Dosgi.configuration.area={}", area.to_string_lossy()));
|
||||
}
|
||||
cfg.command = java.to_string_lossy().into_owned();
|
||||
}
|
||||
|
||||
/// Equinox extracts bundle files, jdtls's Gradle init scripts among them, into its writable
|
||||
/// configuration area, `<home>/configuration` unless the launch names one. jdtls passes those
|
||||
/// scripts to every Gradle import as `--init-script` arguments, and Buildship stores a build's
|
||||
/// arguments joined by spaces and splits them again. Under a home with spaces (macOS's
|
||||
/// `Application Support`) each import that sets a Gradle JDK, user home or argument then fails
|
||||
/// with "The specified initialization script '…/Application' does not exist". Such a home
|
||||
/// gets an area without spaces in the user's cache directory, one per install.
|
||||
fn configuration_area(home: &Path, args: &[String], cache: Option<PathBuf>) -> Option<PathBuf> {
|
||||
let parsed = split_script_args(args);
|
||||
let named = parsed.jvm.iter().any(|a| a.starts_with("-Dosgi.configuration.area="))
|
||||
|| parsed.rest.iter().any(|a| a == "-configuration");
|
||||
if named || !home.join("configuration").to_string_lossy().contains(char::is_whitespace) {
|
||||
return None;
|
||||
}
|
||||
let mut hash = 0xcbf29ce484222325u64;
|
||||
for byte in home.to_string_lossy().bytes() {
|
||||
hash = (hash ^ u64::from(byte)).wrapping_mul(0x100000001b3);
|
||||
}
|
||||
Some(cache?.join("openidea").join("jdtls-configuration").join(format!("{hash:016x}")))
|
||||
.filter(|area| !area.to_string_lossy().contains(char::is_whitespace))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_home_with_spaces_gets_a_configuration_area_without_them() {
|
||||
let cache = Some(PathBuf::from("/cache"));
|
||||
let spaced = Path::new("/Users/me/Library/Application Support/openidea/tools/jdtls");
|
||||
let area = configuration_area(spaced, &[], cache.clone()).unwrap();
|
||||
assert!(area.starts_with("/cache/openidea/jdtls-configuration"));
|
||||
assert_eq!(configuration_area(spaced, &[], cache.clone()), Some(area), "one per install");
|
||||
assert_ne!(
|
||||
configuration_area(Path::new("/opt/My Tools/jdtls"), &[], cache.clone()),
|
||||
configuration_area(spaced, &[], cache.clone())
|
||||
);
|
||||
assert_eq!(configuration_area(Path::new("/opt/jdtls"), &[], cache.clone()), None, "the default is fine");
|
||||
let own = strings(&["--jvm-arg=-Dosgi.configuration.area=/mine"]);
|
||||
assert_eq!(configuration_area(spaced, &own, cache.clone()), None, "the user's area stays");
|
||||
assert_eq!(configuration_area(spaced, &strings(&["-configuration", "/mine"]), cache), None);
|
||||
assert_eq!(configuration_area(spaced, &[], Some(PathBuf::from("/My Cache"))), None);
|
||||
}
|
||||
|
||||
fn strings(args: &[&str]) -> Vec<String> {
|
||||
args.iter().map(|s| s.to_string()).collect()
|
||||
}
|
||||
|
||||
@@ -10,13 +10,6 @@ pub(crate) fn has_ts_api(lib: &Path) -> bool {
|
||||
lib.join("typescript.js").is_file()
|
||||
}
|
||||
|
||||
/// `command` installed in the project: the nearest `node_modules/.bin` from `server_root` up to `root`.
|
||||
pub(crate) fn project_bin(command: &str, root: &Path, server_root: &Path) -> Option<PathBuf> {
|
||||
server_root.ancestors().take_while(|dir| dir.starts_with(root)).find_map(|dir| {
|
||||
ide_core::tool_path::find_command(command, dir.join("node_modules/.bin").as_os_str(), server_root)
|
||||
})
|
||||
}
|
||||
|
||||
/// The native executable of TypeScript 7 (`typescript` 7+, whose `tsc` is native, or
|
||||
/// `@typescript/native-preview`'s `tsgo`), from its package directory or its `lib`.
|
||||
/// These packages have no JavaScript API (`lib/typescript.js`); their platform package
|
||||
|
||||
@@ -4,7 +4,6 @@
|
||||
//! program: started with [`PORT_ENV`] set, it sends the prompt to the
|
||||
//! [`AskpassServer`] on 127.0.0.1 and prints the answer ([`run_helper`]).
|
||||
|
||||
use ide_core::process::ASKPASS_SILENT_ENV;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use parking_lot::Mutex;
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -16,7 +15,7 @@ use std::sync::atomic::{AtomicU64, Ordering};
|
||||
use std::sync::mpsc;
|
||||
use std::time::Duration;
|
||||
|
||||
pub const PORT_ENV: &str = ide_core::process::ASKPASS_PORT_ENV;
|
||||
pub const PORT_ENV: &str = "OPENIDEA_ASKPASS_PORT";
|
||||
pub const COMMAND_ENV: &str = "OPENIDEA_GIT_COMMAND_ID";
|
||||
pub const TOKEN_ENV: &str = "OPENIDEA_ASKPASS_TOKEN";
|
||||
/// An unanswered prompt fails after this long.
|
||||
@@ -52,8 +51,6 @@ pub fn remembers(prompt: &str) -> bool {
|
||||
struct Request {
|
||||
#[serde(default)]
|
||||
command_id: Option<u64>,
|
||||
#[serde(default)]
|
||||
silent: bool,
|
||||
token: String,
|
||||
prompt: String,
|
||||
}
|
||||
@@ -160,16 +157,12 @@ fn serve(
|
||||
let _ = writeln!(out, "{}", serde_json::to_string(&Response { answer: Some(answer) }).unwrap_or_default());
|
||||
return;
|
||||
}
|
||||
if req.silent {
|
||||
None
|
||||
} else {
|
||||
let (tx, rx) = mpsc::channel();
|
||||
pending.lock().insert(id, PendingPrompt { command_id: req.command_id, prompt: prompt.clone(), tx });
|
||||
on_prompt(AskpassPrompt { id, kind: classify(&prompt), prompt });
|
||||
let answer = rx.recv_timeout(ANSWER_TIMEOUT).ok().flatten();
|
||||
pending.lock().remove(&id);
|
||||
answer
|
||||
}
|
||||
let (tx, rx) = mpsc::channel();
|
||||
pending.lock().insert(id, PendingPrompt { command_id: req.command_id, prompt: prompt.clone(), tx });
|
||||
on_prompt(AskpassPrompt { id, kind: classify(&prompt), prompt });
|
||||
let answer = rx.recv_timeout(ANSWER_TIMEOUT).ok().flatten();
|
||||
pending.lock().remove(&id);
|
||||
answer
|
||||
};
|
||||
let mut out = stream;
|
||||
let _ = writeln!(out, "{}", serde_json::to_string(&Response { answer }).unwrap_or_default());
|
||||
@@ -197,14 +190,9 @@ pub fn run_helper() -> Option<i32> {
|
||||
let token = std::env::var(TOKEN_ENV).unwrap_or_default();
|
||||
let prompt = std::env::args().nth(1).unwrap_or_else(|| "Password:".into());
|
||||
let command_id = std::env::var(COMMAND_ENV).ok().and_then(|id| id.parse().ok());
|
||||
let silent = std::env::var(ASKPASS_SILENT_ENV).is_ok_and(|value| value == "1");
|
||||
let ask = || -> std::io::Result<Option<String>> {
|
||||
let mut stream = TcpStream::connect(("127.0.0.1", port))?;
|
||||
writeln!(
|
||||
stream,
|
||||
"{}",
|
||||
serde_json::to_string(&Request { command_id, silent, token, prompt }).unwrap_or_default()
|
||||
)?;
|
||||
writeln!(stream, "{}", serde_json::to_string(&Request { command_id, token, prompt }).unwrap_or_default())?;
|
||||
let mut line = String::new();
|
||||
BufReader::new(stream).read_line(&mut line)?;
|
||||
Ok(serde_json::from_str::<Response>(&line).ok().and_then(|r| r.answer))
|
||||
@@ -245,13 +233,7 @@ mod tests {
|
||||
writeln!(
|
||||
stream,
|
||||
"{}",
|
||||
serde_json::to_string(&Request {
|
||||
command_id: Some(42),
|
||||
silent: false,
|
||||
token,
|
||||
prompt: "Password: ".into()
|
||||
})
|
||||
.unwrap()
|
||||
serde_json::to_string(&Request { command_id: Some(42), token, prompt: "Password: ".into() }).unwrap()
|
||||
)
|
||||
.unwrap();
|
||||
let mut line = String::new();
|
||||
@@ -270,22 +252,4 @@ mod tests {
|
||||
assert_eq!(client.join().unwrap().as_deref(), Some("hunter2"));
|
||||
assert!(server.env().iter().any(|(k, v)| k == "SSH_ASKPASS" && v == "helper"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn silent_request_with_no_saved_credentials_returns_without_prompting() {
|
||||
let server = AskpassServer::start("helper".into(), Arc::new(|_| panic!("unexpected prompt"))).unwrap();
|
||||
let mut stream = TcpStream::connect(("127.0.0.1", server.port)).unwrap();
|
||||
stream.set_read_timeout(Some(Duration::from_secs(2))).unwrap();
|
||||
let request = Request {
|
||||
command_id: Some(42),
|
||||
silent: true,
|
||||
token: server.token.clone(),
|
||||
prompt: "Password for 'https://test-password.example.invalid': ".into(),
|
||||
};
|
||||
writeln!(stream, "{}", serde_json::to_string(&request).unwrap()).unwrap();
|
||||
let mut line = String::new();
|
||||
BufReader::new(stream).read_line(&mut line).unwrap();
|
||||
assert!(serde_json::from_str::<Response>(&line).unwrap().answer.is_none());
|
||||
assert!(server.pending.lock().is_empty());
|
||||
}
|
||||
}
|
||||
@@ -62,22 +62,13 @@ fn package_bin(package: &Path, tool: &str) -> IdeResult<PathBuf> {
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
/// Prettier and Ruff format ranges for some languages (`config.range`); oxfmt and Biome format whole files only.
|
||||
/// Prettier and Ruff format ranges for some languages (`config.range`); oxfmt formats whole files only.
|
||||
pub fn supports_range(tool: &str, config: &FormatterConfig) -> bool {
|
||||
matches!(tool, "prettier" | "ruff") && config.range
|
||||
}
|
||||
|
||||
fn is_formatter(tool: &str) -> bool {
|
||||
crate::registry::find(tool)
|
||||
.is_some_and(|t| t.kind == crate::ToolKind::Formatter || matches!(t.name, "ruff" | "biome"))
|
||||
}
|
||||
|
||||
/// The npm package that provides `tool`'s CLI.
|
||||
fn npm_package(tool: &str) -> &str {
|
||||
match tool {
|
||||
"biome" => "@biomejs/biome",
|
||||
_ => tool,
|
||||
}
|
||||
crate::registry::find(tool).is_some_and(|t| t.kind == crate::ToolKind::Formatter || t.name == "ruff")
|
||||
}
|
||||
|
||||
impl Tools {
|
||||
@@ -90,7 +81,7 @@ impl Tools {
|
||||
if !is_formatter(tool) {
|
||||
return Err(IdeError::unavailable(format!("Unknown external formatter: {tool}")));
|
||||
}
|
||||
let package = Path::new("node_modules").join(npm_package(tool));
|
||||
let package = Path::new("node_modules").join(tool);
|
||||
let manifest = package.join("package.json");
|
||||
let (path, node) = if let Some(custom) = custom.filter(|p| p.is_dir()) {
|
||||
(package_bin(custom, tool)?, true)
|
||||
@@ -117,7 +108,7 @@ impl Tools {
|
||||
}
|
||||
|
||||
/// Every tool resolves its configuration itself. Prettier's project configuration
|
||||
/// overrides the editor indentation passed here; oxfmt, Biome and Ruff read their own
|
||||
/// overrides the editor indentation passed here; oxfmt and Ruff read their own
|
||||
/// configuration files. Ruff also discovers the nearest `pyproject.toml`,
|
||||
/// `ruff.toml`, or `.ruff.toml` from the stdin filename.
|
||||
pub fn arguments(
|
||||
@@ -146,12 +137,6 @@ pub fn arguments(
|
||||
}
|
||||
return args;
|
||||
}
|
||||
if tool == "biome" {
|
||||
// Biome finds its `biome.json` and ignore files from the file's path itself.
|
||||
let mut path = OsString::from("--stdin-file-path=");
|
||||
path.push(file);
|
||||
return vec!["format".into(), path];
|
||||
}
|
||||
if tool == "prettier" {
|
||||
let parser = if config.parser == "markdown" && file.extension().is_some_and(|s| s == "mdx") {
|
||||
"mdx"
|
||||
@@ -338,38 +323,6 @@ mod tests {
|
||||
assert!(unknown.message.contains("Unknown external formatter"), "{}", unknown.message);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn biome_runs_the_nearest_biomejs_package_with_the_file_path() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let package = root.join("node_modules/@biomejs/biome");
|
||||
std::fs::create_dir_all(package.join("bin")).unwrap();
|
||||
std::fs::write(package.join("package.json"), r#"{"bin":{"biome":"bin/biome"}}"#).unwrap();
|
||||
std::fs::write(package.join("bin/biome"), "").unwrap();
|
||||
std::fs::write(root.join(".prettierignore"), "dist").unwrap();
|
||||
let file = root.join("packages/web/src/app.ts");
|
||||
let path = std::env::var_os("PATH").unwrap_or_default();
|
||||
let tools = Tools::with_paths(root.join("tools"), path, crate::platform::Platform::current());
|
||||
|
||||
let command = tools.formatter_command("biome", &file, None).unwrap();
|
||||
let program = Path::new(command.get_program()).file_stem().unwrap().to_string_lossy().into_owned();
|
||||
assert_eq!(program, "node");
|
||||
let script: Vec<_> = command.get_args().collect();
|
||||
assert_eq!(
|
||||
Path::new(&script[0]).components().collect::<Vec<_>>(),
|
||||
package.join("bin/biome").components().collect::<Vec<_>>()
|
||||
);
|
||||
|
||||
let config = FormatterConfig { tool: "prettier".into(), parser: "typescript".into(), range: true };
|
||||
let range =
|
||||
Some(FormatRange { start_offset: 3, end_offset: 9, start_line: 1, start_col: 1, end_line: 1, end_col: 7 });
|
||||
let mut stdin_path = OsString::from("--stdin-file-path=");
|
||||
stdin_path.push(&file);
|
||||
// No Prettier ignore files or indentation: Biome reads its own configuration.
|
||||
assert_eq!(arguments("biome", &config, &file, 4, false, range, None), ["format".into(), stdin_path]);
|
||||
assert!(!supports_range("biome", &config));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ruff_formats_stdin_and_uses_its_config_and_range_flags() {
|
||||
let config = FormatterConfig { tool: "ruff".into(), parser: "python".into(), range: true };
|
||||
|
||||
@@ -201,18 +201,6 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
needs: NODE,
|
||||
homepage: "https://oxc.rs/docs/guide/usage/linter",
|
||||
},
|
||||
// Linter and formatter: `biome lsp-proxy` lints, and Reformat Code runs `biome format`.
|
||||
ToolSpec {
|
||||
name: "biome",
|
||||
display: "Biome",
|
||||
kind: LanguageServer,
|
||||
commands: &["biome"],
|
||||
method: Method::Npm { packages: &["@biomejs/biome"] },
|
||||
fallback: None,
|
||||
version: ver("biome"),
|
||||
needs: NODE,
|
||||
homepage: "https://biomejs.dev",
|
||||
},
|
||||
ToolSpec {
|
||||
name: "eslint",
|
||||
display: "ESLint Language Server",
|
||||
@@ -224,17 +212,6 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
homepage: "https://github.com/hrsh7th/vscode-langservers-extracted",
|
||||
needs: NODE,
|
||||
},
|
||||
ToolSpec {
|
||||
name: "stylelint",
|
||||
display: "Stylelint Language Server",
|
||||
kind: LanguageServer,
|
||||
commands: &["stylelint-language-server"],
|
||||
method: Method::Npm { packages: &["@stylelint/language-server"] },
|
||||
fallback: None,
|
||||
version: V,
|
||||
homepage: "https://github.com/stylelint/vscode-stylelint",
|
||||
needs: NODE,
|
||||
},
|
||||
ToolSpec {
|
||||
name: "rust-analyzer",
|
||||
display: "rust-analyzer",
|
||||
@@ -467,18 +444,6 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
homepage: "https://angular.dev/tools/language-service",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "tailwindcss-language-server",
|
||||
display: "Tailwind CSS Language Server",
|
||||
kind: LanguageServer,
|
||||
commands: &["tailwindcss-language-server"],
|
||||
// Brings Tailwind CSS 3 and 4 for projects whose own `tailwindcss` isn't installed yet.
|
||||
method: Method::Npm { packages: &["@tailwindcss/language-server"] },
|
||||
fallback: None,
|
||||
version: V,
|
||||
homepage: "https://github.com/tailwindlabs/tailwindcss-intellisense",
|
||||
needs: NODE,
|
||||
},
|
||||
ToolSpec {
|
||||
name: "graphql-lsp",
|
||||
display: "GraphQL Language Server",
|
||||
@@ -1321,7 +1286,7 @@ mod tests {
|
||||
known.insert((d.adapter.clone(), d.command.clone()));
|
||||
}
|
||||
}
|
||||
// The host selects the formatter of each file (Prettier, oxfmt or Biome) and runs its own CLIs.
|
||||
// The host selects the formatter of each file (Prettier or oxfmt) and runs its own CLIs.
|
||||
for t in TOOLS.iter().filter(|t| !matches!(t.kind, Plugin | Formatter | Cli)) {
|
||||
assert!(
|
||||
known.contains(&(t.name.to_string(), t.commands[0].to_string())),
|
||||
|
||||
@@ -10,7 +10,6 @@ encoding_rs.workspace = true
|
||||
dunce.workspace = true
|
||||
ide-core.workspace = true
|
||||
ignore.workspace = true
|
||||
notify.workspace = true
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
specta.workspace = true
|
||||
|
||||
+12
-26
@@ -1,32 +1,26 @@
|
||||
//! `git blame --porcelain` parsing.
|
||||
|
||||
use crate::BlameLine;
|
||||
use ide_core::IpcPath;
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Component, Path};
|
||||
|
||||
#[derive(Default, Clone)]
|
||||
struct CommitMeta {
|
||||
author: String,
|
||||
time_ms: f64,
|
||||
summary: String,
|
||||
origin_path: Option<IpcPath>,
|
||||
}
|
||||
|
||||
/// Parses `git blame --porcelain` output into one entry per final line.
|
||||
pub(crate) fn parse_porcelain(out: &str, root: &Path, relative_path: &str) -> Vec<BlameLine> {
|
||||
pub(crate) fn parse_porcelain(out: &str) -> Vec<BlameLine> {
|
||||
let mut metas: HashMap<String, CommitMeta> = HashMap::new();
|
||||
let mut lines: Vec<(u32, String, Option<IpcPath>)> = Vec::new();
|
||||
let mut current: Option<(u32, String)> = None;
|
||||
let mut lines: Vec<(u32, String)> = Vec::new();
|
||||
let mut current: Option<String> = None;
|
||||
for line in out.split('\n') {
|
||||
if line.starts_with('\t') {
|
||||
if let Some((number, id)) = current.take() {
|
||||
let origin = metas.get(&id).and_then(|m| m.origin_path.clone());
|
||||
lines.push((number, id, origin));
|
||||
}
|
||||
if let Some(_content) = line.strip_prefix('\t') {
|
||||
current = None;
|
||||
continue;
|
||||
}
|
||||
if let Some((_, id)) = current.as_ref() {
|
||||
if let Some(id) = current.as_ref() {
|
||||
let meta = metas.entry(id.clone()).or_default();
|
||||
if let Some(v) = line.strip_prefix("author ") {
|
||||
meta.author = v.to_string();
|
||||
@@ -34,15 +28,6 @@ pub(crate) fn parse_porcelain(out: &str, root: &Path, relative_path: &str) -> Ve
|
||||
meta.time_ms = v.trim().parse::<f64>().unwrap_or(0.0) * 1000.0;
|
||||
} else if let Some(v) = line.strip_prefix("summary ") {
|
||||
meta.summary = v.to_string();
|
||||
} else if let Some(v) = line.strip_prefix("filename ") {
|
||||
// Porcelain repeats the filename at group boundaries when one commit
|
||||
// contributed lines from multiple files, even when it omits other metadata.
|
||||
let name = crate::patch::git_path(v);
|
||||
let path = Path::new(&name);
|
||||
meta.origin_path = (name != relative_path
|
||||
&& !name.is_empty()
|
||||
&& path.components().all(|c| matches!(c, Component::Normal(_))))
|
||||
.then(|| root.join(path).into());
|
||||
}
|
||||
continue;
|
||||
}
|
||||
@@ -56,14 +41,15 @@ pub(crate) fn parse_porcelain(out: &str, root: &Path, relative_path: &str) -> Ve
|
||||
}
|
||||
let Ok(final_line) = final_line.parse::<u32>() else { continue };
|
||||
metas.entry(sha.to_string()).or_default();
|
||||
current = Some((final_line, sha.to_string()));
|
||||
lines.push((final_line, sha.to_string()));
|
||||
current = Some(sha.to_string());
|
||||
}
|
||||
lines.sort_by_key(|(n, ..)| *n);
|
||||
lines.sort_by_key(|(n, _)| *n);
|
||||
lines
|
||||
.into_iter()
|
||||
.map(|(_, sha, origin_path)| {
|
||||
.map(|(_, sha)| {
|
||||
let meta = metas.get(&sha).cloned().unwrap_or_default();
|
||||
BlameLine { commit: sha, author: meta.author, time_ms: meta.time_ms, summary: meta.summary, origin_path }
|
||||
BlameLine { commit: sha, author: meta.author, time_ms: meta.time_ms, summary: meta.summary }
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
@@ -81,7 +67,7 @@ mod tests {
|
||||
{sha_a} 2 2\n\tl2\n\
|
||||
{sha_z} 3 3 1\nauthor Not Committed Yet\nauthor-time 200\nsummary Version of f from f\nfilename f\n\tl3\n"
|
||||
);
|
||||
let lines = parse_porcelain(&out, Path::new("root"), "f");
|
||||
let lines = parse_porcelain(&out);
|
||||
assert_eq!(lines.len(), 3);
|
||||
assert_eq!(lines[1].author, "Ann");
|
||||
assert_eq!(lines[1].time_ms, 100_000.0);
|
||||
|
||||
@@ -13,12 +13,7 @@ impl ChangelistState {
|
||||
/// The default "Changes" list, active, with no file assignments.
|
||||
pub fn initial() -> Self {
|
||||
ChangelistState {
|
||||
lists: vec![Changelist {
|
||||
id: DEFAULT_ID.into(),
|
||||
name: DEFAULT_NAME.into(),
|
||||
comment: String::new(),
|
||||
applied_commit: None,
|
||||
}],
|
||||
lists: vec![Changelist { id: DEFAULT_ID.into(), name: DEFAULT_NAME.into(), comment: String::new() }],
|
||||
active: DEFAULT_ID.into(),
|
||||
files: Default::default(),
|
||||
}
|
||||
@@ -44,23 +39,11 @@ impl ChangelistState {
|
||||
pub fn load(file: &Path) -> ChangelistState {
|
||||
std::fs::read(file)
|
||||
.ok()
|
||||
.and_then(|b| decode(&b).ok())
|
||||
.and_then(|b| serde_json::from_slice::<ChangelistState>(&b).ok())
|
||||
.map(ChangelistState::normalized)
|
||||
.unwrap_or_else(ChangelistState::initial)
|
||||
}
|
||||
|
||||
fn decode(bytes: &[u8]) -> serde_json::Result<ChangelistState> {
|
||||
let mut value: serde_json::Value = serde_json::from_slice(bytes)?;
|
||||
if let Some(lists) = value.get_mut("lists").and_then(serde_json::Value::as_array_mut) {
|
||||
for list in lists.iter_mut().filter_map(serde_json::Value::as_object_mut) {
|
||||
if let Some(source) = list.remove("cherryPick") {
|
||||
list.entry("appliedCommit").or_insert(source);
|
||||
}
|
||||
}
|
||||
}
|
||||
serde_json::from_value(value)
|
||||
}
|
||||
|
||||
pub fn save(file: &Path, state: &ChangelistState) -> IdeResult<()> {
|
||||
if let Some(dir) = file.parent() {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
@@ -110,12 +93,7 @@ mod tests {
|
||||
assert_eq!(load(&file).lists[0].name, "Changes");
|
||||
|
||||
let mut st = ChangelistState::initial();
|
||||
st.lists.push(Changelist {
|
||||
id: "f".into(),
|
||||
name: "Feature".into(),
|
||||
comment: String::new(),
|
||||
applied_commit: None,
|
||||
});
|
||||
st.lists.push(Changelist { id: "f".into(), name: "Feature".into(), comment: String::new() });
|
||||
st.active = "f".into();
|
||||
st.files.insert("src/a.rs".into(), "f".into());
|
||||
st.files.insert("b.rs".into(), "missing".into());
|
||||
@@ -138,33 +116,4 @@ mod tests {
|
||||
assert_eq!(text.matches("/shelf/").count(), 1);
|
||||
assert!(text.contains("/changelists.json\n"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restores_earlier_cherry_pick_lists() {
|
||||
let state = decode(
|
||||
br#"{
|
||||
"lists": [{
|
||||
"id": "pick",
|
||||
"name": "Incoming change",
|
||||
"cherryPick": {
|
||||
"repo": "/repo",
|
||||
"commit": "source",
|
||||
"base": "head",
|
||||
"author": "Author <[email protected]>",
|
||||
"authorDate": "2022-06-04T13:20:21+05:30"
|
||||
}
|
||||
}],
|
||||
"active": "pick",
|
||||
"files": {"a.txt": "pick"}
|
||||
}"#,
|
||||
)
|
||||
.unwrap();
|
||||
let list = &state.lists[0];
|
||||
let source = list.applied_commit.as_ref().unwrap();
|
||||
assert_eq!(source.kind, crate::CommitApplyKind::CherryPick);
|
||||
assert_eq!(source.author_date.as_deref(), Some("2022-06-04T13:20:21+05:30"));
|
||||
let saved = serde_json::to_value(list).unwrap();
|
||||
assert_eq!(saved["appliedCommit"]["kind"], "cherry-pick");
|
||||
assert_eq!(saved["appliedCommit"]["author"], "Author <[email protected]>");
|
||||
}
|
||||
}
|
||||
@@ -1,160 +0,0 @@
|
||||
//! Git's -x applies to the whole invocation. For mixed batches, resume the
|
||||
//! queued commits after Git finishes the single pick that needed resolution.
|
||||
|
||||
use crate::{ApplyCommitOptions, Repo, cli, ops};
|
||||
use ide_core::workflow_settings::EmptyCherryPickAction;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::HashSet;
|
||||
use std::fs;
|
||||
use std::time::SystemTime;
|
||||
|
||||
const PLAN: &str = "openidea-cherry-pick.json";
|
||||
|
||||
#[derive(Clone, Copy, Default)]
|
||||
pub struct CherryPickOptions<'a> {
|
||||
pub record_origin: bool,
|
||||
pub record_origin_for: &'a [String],
|
||||
pub empty_action: EmptyCherryPickAction,
|
||||
}
|
||||
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
struct Pick {
|
||||
commit: String,
|
||||
record_origin: bool,
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Serialize, Deserialize)]
|
||||
struct Pause {
|
||||
commit: String,
|
||||
head: (Option<String>, Option<String>),
|
||||
modified: SystemTime,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct Pending {
|
||||
pause: Pause,
|
||||
remaining: Vec<Pick>,
|
||||
}
|
||||
|
||||
pub(crate) fn start(
|
||||
repo: &Repo,
|
||||
commits: &[String],
|
||||
options: CherryPickOptions<'_>,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<u32> {
|
||||
let ids = ops::checked_apply_commits(repo, commits, "cherry-pick")?;
|
||||
let action = options.empty_action;
|
||||
if options.record_origin_for.is_empty() {
|
||||
return ops::apply_cherry_pick(repo, &ids, options.record_origin, action, cancel, out);
|
||||
}
|
||||
let selected: HashSet<_> = commits.iter().collect();
|
||||
let origins: HashSet<_> = options.record_origin_for.iter().collect();
|
||||
if !origins.is_subset(&selected) {
|
||||
return Err(IdeError::invalid("Cherry-pick origins must be among the selected commits"));
|
||||
}
|
||||
if selected.len() == origins.len() {
|
||||
return ops::apply_cherry_pick(repo, &ids, true, action, cancel, out);
|
||||
}
|
||||
let picks: Vec<_> = commits
|
||||
.iter()
|
||||
.zip(ids)
|
||||
.map(|(original, commit)| Pick { commit, record_origin: origins.contains(original) })
|
||||
.collect();
|
||||
apply(repo, &picks, action, cancel, out)
|
||||
}
|
||||
|
||||
pub(crate) fn resume(
|
||||
repo: &Repo,
|
||||
args: &[&str],
|
||||
edited: Option<(&str, &ApplyCommitOptions)>,
|
||||
action: EmptyCherryPickAction,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<u32> {
|
||||
let picking = args.first() == Some(&"cherry-pick");
|
||||
let pending = picking.then(|| load(repo)).flatten();
|
||||
let mut run_sequence = true;
|
||||
if let Some((message, options)) = edited {
|
||||
// Capture the pending plan first: committing removes CHERRY_PICK_HEAD.
|
||||
ops::commit_apply_message(repo, message, options, cancel, out)?;
|
||||
run_sequence = repo.git_dir.join("sequencer/todo").is_file();
|
||||
}
|
||||
let empty = if !run_sequence {
|
||||
0
|
||||
} else if picking {
|
||||
ops::apply_resolving_empty(repo, "cherry-pick", args, action, cancel, out)?
|
||||
} else {
|
||||
cli::run_streaming(repo.root(), args, cancel, out)?;
|
||||
0
|
||||
};
|
||||
match pending {
|
||||
Some(pending) => apply(repo, &pending.remaining, action, cancel, out).map(|rest| empty + rest),
|
||||
None => Ok(empty),
|
||||
}
|
||||
}
|
||||
|
||||
fn apply(
|
||||
repo: &Repo,
|
||||
picks: &[Pick],
|
||||
action: EmptyCherryPickAction,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<u32> {
|
||||
if repo.operation()?.is_some() {
|
||||
return Err(IdeError::invalid("Another Git operation is in progress."));
|
||||
}
|
||||
clear(repo);
|
||||
let mut empty = 0;
|
||||
for (index, pick) in picks.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let head = repo.head()?;
|
||||
match ops::apply_cherry_pick(repo, std::slice::from_ref(&pick.commit), pick.record_origin, action, cancel, out)
|
||||
{
|
||||
Ok(count) => empty += count,
|
||||
Err(error) => {
|
||||
let remaining = &picks[index + 1..];
|
||||
if !remaining.is_empty()
|
||||
&& let Some(pause) = current_pause(repo)
|
||||
&& pause.commit == pick.commit
|
||||
&& pause.head == head
|
||||
{
|
||||
save(repo, pause, remaining)?;
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(empty)
|
||||
}
|
||||
|
||||
fn current_pause(repo: &Repo) -> Option<Pause> {
|
||||
let path = repo.git_dir.join("CHERRY_PICK_HEAD");
|
||||
let modified = fs::metadata(&path).ok()?.modified().ok()?;
|
||||
let commit = fs::read_to_string(&path).ok()?.trim().to_owned();
|
||||
Some(Pause { commit, head: repo.head().ok()?, modified })
|
||||
}
|
||||
|
||||
fn load(repo: &Repo) -> Option<Pending> {
|
||||
let pending: Pending = serde_json::from_slice(&fs::read(repo.git_dir.join(PLAN)).ok()?).ok()?;
|
||||
// The same commit can be cherry-picked later outside the IDE. Its Git
|
||||
// checkpoint must match before any previously queued picks are replayed.
|
||||
(current_pause(repo)? == pending.pause
|
||||
&& pending.remaining.iter().all(|pick| gix::ObjectId::from_hex(pick.commit.as_bytes()).is_ok()))
|
||||
.then_some(pending)
|
||||
}
|
||||
|
||||
fn save(repo: &Repo, pause: Pause, remaining: &[Pick]) -> IdeResult<()> {
|
||||
let mut file = tempfile::NamedTempFile::new_in(&repo.git_dir)?;
|
||||
serde_json::to_writer(&mut file, &(Pending { pause, remaining: remaining.to_vec() }))
|
||||
.map_err(|err| IdeError::internal(err.to_string()))?;
|
||||
file.persist(repo.git_dir.join(PLAN)).map_err(|err| err.error)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn clear(repo: &Repo) {
|
||||
let _ = fs::remove_file(repo.git_dir.join(PLAN));
|
||||
}
|
||||
+32
-189
@@ -6,7 +6,6 @@ use std::io::{Read, Write};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Stdio};
|
||||
use std::sync::OnceLock;
|
||||
use std::sync::atomic::{AtomicU32, Ordering};
|
||||
use std::sync::mpsc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
@@ -14,41 +13,15 @@ use std::time::{Duration, Instant};
|
||||
/// to exit on `SIGTERM` before `SIGKILL`: git removes its `index.lock` on `SIGTERM`.
|
||||
const KILL_GRACE: Duration = Duration::from_millis(20);
|
||||
|
||||
/// A throwaway index file in the repository's Git directory.
|
||||
pub(crate) struct TempIndex(PathBuf);
|
||||
/// Explicit git executable from Settings › Version Control › Git (`None` = auto-detect).
|
||||
static CONFIGURED: std::sync::RwLock<Option<PathBuf>> = std::sync::RwLock::new(None);
|
||||
|
||||
impl TempIndex {
|
||||
pub(crate) fn new(repo: &crate::Repo) -> Self {
|
||||
static SEQ: AtomicU32 = AtomicU32::new(0);
|
||||
let n = SEQ.fetch_add(1, Ordering::Relaxed);
|
||||
Self(repo.git_dir.join(format!("openidea-index-{}-{n}", std::process::id())))
|
||||
}
|
||||
|
||||
pub(crate) fn env(&self) -> [(&'static str, &std::ffi::OsStr); 1] {
|
||||
[("GIT_INDEX_FILE", self.0.as_os_str())]
|
||||
}
|
||||
|
||||
pub(crate) fn path(&self) -> &Path {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TempIndex {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.0);
|
||||
let _ = std::fs::remove_file(self.0.with_extension("lock"));
|
||||
}
|
||||
}
|
||||
|
||||
/// Git executable of the user's global settings (`None` = auto-detect). Never a project's: a
|
||||
/// project's repositories carry their own ([`crate::Repo::set_git_executable`]).
|
||||
static DEFAULT: std::sync::RwLock<Option<PathBuf>> = std::sync::RwLock::new(None);
|
||||
|
||||
/// Sets (or clears, with `None` / an empty path) the git executable of repositories that have
|
||||
/// none of their own, from the global settings only.
|
||||
pub fn set_default_git_executable(path: Option<&Path>) {
|
||||
/// Sets (or clears, with `None` / an empty path) the git executable to use.
|
||||
pub fn set_git_executable(path: Option<&Path>) {
|
||||
let path = path.filter(|p| !p.as_os_str().is_empty()).map(Path::to_path_buf);
|
||||
*DEFAULT.write().unwrap_or_else(|e| e.into_inner()) = path;
|
||||
if *CONFIGURED.read().unwrap_or_else(|e| e.into_inner()) != path {
|
||||
*CONFIGURED.write().unwrap_or_else(|e| e.into_inner()) = path;
|
||||
}
|
||||
}
|
||||
|
||||
/// Environment that routes credential prompts (`ssh` passphrases and host keys,
|
||||
@@ -129,20 +102,16 @@ pub fn detected_git_executable() -> Option<PathBuf> {
|
||||
detected_git().map(Path::to_path_buf)
|
||||
}
|
||||
|
||||
/// The executable of the repository this thread works in, else the default, else the detected one.
|
||||
pub(crate) fn git_binary() -> IdeResult<PathBuf> {
|
||||
if let Some(own) = crate::scoped_git_executable() {
|
||||
return Ok(own.to_path_buf());
|
||||
}
|
||||
if let Some(default) = DEFAULT.read().unwrap_or_else(|e| e.into_inner()).clone() {
|
||||
return Ok(default);
|
||||
if let Some(configured) = CONFIGURED.read().unwrap_or_else(|e| e.into_inner()).clone() {
|
||||
return Ok(configured);
|
||||
}
|
||||
detected_git()
|
||||
.map(Path::to_path_buf)
|
||||
.ok_or_else(|| IdeError::unavailable("git executable not found; install git and make sure it is on PATH"))
|
||||
}
|
||||
|
||||
/// `git --version` of `executable` (or the default / detected one), e.g. `git version 2.44.0`.
|
||||
/// `git --version` of `executable` (or the configured / detected one), e.g. `git version 2.44.0`.
|
||||
pub fn git_version(executable: Option<&Path>) -> IdeResult<String> {
|
||||
let exe = match executable.filter(|p| !p.as_os_str().is_empty()) {
|
||||
Some(p) => p.to_path_buf(),
|
||||
@@ -302,7 +271,6 @@ pub(crate) fn command(root: &Path) -> IdeResult<Command> {
|
||||
.env("GIT_PAGER", "cat")
|
||||
.env("GIT_EDITOR", "true")
|
||||
.env("GIT_SEQUENCE_EDITOR", "true")
|
||||
.env_remove(ide_core::process::ASKPASS_SILENT_ENV)
|
||||
.env_remove("GIT_DIR")
|
||||
.env_remove("GIT_WORK_TREE")
|
||||
.env_remove("GIT_INDEX_FILE");
|
||||
@@ -506,7 +474,7 @@ fn run_cancellable_raw_stdin(
|
||||
stdin: Option<&[u8]>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Output> {
|
||||
run_capture(root, args, stdin, cancel, usize::MAX, Credentials::Interactive, &[])
|
||||
run_capture(root, args, stdin, cancel, usize::MAX)
|
||||
}
|
||||
|
||||
/// Options for a `git diff` that reads the working tree in Restricted Mode: git asks a submodule
|
||||
@@ -550,99 +518,29 @@ pub fn filter_overrides_from(config: &[u8]) -> IdeResult<Vec<String>> {
|
||||
|
||||
/// Cancellable capture with bounded stdout and stderr; stops git on overflow.
|
||||
pub(crate) fn run_bounded(root: &Path, args: &[&str], cancel: &CancellationToken, max: usize) -> IdeResult<Output> {
|
||||
run_bounded_env(root, args, cancel, max, &[])
|
||||
}
|
||||
|
||||
pub(crate) fn run_bounded_env(
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
cancel: &CancellationToken,
|
||||
max: usize,
|
||||
env: &[(&str, &std::ffi::OsStr)],
|
||||
) -> IdeResult<Output> {
|
||||
let out = run_capture(root, args, None, cancel, max, Credentials::Interactive, env)?;
|
||||
let out = run_capture(root, args, None, cancel, max)?;
|
||||
if out.code == Some(0) { Ok(out) } else { Err(failure(args, &out.stderr, &out.stdout, out.code)) }
|
||||
}
|
||||
/// Quiet transport that may still obtain credentials from the IDE's saved store.
|
||||
pub(crate) fn run_with_saved_credentials(root: &Path, args: &[&str], cancel: &CancellationToken) -> IdeResult<Output> {
|
||||
let out = run_with_saved_credentials_raw(root, args, cancel)?;
|
||||
if out.code == Some(0) { Ok(out) } else { Err(failure(args, &out.stderr, &out.stdout, out.code)) }
|
||||
}
|
||||
|
||||
pub(crate) fn run_with_saved_credentials_raw(
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Output> {
|
||||
run_capture(root, args, None, cancel, 1 << 20, Credentials::Saved, &[])
|
||||
}
|
||||
|
||||
fn suppress_credential_prompts(cmd: &mut Command) {
|
||||
cmd.env("GCM_INTERACTIVE", "never");
|
||||
let ide_askpass = cmd.get_envs().any(|(key, value)| key == ide_core::process::ASKPASS_PORT_ENV && value.is_some());
|
||||
if ide_askpass {
|
||||
cmd.env(ide_core::process::ASKPASS_SILENT_ENV, "1");
|
||||
} else {
|
||||
cmd.args(["-c", "credential.interactive=false"])
|
||||
.env("GIT_ASKPASS", no_program())
|
||||
.env("SSH_ASKPASS", no_program())
|
||||
.env("SSH_ASKPASS_REQUIRE", "never");
|
||||
}
|
||||
}
|
||||
|
||||
enum Credentials {
|
||||
Interactive,
|
||||
Saved,
|
||||
}
|
||||
|
||||
fn run_capture(
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
stdin: Option<&[u8]>,
|
||||
cancel: &CancellationToken,
|
||||
max: usize,
|
||||
credentials: Credentials,
|
||||
env: &[(&str, &std::ffi::OsStr)],
|
||||
) -> IdeResult<Output> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let mut cmd = command(root)?;
|
||||
match credentials {
|
||||
Credentials::Interactive => {}
|
||||
Credentials::Saved => suppress_credential_prompts(&mut cmd),
|
||||
}
|
||||
cmd.args(args).envs(env.iter().copied());
|
||||
let refresh = IndexRefresh::before(root, args, env);
|
||||
let mut session = CommandSession::start(&mut cmd);
|
||||
let out = capture_command(cmd, stdin, cancel, max, "git")?;
|
||||
session.finish(out.code == Some(0), &String::from_utf8_lossy(&out.stderr));
|
||||
refresh.after();
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub(crate) fn capture_command(
|
||||
mut cmd: Command,
|
||||
stdin: Option<&[u8]>,
|
||||
cancel: &CancellationToken,
|
||||
max: usize,
|
||||
program: &str,
|
||||
) -> IdeResult<Output> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let overflow = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
own_group(&mut cmd);
|
||||
cmd.stdin(if stdin.is_some() { Stdio::piped() } else { Stdio::null() })
|
||||
let mut cmd = command(root)?;
|
||||
cmd.args(args)
|
||||
.stdin(if stdin.is_some() { Stdio::piped() } else { Stdio::null() })
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped());
|
||||
let mut child = cmd.spawn().map_err(|error| {
|
||||
if error.kind() == std::io::ErrorKind::NotFound {
|
||||
IdeError::unavailable(format!("could not run {program}: {error}"))
|
||||
} else {
|
||||
error.into()
|
||||
}
|
||||
})?;
|
||||
own_group(&mut cmd);
|
||||
let refresh = IndexRefresh::before(root, args, &[]);
|
||||
let mut session = CommandSession::start(&mut cmd);
|
||||
let mut child = cmd.spawn().map_err(spawn_error)?;
|
||||
let writer = match (stdin, child.stdin.take()) {
|
||||
(Some(data), Some(mut pipe)) => {
|
||||
let data = data.to_vec();
|
||||
@@ -678,7 +576,7 @@ pub(crate) fn capture_command(
|
||||
return Err(if cancel.is_cancelled() {
|
||||
IdeError::cancelled()
|
||||
} else {
|
||||
IdeError::invalid(format!("{program} output exceeds {max} bytes"))
|
||||
IdeError::invalid(format!("git output exceeds {max} bytes"))
|
||||
});
|
||||
}
|
||||
if let Some(status) = child.try_wait()? {
|
||||
@@ -690,14 +588,13 @@ pub(crate) fn capture_command(
|
||||
let _ = w.join();
|
||||
}
|
||||
let join = |thread: std::thread::JoinHandle<std::io::Result<Vec<u8>>>| {
|
||||
thread
|
||||
.join()
|
||||
.map_err(|_| IdeError::internal(format!("{program} output reader panicked")))?
|
||||
.map_err(IdeError::from)
|
||||
thread.join().map_err(|_| IdeError::internal("git output reader panicked"))?.map_err(IdeError::from)
|
||||
};
|
||||
let out = Output { stdout: join(stdout)?, stderr: join(stderr)?, code: status.code() };
|
||||
session.finish(status.success(), &String::from_utf8_lossy(&out.stderr));
|
||||
refresh.after();
|
||||
if out.stdout.len() > max || out.stderr.len() > max {
|
||||
return Err(IdeError::invalid(format!("{program} output exceeds {max} bytes")));
|
||||
return Err(IdeError::invalid(format!("git output exceeds {max} bytes")));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
@@ -793,29 +690,6 @@ pub(crate) fn run_streaming(
|
||||
run_streaming_env(root, args, &[], cancel, on_output)
|
||||
}
|
||||
|
||||
/// Also feeds machine-readable stdout to the caller, separately from progress and stderr.
|
||||
pub(crate) fn run_streaming_stdout(
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
stdout: &mut dyn FnMut(&str),
|
||||
) -> IdeResult<()> {
|
||||
run_streaming_command(root, args, &[], &|| cancel.is_cancelled(), on_output, (Stream::Stdout, stdout), false)
|
||||
}
|
||||
|
||||
/// Also feeds Git's ref status lines on stderr to the caller.
|
||||
pub(crate) fn run_streaming_stderr(
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
stderr: &mut dyn FnMut(&str),
|
||||
silent: bool,
|
||||
) -> IdeResult<()> {
|
||||
run_streaming_command(root, args, &[], &|| cancel.is_cancelled(), on_output, (Stream::Stderr, stderr), silent)
|
||||
}
|
||||
|
||||
/// [`run_streaming`] with extra environment variables (e.g. a sequence editor).
|
||||
pub(crate) fn run_streaming_env(
|
||||
root: &Path,
|
||||
@@ -824,39 +698,13 @@ pub(crate) fn run_streaming_env(
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
run_streaming_env_until(root, args, env, &|| cancel.is_cancelled(), on_output)
|
||||
}
|
||||
|
||||
/// Like `run_streaming_env`, with a predicate for sessions that can stop cooperatively.
|
||||
pub(crate) fn run_streaming_env_until(
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
env: &[(&str, &std::ffi::OsStr)],
|
||||
should_cancel: &dyn Fn() -> bool,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
run_streaming_command(root, args, env, should_cancel, on_output, (Stream::Stdout, &mut |_| {}), false)
|
||||
}
|
||||
|
||||
fn run_streaming_command(
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
env: &[(&str, &std::ffi::OsStr)],
|
||||
should_cancel: &dyn Fn() -> bool,
|
||||
on_output: &dyn Fn(String),
|
||||
(capture_stream, capture): (Stream, &mut dyn FnMut(&str)),
|
||||
silent: bool,
|
||||
) -> IdeResult<()> {
|
||||
if should_cancel() {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let mut cmd = command(root)?;
|
||||
for (k, v) in env {
|
||||
cmd.env(k, v);
|
||||
}
|
||||
if silent {
|
||||
suppress_credential_prompts(&mut cmd);
|
||||
}
|
||||
cmd.args(args).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
own_group(&mut cmd);
|
||||
tracing::debug!(?args, "git (streaming)");
|
||||
@@ -873,12 +721,12 @@ fn run_streaming_command(
|
||||
}
|
||||
drop(tx);
|
||||
|
||||
// Keep the tail of stderr and machine-readable failures from stdout.
|
||||
// Keep the tail of stderr (and stdout conflict reports) for the error message.
|
||||
let mut stderr_tail: Vec<String> = Vec::new();
|
||||
let mut diagnostics: Vec<String> = Vec::new();
|
||||
let mut conflicts: Vec<String> = Vec::new();
|
||||
let mut open = readers.len();
|
||||
while open > 0 {
|
||||
if should_cancel() {
|
||||
if cancel.is_cancelled() {
|
||||
terminate_tree(&mut child, KILL_GRACE);
|
||||
for r in readers {
|
||||
let _ = r.join();
|
||||
@@ -887,18 +735,13 @@ fn run_streaming_command(
|
||||
}
|
||||
match rx.recv_timeout(Duration::from_millis(40)) {
|
||||
Ok(Event::Line(stream, line)) => {
|
||||
if stream == capture_stream {
|
||||
capture(&line);
|
||||
}
|
||||
if stream == Stream::Stderr {
|
||||
stderr_tail.push(line.clone());
|
||||
if stderr_tail.len() > 40 {
|
||||
stderr_tail.remove(0);
|
||||
}
|
||||
} else if (line.starts_with("CONFLICT") || (args.first() == Some(&"push") && line.starts_with("!\t")))
|
||||
&& diagnostics.len() < 40
|
||||
{
|
||||
diagnostics.push(line.clone());
|
||||
} else if line.starts_with("CONFLICT") && conflicts.len() < 40 {
|
||||
conflicts.push(line.clone());
|
||||
}
|
||||
on_output(line);
|
||||
}
|
||||
@@ -912,7 +755,7 @@ fn run_streaming_command(
|
||||
if let Some(status) = child.try_wait()? {
|
||||
break status;
|
||||
}
|
||||
if should_cancel() {
|
||||
if cancel.is_cancelled() {
|
||||
terminate_tree(&mut child, KILL_GRACE);
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
@@ -926,7 +769,7 @@ fn run_streaming_command(
|
||||
return Ok(());
|
||||
}
|
||||
let relevant: Vec<&str> =
|
||||
diagnostics.iter().chain(stderr_tail.iter()).map(String::as_str).filter(|l| !is_progress_line(l)).collect();
|
||||
conflicts.iter().chain(stderr_tail.iter()).map(String::as_str).filter(|l| !is_progress_line(l)).collect();
|
||||
let msg = relevant.join("\n");
|
||||
session.finish(false, &stderr_tail.join("\n"));
|
||||
Err(failure(args, msg.as_bytes(), b"", status.code()))
|
||||
|
||||
@@ -1,650 +0,0 @@
|
||||
use crate::{Repo, cherry_pick_plan, cli, ops};
|
||||
use ide_core::workflow_settings::EmptyCherryPickAction;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, IpcPath};
|
||||
use notify::event::{MetadataKind, ModifyKind};
|
||||
use notify::{RecommendedWatcher, RecursiveMode, Watcher};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::BTreeSet;
|
||||
use std::fs::File;
|
||||
use std::io::Read;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
const MESSAGE_LIMIT: usize = 1 << 20;
|
||||
const PREPARED_MESSAGE_FILES: [&str; 2] = ["SQUASH_MSG", "MERGE_MSG"];
|
||||
const APPLY_HEADS: [(CommitApplyKind, &str); 2] =
|
||||
[(CommitApplyKind::CherryPick, "CHERRY_PICK_HEAD"), (CommitApplyKind::Revert, "REVERT_HEAD")];
|
||||
|
||||
fn apply_changed() -> IdeError {
|
||||
IdeError::invalid("The Git operation changed. Review the current changes and try again.")
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CommitMessages {
|
||||
pub template: Option<String>,
|
||||
pub prepared: Option<String>,
|
||||
#[serde(default)]
|
||||
pub pending_apply: Option<PendingCommitApply>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize, Type)]
|
||||
#[serde(rename_all = "kebab-case")]
|
||||
pub enum CommitApplyKind {
|
||||
#[default]
|
||||
CherryPick,
|
||||
Revert,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CommitApplySource {
|
||||
#[serde(default)]
|
||||
pub kind: CommitApplyKind,
|
||||
pub repo: IpcPath,
|
||||
pub commit: String,
|
||||
pub base: String,
|
||||
pub author: Option<String>,
|
||||
pub author_date: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Type)]
|
||||
pub struct PendingCommitApply {
|
||||
pub source: CommitApplySource,
|
||||
pub paths: Vec<IpcPath>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ApplyCommitReview {
|
||||
pub kind: CommitApplyKind,
|
||||
pub checkpoint: String,
|
||||
pub message: String,
|
||||
pub paths: Vec<IpcPath>,
|
||||
#[serde(default)]
|
||||
pub author: Option<String>,
|
||||
#[serde(default)]
|
||||
pub author_date: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct ApplyCommitOptions {
|
||||
pub author: Option<String>,
|
||||
pub author_date: Option<String>,
|
||||
pub sign_off: bool,
|
||||
pub run_hooks: bool,
|
||||
}
|
||||
|
||||
impl Default for ApplyCommitOptions {
|
||||
fn default() -> Self {
|
||||
Self { author: None, author_date: None, sign_off: false, run_hooks: true }
|
||||
}
|
||||
}
|
||||
|
||||
/// Watches Git-prepared messages and the effective template, including files outside the worktree.
|
||||
pub struct CommitMessageWatch {
|
||||
watcher: RecommendedWatcher,
|
||||
base_files: BTreeSet<PathBuf>,
|
||||
files: Arc<Mutex<BTreeSet<PathBuf>>>,
|
||||
dirs: BTreeSet<PathBuf>,
|
||||
}
|
||||
|
||||
impl CommitMessageWatch {
|
||||
fn new(base_files: BTreeSet<PathBuf>, changed: impl Fn() + Send + 'static) -> IdeResult<Self> {
|
||||
let files = Arc::new(Mutex::new(BTreeSet::<PathBuf>::new()));
|
||||
let watched = files.clone();
|
||||
let watcher = notify::recommended_watcher(move |event: notify::Result<notify::Event>| {
|
||||
if let Ok(event) = event
|
||||
&& (event.need_rescan()
|
||||
|| (!event.kind.is_access()
|
||||
&& event.kind != notify::EventKind::Modify(ModifyKind::Metadata(MetadataKind::AccessTime))
|
||||
&& event.paths.iter().any(|p| {
|
||||
watched.lock().unwrap_or_else(|e| e.into_inner()).iter().any(|f| f.starts_with(p))
|
||||
})))
|
||||
{
|
||||
changed();
|
||||
}
|
||||
})
|
||||
.map_err(|e| IdeError::internal(format!("Git commit message watcher: {e}")))?;
|
||||
let mut watch = Self { watcher, base_files, files, dirs: BTreeSet::new() };
|
||||
watch.replace_files(BTreeSet::new());
|
||||
Ok(watch)
|
||||
}
|
||||
|
||||
fn replace_files(&mut self, paths: BTreeSet<PathBuf>) -> bool {
|
||||
let mut files = BTreeSet::new();
|
||||
let mut dirs = BTreeSet::new();
|
||||
for path in self.base_files.iter().chain(&paths) {
|
||||
// Track both a symlink's name and the file it resolves to. Watching the nearest
|
||||
// existing directory also catches a missing template or config appearing later.
|
||||
for file in [watch_path(path), dunce::canonicalize(path).ok()].into_iter().flatten() {
|
||||
if let Some(dir) = file.ancestors().skip(1).find(|dir| dir.is_dir()) {
|
||||
dirs.insert(dir.to_path_buf());
|
||||
files.insert(file);
|
||||
}
|
||||
}
|
||||
}
|
||||
let changed = {
|
||||
let mut watched = self.files.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let changed = *watched != files || self.dirs != dirs;
|
||||
*watched = files;
|
||||
changed
|
||||
};
|
||||
for dir in self.dirs.difference(&dirs) {
|
||||
let _ = self.watcher.unwatch(dir);
|
||||
}
|
||||
dirs.retain(|dir| {
|
||||
self.dirs.contains(dir)
|
||||
|| self
|
||||
.watcher
|
||||
.watch(dir, RecursiveMode::NonRecursive)
|
||||
.map_err(|e| {
|
||||
tracing::debug!("Git commit message watcher {}: {e}", dir.display());
|
||||
})
|
||||
.is_ok()
|
||||
});
|
||||
self.dirs = dirs;
|
||||
changed
|
||||
}
|
||||
}
|
||||
|
||||
fn watch_path(path: &Path) -> Option<PathBuf> {
|
||||
let parent = path.parent()?.ancestors().find(|p| p.is_dir())?;
|
||||
Some(dunce::canonicalize(parent).ok()?.join(path.strip_prefix(parent).ok()?))
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct MessageConfig {
|
||||
configured: bool,
|
||||
encoding: Option<String>,
|
||||
comment: Option<String>,
|
||||
files: BTreeSet<PathBuf>,
|
||||
}
|
||||
|
||||
impl MessageConfig {
|
||||
fn parse(root: &Path, bytes: &[u8]) -> Self {
|
||||
let mut config = Self::default();
|
||||
let mut fields = bytes.split(|byte| *byte == 0);
|
||||
while let (Some(origin), Some(entry)) = (fields.next(), fields.next()) {
|
||||
let source = origin.strip_prefix(b"file:").map(|path| root.join(String::from_utf8_lossy(path).as_ref()));
|
||||
config.files.extend(source.iter().cloned());
|
||||
let entry = String::from_utf8_lossy(entry);
|
||||
let (key, value) = entry.split_once('\n').unwrap_or((&entry, ""));
|
||||
match key {
|
||||
"commit.template" => config.configured = !value.is_empty(),
|
||||
"i18n.commitencoding" => config.encoding = Some(value.to_owned()),
|
||||
"core.commentchar" | "core.commentstring" => config.comment = Some(value.to_owned()),
|
||||
key if key == "include.path" || (key.starts_with("includeif.") && key.ends_with(".path")) => {
|
||||
// Git only reports origins that produced entries. Keep watching an include
|
||||
// even when its file is empty or has yet to be created.
|
||||
if let Some(path) = include_path(source.as_deref(), value) {
|
||||
config.files.insert(path);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
config
|
||||
}
|
||||
}
|
||||
|
||||
fn include_path(source: Option<&Path>, value: &str) -> Option<PathBuf> {
|
||||
if value.is_empty() {
|
||||
return None;
|
||||
}
|
||||
if let Some(relative) = value.strip_prefix("~/") {
|
||||
return Some(gix::path::env::home_dir()?.join(relative));
|
||||
}
|
||||
let path = Path::new(value);
|
||||
if path.is_absolute() {
|
||||
return Some(path.to_path_buf());
|
||||
}
|
||||
Some(source?.parent()?.join(path))
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
pub fn watch_commit_messages(
|
||||
&self,
|
||||
cancel: &CancellationToken,
|
||||
changed: impl Fn() + Send + 'static,
|
||||
) -> IdeResult<CommitMessageWatch> {
|
||||
let _scope = self.execution_scope();
|
||||
let [git_dir, common_dir] = self.metadata_dirs()?;
|
||||
let mut files =
|
||||
BTreeSet::from([git_dir.join("HEAD"), git_dir.join("config.worktree"), common_dir.join("config")]);
|
||||
files.extend(PREPARED_MESSAGE_FILES.map(|name| git_dir.join(name)));
|
||||
files.extend(APPLY_HEADS.map(|(_, name)| git_dir.join(name)));
|
||||
for variable in ["GIT_CONFIG_GLOBAL", "GIT_CONFIG_SYSTEM"] {
|
||||
if let Ok(out) = cli::run_bounded(self.root(), &["var", variable], cancel, 65536) {
|
||||
files.extend(out.stdout_str().lines().filter(|line| !line.is_empty()).map(PathBuf::from));
|
||||
}
|
||||
}
|
||||
CommitMessageWatch::new(files, changed)
|
||||
}
|
||||
|
||||
pub fn commit_messages(
|
||||
&self,
|
||||
watch: &mut CommitMessageWatch,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<CommitMessages> {
|
||||
// Read again after installing newly discovered watches. This closes the gap between
|
||||
// reading the configuration and observing changes to a newly configured template.
|
||||
let (mut config, mut path) = self.commit_message_config(cancel)?;
|
||||
if set_template_paths(watch, &config, path.as_deref()) {
|
||||
(config, path) = self.commit_message_config(cancel)?;
|
||||
set_template_paths(watch, &config, path.as_deref());
|
||||
}
|
||||
let template = path.and_then(|path| read_message(&path, &config, false));
|
||||
let prepared = PREPARED_MESSAGE_FILES
|
||||
.iter()
|
||||
.filter_map(|file| read_message(&self.git_dir.join(file), &config, true))
|
||||
.collect::<Vec<_>>();
|
||||
let prepared = (!prepared.is_empty()).then(|| prepared.join("\n\n"));
|
||||
let pending_apply = prepared.as_ref().and_then(|_| self.pending_apply(cancel));
|
||||
Ok(CommitMessages { template, prepared, pending_apply })
|
||||
}
|
||||
|
||||
fn pending_apply(&self, cancel: &CancellationToken) -> Option<PendingCommitApply> {
|
||||
let _scope = self.execution_scope();
|
||||
let (kind, marker, revision) = self.apply_head()?;
|
||||
let commit = gix::ObjectId::from_hex(revision.as_bytes()).ok()?.to_string();
|
||||
let (_, base) = self.head().ok()?;
|
||||
let base = base?;
|
||||
let (author, author_date) = self.apply_author(kind, &commit, cancel);
|
||||
let index = cli::run_bounded(
|
||||
self.root(),
|
||||
&["diff", "--cached", "--name-only", "-z", "--no-renames", "--no-ext-diff", "--no-relative", &base, "--"],
|
||||
cancel,
|
||||
4 << 20,
|
||||
)
|
||||
.ok()?;
|
||||
// Git starts these operations with a clean index. The cached paths include both
|
||||
// applied and unmerged changes, leaving pre-existing unstaged changes alone.
|
||||
let paths = index
|
||||
.stdout
|
||||
.split(|byte| *byte == 0)
|
||||
.filter(|path| !path.is_empty())
|
||||
.map(|path| IpcPath(self.root().join(String::from_utf8_lossy(path).as_ref())))
|
||||
.collect();
|
||||
if read_message(&marker, &MessageConfig::default(), false).as_deref() != Some(&revision)
|
||||
|| self.head().ok()?.1.as_deref() != Some(&base)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
Some(PendingCommitApply {
|
||||
source: CommitApplySource {
|
||||
kind,
|
||||
repo: IpcPath(self.root().to_path_buf()),
|
||||
commit,
|
||||
base,
|
||||
author,
|
||||
author_date,
|
||||
},
|
||||
paths,
|
||||
})
|
||||
}
|
||||
|
||||
fn apply_head(&self) -> Option<(CommitApplyKind, PathBuf, String)> {
|
||||
APPLY_HEADS.into_iter().find_map(|(kind, name)| {
|
||||
let marker = self.git_dir.join(name);
|
||||
let revision = read_message(&marker, &MessageConfig::default(), false)?;
|
||||
Some((kind, marker, revision))
|
||||
})
|
||||
}
|
||||
|
||||
/// The staged changes Git would commit after a cherry-pick or revert stopped.
|
||||
pub fn review_apply_commit(&self, cancel: &CancellationToken) -> IdeResult<Option<ApplyCommitReview>> {
|
||||
let _scope = self.execution_scope();
|
||||
self.review_apply_index(cancel, &[])
|
||||
}
|
||||
|
||||
pub(crate) fn review_apply_index(
|
||||
&self,
|
||||
cancel: &CancellationToken,
|
||||
env: &[(&str, &std::ffi::OsStr)],
|
||||
) -> IdeResult<Option<ApplyCommitReview>> {
|
||||
let Some((kind, marker, revision)) = self.apply_head() else { return Ok(None) };
|
||||
let (branch, head) = self.head()?;
|
||||
let head = head.ok_or_else(|| IdeError::invalid("Git operation has no current commit"))?;
|
||||
let modified = marker.metadata()?.modified()?;
|
||||
let raw = cli::run_bounded_env(
|
||||
self.root(),
|
||||
&[
|
||||
"diff",
|
||||
"--cached",
|
||||
"--raw",
|
||||
"-z",
|
||||
"--no-abbrev",
|
||||
"--no-renames",
|
||||
"--no-ext-diff",
|
||||
"--no-relative",
|
||||
"--ignore-submodules=none",
|
||||
&head,
|
||||
"--",
|
||||
],
|
||||
cancel,
|
||||
16 << 20,
|
||||
env,
|
||||
)?;
|
||||
let mut paths = Vec::new();
|
||||
let mut fields = raw.stdout.split(|&b| b == 0).filter(|field| !field.is_empty());
|
||||
while let (Some(change), Some(path)) = (fields.next(), fields.next()) {
|
||||
if change.ends_with(b" U") {
|
||||
return Err(IdeError::invalid("Resolve all conflicts before continuing"));
|
||||
}
|
||||
paths.push(IpcPath(self.root().join(String::from_utf8_lossy(path).as_ref())));
|
||||
}
|
||||
if paths.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let (config, _) = self.commit_message_config(cancel)?;
|
||||
let message = read_message(&self.git_dir.join("MERGE_MSG"), &config, true).unwrap_or_default();
|
||||
if self.apply_head().as_ref() != Some(&(kind, marker.clone(), revision.clone()))
|
||||
|| marker.metadata()?.modified()? != modified
|
||||
|| self.head()? != (branch.clone(), Some(head.clone()))
|
||||
{
|
||||
return Err(apply_changed());
|
||||
}
|
||||
let mut digest = blake3::Hasher::new();
|
||||
digest.update(format!("{kind:?}\0{revision}\0{branch:?}\0{head}\0{modified:?}\0{message}\0").as_bytes());
|
||||
digest.update(&raw.stdout);
|
||||
let (author, author_date) = self.apply_author(kind, &revision, cancel);
|
||||
Ok(Some(ApplyCommitReview {
|
||||
kind,
|
||||
checkpoint: digest.finalize().to_hex().to_string(),
|
||||
message,
|
||||
paths,
|
||||
author,
|
||||
author_date,
|
||||
}))
|
||||
}
|
||||
|
||||
pub fn continue_reviewed_apply(
|
||||
&self,
|
||||
checkpoint: &str,
|
||||
message: &str,
|
||||
options: &ApplyCommitOptions,
|
||||
empty_action: EmptyCherryPickAction,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<u32> {
|
||||
let _scope = self.execution_scope();
|
||||
if message.trim().is_empty() || message.contains('\0') || message.len() > MESSAGE_LIMIT {
|
||||
return Err(IdeError::invalid("Invalid commit message"));
|
||||
}
|
||||
ops::continue_op(self, false, |args| {
|
||||
let review = self.require_apply_review(checkpoint, cancel)?;
|
||||
let edited =
|
||||
(message != review.message || *options != ApplyCommitOptions::default()).then_some((message, options));
|
||||
cherry_pick_plan::resume(self, args, edited, empty_action, cancel, out)
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn require_apply_review(
|
||||
&self,
|
||||
checkpoint: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<ApplyCommitReview> {
|
||||
self.review_apply_index(cancel, &[])?.filter(|review| review.checkpoint == checkpoint).ok_or_else(apply_changed)
|
||||
}
|
||||
|
||||
fn apply_author(
|
||||
&self,
|
||||
kind: CommitApplyKind,
|
||||
commit: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> (Option<String>, Option<String>) {
|
||||
if kind == CommitApplyKind::CherryPick
|
||||
&& gix::ObjectId::from_hex(commit.as_bytes()).is_ok()
|
||||
&& let Some((author, date)) = self.commit_author(commit, cancel)
|
||||
{
|
||||
return (Some(author), Some(date));
|
||||
}
|
||||
(None, None)
|
||||
}
|
||||
|
||||
fn commit_author(&self, commit: &str, cancel: &CancellationToken) -> Option<(String, String)> {
|
||||
let raw = cli::run_bounded(
|
||||
self.root(),
|
||||
&["show", "-s", "--no-show-signature", "--format=%an%x00%ae%x00%aI", commit, "--"],
|
||||
cancel,
|
||||
64 << 10,
|
||||
)
|
||||
.ok()?;
|
||||
let text = raw.stdout_str();
|
||||
let mut fields = text.trim_end().split('\0');
|
||||
let author = format!("{} <{}>", fields.next()?, fields.next()?);
|
||||
Some((author, fields.next()?.to_owned()))
|
||||
}
|
||||
|
||||
fn commit_message_config(&self, cancel: &CancellationToken) -> IdeResult<(MessageConfig, Option<PathBuf>)> {
|
||||
let _scope = self.execution_scope();
|
||||
let raw = cli::run_bounded(
|
||||
self.root(),
|
||||
&["config", "--includes", "--show-origin", "--null", "--list"],
|
||||
cancel,
|
||||
4 << 20,
|
||||
)?;
|
||||
let config = MessageConfig::parse(self.root(), &raw.stdout);
|
||||
let path = if config.configured {
|
||||
let raw = cli::run_bounded(
|
||||
self.root(),
|
||||
&["config", "--type=path", "--null", "--get", "commit.template"],
|
||||
cancel,
|
||||
65536,
|
||||
)?;
|
||||
let value = raw.stdout.strip_suffix(&[0]).unwrap_or(&raw.stdout);
|
||||
let path = String::from_utf8_lossy(value);
|
||||
(!path.is_empty() && !path.ends_with('/')).then(|| self.root().join(path.as_ref()))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
Ok((config, path))
|
||||
}
|
||||
}
|
||||
|
||||
fn set_template_paths(watch: &mut CommitMessageWatch, config: &MessageConfig, path: Option<&Path>) -> bool {
|
||||
let mut files = config.files.clone();
|
||||
files.extend(path.map(Path::to_path_buf));
|
||||
watch.replace_files(files)
|
||||
}
|
||||
|
||||
fn read_message(path: &Path, config: &MessageConfig, prepared: bool) -> Option<String> {
|
||||
let mut options = File::options();
|
||||
options.read(true);
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
options.custom_flags(libc::O_NONBLOCK);
|
||||
}
|
||||
let file = options.open(path).ok()?;
|
||||
let metadata = file.metadata().ok()?;
|
||||
if !metadata.is_file() || metadata.len() > MESSAGE_LIMIT as u64 {
|
||||
return None;
|
||||
}
|
||||
let mut bytes = Vec::new();
|
||||
file.take(MESSAGE_LIMIT as u64 + 1).read_to_end(&mut bytes).ok()?;
|
||||
if bytes.len() > MESSAGE_LIMIT {
|
||||
return None;
|
||||
}
|
||||
let encoding = config
|
||||
.encoding
|
||||
.as_deref()
|
||||
.and_then(|label| encoding_rs::Encoding::for_label(label.as_bytes()))
|
||||
.unwrap_or(encoding_rs::UTF_8);
|
||||
let (text, _, _) = encoding.decode(&bytes);
|
||||
let comment = config.comment.as_deref().filter(|prefix| !prefix.is_empty() && *prefix != "auto").unwrap_or("#");
|
||||
let message = text
|
||||
.lines()
|
||||
.filter(|line| !(line.starts_with(comment) || prepared && line.starts_with('\u{1}')))
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
let message = message.trim();
|
||||
(!message.is_empty()).then(|| message.to_owned())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::fs;
|
||||
use std::process::Command;
|
||||
use std::sync::mpsc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn git(root: &Path, args: &[&str]) {
|
||||
let output = Command::new("git").current_dir(root).args(args).output().unwrap();
|
||||
assert!(output.status.success(), "{args:?}: {}", String::from_utf8_lossy(&output.stderr));
|
||||
}
|
||||
|
||||
fn conflicting_git(root: &Path, args: &[&str]) {
|
||||
let output = Command::new("git").current_dir(root).args(args).output().unwrap();
|
||||
assert_eq!(output.status.code(), Some(1), "{args:?}: {}", String::from_utf8_lossy(&output.stderr));
|
||||
assert!(String::from_utf8_lossy(&output.stdout).contains("CONFLICT"), "{args:?} did not conflict");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn follows_an_included_config_and_a_template_outside_the_repository() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("repo");
|
||||
fs::create_dir(&root).unwrap();
|
||||
git(&root, &["init", "-q"]);
|
||||
let include = tmp.path().join("template.gitconfig");
|
||||
let template = tmp.path().join("commit message.txt");
|
||||
let template_arg = template.to_str().unwrap();
|
||||
let include_arg = include.to_str().unwrap();
|
||||
git(&root, &["config", "--file", include_arg, "commit.template", template_arg]);
|
||||
git(&root, &["config", "--file", include_arg, "i18n.commitEncoding", "windows-1252"]);
|
||||
git(&root, &["config", "--file", include_arg, "core.commentChar", ";"]);
|
||||
git(&root, &["config", "--add", "include.path", "../../template.gitconfig"]);
|
||||
fs::write(&template, b"R\xe9sum\xe9\r\n; instructions\r\n# Keep this").unwrap();
|
||||
|
||||
let repo = Repo::discover(&root).unwrap().unwrap();
|
||||
let token = CancellationToken::new();
|
||||
let (tx, rx) = mpsc::channel();
|
||||
let mut watch = repo
|
||||
.watch_commit_messages(&token, move || {
|
||||
let _ = tx.send(());
|
||||
})
|
||||
.unwrap();
|
||||
let message = repo.commit_messages(&mut watch, &token).unwrap().template;
|
||||
assert_eq!(message.as_deref(), Some("Résumé\n# Keep this"));
|
||||
|
||||
let mut expect_update = |expected: Option<&str>| {
|
||||
let deadline = Instant::now() + Duration::from_secs(8);
|
||||
loop {
|
||||
rx.recv_timeout(deadline.saturating_duration_since(Instant::now()))
|
||||
.expect("template watcher did not report the change");
|
||||
let message = repo.commit_messages(&mut watch, &token).unwrap().template;
|
||||
if message.as_deref() == expected {
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
fs::write(&template, "Updated").unwrap();
|
||||
expect_update(Some("Updated"));
|
||||
fs::remove_file(&template).unwrap();
|
||||
expect_update(None);
|
||||
fs::write(&template, "Restored").unwrap();
|
||||
expect_update(Some("Restored"));
|
||||
fs::write(root.join("local template"), "Local template").unwrap();
|
||||
git(&root, &["config", "--file", include_arg, "commit.template", "local template"]);
|
||||
expect_update(Some("Local template"));
|
||||
fs::write(&include, "").unwrap();
|
||||
expect_update(None);
|
||||
git(&root, &["config", "--file", include_arg, "commit.template", "local template"]);
|
||||
expect_update(Some("Local template"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn follows_prepared_messages_in_the_linked_git_directory() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let main = tmp.path().join("main");
|
||||
let linked = tmp.path().join("linked");
|
||||
fs::create_dir(&main).unwrap();
|
||||
git(&main, &["init", "-q", "-b", "main"]);
|
||||
for (key, value) in [
|
||||
("user.name", "Fixture"),
|
||||
("user.email", "[email protected]"),
|
||||
("commit.gpgsign", "false"),
|
||||
("core.commentChar", ";"),
|
||||
("core.autocrlf", "false"),
|
||||
] {
|
||||
git(&main, &["config", "--local", key, value]);
|
||||
}
|
||||
fs::write(main.join("notes.txt"), "base\n").unwrap();
|
||||
fs::write(main.join("local.txt"), "untouched\n").unwrap();
|
||||
git(&main, &["add", "notes.txt", "local.txt"]);
|
||||
git(&main, &["commit", "-qm", "Base notes"]);
|
||||
git(&main, &["switch", "-qc", "incoming"]);
|
||||
fs::write(main.join("notes.txt"), "incoming\n").unwrap();
|
||||
git(&main, &["commit", "-qam", "Incoming notes"]);
|
||||
git(&main, &["worktree", "add", "-qb", "workspace", linked.to_str().unwrap(), "main"]);
|
||||
fs::write(linked.join("notes.txt"), "local\n").unwrap();
|
||||
git(&linked, &["commit", "-qam", "Local notes"]);
|
||||
|
||||
let repo = Repo::discover(&linked).unwrap().unwrap();
|
||||
let [git_dir, common_dir] = repo.metadata_dirs().unwrap();
|
||||
assert_ne!(git_dir, common_dir);
|
||||
let token = CancellationToken::new();
|
||||
let (tx, rx) = mpsc::channel();
|
||||
let mut watch = repo
|
||||
.watch_commit_messages(&token, move || {
|
||||
let _ = tx.send(());
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(repo.commit_messages(&mut watch, &token).unwrap().prepared, None);
|
||||
let mut expect_update = |subject: Option<&str>| {
|
||||
let deadline = Instant::now() + Duration::from_secs(8);
|
||||
loop {
|
||||
rx.recv_timeout(deadline.saturating_duration_since(Instant::now()))
|
||||
.expect("prepared message watcher did not report the change");
|
||||
let message = repo.commit_messages(&mut watch, &token).unwrap().prepared;
|
||||
if message.as_deref().and_then(|m| m.lines().next()) == subject {
|
||||
return message;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
conflicting_git(&linked, &["merge", "incoming"]);
|
||||
let merge = expect_update(Some("Merge branch 'incoming' into workspace")).unwrap();
|
||||
assert!(!merge.contains("Conflicts:") && !merge.contains("notes.txt"));
|
||||
fs::write(git_dir.join("MERGE_MSG"), "Message edited on disk\n; Conflicts:\n").unwrap();
|
||||
assert_eq!(expect_update(Some("Message edited on disk")).as_deref(), Some("Message edited on disk"));
|
||||
git(&linked, &["merge", "--abort"]);
|
||||
expect_update(None);
|
||||
|
||||
fs::write(linked.join("local.txt"), "unrelated local edit\n").unwrap();
|
||||
conflicting_git(&linked, &["cherry-pick", "incoming"]);
|
||||
expect_update(Some("Incoming notes"));
|
||||
let mut read = repo.watch_commit_messages(&token, || {}).unwrap();
|
||||
let pending = repo.commit_messages(&mut read, &token).unwrap().pending_apply.unwrap();
|
||||
assert_eq!(pending.source.kind, CommitApplyKind::CherryPick);
|
||||
assert_eq!(pending.source.author.as_deref(), Some("Fixture <[email protected]>"));
|
||||
assert_eq!(pending.source.base, repo.head().unwrap().1.unwrap());
|
||||
assert_eq!(pending.paths, [IpcPath(repo.root().join("notes.txt"))]);
|
||||
git(&linked, &["cherry-pick", "--abort"]);
|
||||
expect_update(None);
|
||||
assert!(repo.commit_messages(&mut read, &token).unwrap().pending_apply.is_none());
|
||||
|
||||
conflicting_git(&linked, &["revert", "--no-edit", "incoming"]);
|
||||
expect_update(Some("Revert \"Incoming notes\""));
|
||||
let pending = repo.commit_messages(&mut read, &token).unwrap().pending_apply.unwrap();
|
||||
assert_eq!(pending.source.kind, CommitApplyKind::Revert);
|
||||
assert_eq!(pending.source.author, None);
|
||||
assert_eq!(pending.source.author_date, None);
|
||||
assert_eq!(pending.paths, [IpcPath(repo.root().join("notes.txt"))]);
|
||||
git(&linked, &["revert", "--abort"]);
|
||||
expect_update(None);
|
||||
assert!(repo.commit_messages(&mut read, &token).unwrap().pending_apply.is_none());
|
||||
|
||||
conflicting_git(&linked, &["merge", "--squash", "incoming"]);
|
||||
let squash = expect_update(Some("Squashed commit of the following:")).unwrap();
|
||||
assert!(squash.contains("Incoming notes"));
|
||||
fs::write(git_dir.join("MERGE_MSG"), "Extra context\n; Conflicts:\n").unwrap();
|
||||
assert!(expect_update(Some("Squashed commit of the following:")).is_some());
|
||||
let prepared = repo.commit_messages(&mut watch, &token).unwrap().prepared.unwrap();
|
||||
assert!(prepared.ends_with("\n\nExtra context"));
|
||||
}
|
||||
}
|
||||
@@ -1,569 +0,0 @@
|
||||
//! Editing a commit and replaying its descendants.
|
||||
|
||||
use crate::cli::{TempIndex, failure, run, run_env, run_raw};
|
||||
use crate::repo::{absolute, gx, resolve};
|
||||
use crate::{AmendTarget, CommitOptions, HeadChange, HistoryTip, Repo, RewrittenCommit, TextEncoding};
|
||||
use gix::bstr::ByteSlice;
|
||||
use ide_core::error::ErrorData;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use std::collections::HashSet;
|
||||
use std::ffi::OsStr;
|
||||
use std::fs;
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[derive(Clone)]
|
||||
struct History {
|
||||
head: gix::ObjectId,
|
||||
branch: Option<String>,
|
||||
commits: Vec<String>,
|
||||
}
|
||||
|
||||
impl History {
|
||||
fn load(repo: &Repo, target: &str, expected_head: Option<&HistoryTip>) -> IdeResult<Self> {
|
||||
if repo.branch_info()?.operation.is_some() {
|
||||
return Err(IdeError::invalid("cannot rewrite history while a Git operation is in progress"));
|
||||
}
|
||||
let objects = repo.gix()?;
|
||||
let head = objects.head().map_err(gx)?;
|
||||
let branch = head.referent_name().map(|name| name.as_bstr().to_string());
|
||||
let head = head.id().ok_or_else(|| IdeError::invalid("there is no commit to edit"))?.detach();
|
||||
if expected_head.is_some_and(|expected| {
|
||||
let current_branch = branch.as_deref().and_then(|name| name.strip_prefix("refs/heads/"));
|
||||
gix::ObjectId::from_hex(expected.commit.as_bytes()).ok() != Some(head)
|
||||
|| expected.branch.as_deref() != current_branch
|
||||
}) {
|
||||
return Err(IdeError::invalid("the branch has changed since the selection was made"));
|
||||
}
|
||||
let commit = objects.find_object(resolve(&objects, target)?).map_err(gx)?.peel_to_commit().map_err(gx)?;
|
||||
if commit.parent_ids().count() > 1 {
|
||||
return Err(IdeError::invalid("cannot rewrite a merge commit"));
|
||||
}
|
||||
let target = commit.id.to_string();
|
||||
if run_raw(repo.root(), &["merge-base", "--is-ancestor", &target, &head.to_string()], None)?.code != Some(0) {
|
||||
return Err(IdeError::invalid("the commit is not in the current branch"));
|
||||
}
|
||||
let range = format!("{target}..{head}");
|
||||
let listed = run(repo.root(), &["rev-list", "--reverse", "--topo-order", "--parents", &range], None)?;
|
||||
let mut commits = vec![target];
|
||||
for line in listed.stdout_str().lines() {
|
||||
let ids: Vec<&str> = line.split_whitespace().collect();
|
||||
if ids.len() != 2 || ids[1] != commits.last().unwrap() {
|
||||
return Err(IdeError::invalid("the commits after this one are not a linear history"));
|
||||
}
|
||||
commits.push(ids[0].to_string());
|
||||
}
|
||||
Ok(Self { head, branch, commits })
|
||||
}
|
||||
|
||||
fn ensure_current(&self, repo: &Repo) -> IdeResult<()> {
|
||||
let objects = repo.gix()?;
|
||||
let head = objects.head().map_err(gx)?;
|
||||
if head.referent_name().map(|name| name.as_bstr().to_str_lossy()).as_deref() != self.branch.as_deref()
|
||||
|| head.id().is_none_or(|id| id.detach() != self.head)
|
||||
|| repo.branch_info()?.operation.is_some()
|
||||
{
|
||||
return Err(IdeError::invalid("the branch has changed since the selection was made"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn rewrite_descendants(self, repo: &Repo, mut parent: String, reason: &str) -> IdeResult<HeadChange> {
|
||||
for id in &self.commits[1..] {
|
||||
let commit = Commit::read(repo, id)?;
|
||||
parent = commit.write(repo, &commit.tree, Some(&parent), None)?;
|
||||
}
|
||||
self.ensure_current(repo)?;
|
||||
let before = self.head.to_string();
|
||||
self.move_tip(repo, &before, &parent, reason)?;
|
||||
Ok(HeadChange { before, after: parent })
|
||||
}
|
||||
|
||||
fn move_tip(&self, repo: &Repo, from: &str, to: &str, reason: &str) -> IdeResult<()> {
|
||||
run(
|
||||
repo.root(),
|
||||
&["update-ref", "--no-deref", "-m", reason, self.branch.as_deref().unwrap_or("HEAD"), to, from],
|
||||
None,
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn publish_amend(
|
||||
&self,
|
||||
repo: &Repo,
|
||||
index: Option<&[u8]>,
|
||||
paths: &[u8],
|
||||
commit: &str,
|
||||
reason: &str,
|
||||
) -> IdeResult<()> {
|
||||
let index_path = repo.gix()?.index_path();
|
||||
let updated = index_after_amend(repo, index, paths, commit)?;
|
||||
let mut lock =
|
||||
gix::lock::File::acquire_to_update_resource(&index_path, gix::lock::acquire::Fail::Immediately, None, 0)
|
||||
.map_err(gx)?;
|
||||
if read_index(&index_path)?.as_deref() != index {
|
||||
return Err(IdeError::invalid("the index changed while the commit was being amended"));
|
||||
}
|
||||
if let Some(updated) = &updated {
|
||||
lock.with_mut(|out| {
|
||||
out.write_all(updated)?;
|
||||
if let Ok(metadata) = fs::metadata(&index_path) {
|
||||
out.set_permissions(metadata.permissions())?;
|
||||
}
|
||||
out.sync_all()
|
||||
})?;
|
||||
}
|
||||
self.ensure_current(repo)?;
|
||||
let before = self.head.to_string();
|
||||
self.move_tip(repo, &before, commit, reason)?;
|
||||
if updated.is_some()
|
||||
&& let Err(error) = lock.commit()
|
||||
{
|
||||
self.move_tip(repo, commit, &before, "restore tip after amend index write failed")?;
|
||||
return Err(gx(error));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
struct Commit {
|
||||
tree: String,
|
||||
parent: Option<String>,
|
||||
author: String,
|
||||
encoding: Option<String>,
|
||||
data: Vec<u8>,
|
||||
message_start: usize,
|
||||
}
|
||||
|
||||
impl Commit {
|
||||
fn read(repo: &Repo, id: &str) -> IdeResult<Self> {
|
||||
let data = run(repo.root(), &["cat-file", "commit", id], None)?.stdout;
|
||||
let header_end = data.find(b"\n\n").ok_or_else(|| IdeError::invalid("invalid commit data"))?;
|
||||
let headers = data[..header_end].to_str_lossy();
|
||||
let header = |prefix| headers.lines().find_map(|line| line.strip_prefix(prefix)).map(str::to_owned);
|
||||
let tree = header("tree ").ok_or_else(|| IdeError::invalid("commit has no tree"))?;
|
||||
let author = header("author ").ok_or_else(|| IdeError::invalid("commit has no author"))?;
|
||||
Ok(Self {
|
||||
tree,
|
||||
parent: header("parent "),
|
||||
author,
|
||||
encoding: header("encoding "),
|
||||
data,
|
||||
message_start: header_end + 2,
|
||||
})
|
||||
}
|
||||
|
||||
fn write(&self, repo: &Repo, tree: &str, parent: Option<&str>, new_message: Option<&str>) -> IdeResult<String> {
|
||||
let (message, encoding) =
|
||||
new_message.map_or_else(|| (self.message(), self.encoding()), |message| (message.as_bytes(), "UTF-8"));
|
||||
Self::write_commit(repo, tree, parent, message, encoding, self.identity())
|
||||
}
|
||||
|
||||
fn identity(&self) -> (&str, &str, &str) {
|
||||
let (name, rest) = self.author.split_once(" <").unwrap_or((&self.author, ""));
|
||||
let (email, date) = rest.split_once("> ").unwrap_or((rest, ""));
|
||||
(name, email, date)
|
||||
}
|
||||
|
||||
fn write_commit(
|
||||
repo: &Repo,
|
||||
tree: &str,
|
||||
parent: Option<&str>,
|
||||
message: &[u8],
|
||||
encoding: &str,
|
||||
author: (&str, &str, &str),
|
||||
) -> IdeResult<String> {
|
||||
let (name, email, date) = author;
|
||||
let env = [
|
||||
("GIT_AUTHOR_NAME", OsStr::new(name)),
|
||||
("GIT_AUTHOR_EMAIL", OsStr::new(email)),
|
||||
("GIT_AUTHOR_DATE", OsStr::new(date)),
|
||||
];
|
||||
let encoding = format!("i18n.commitEncoding={encoding}");
|
||||
let mut args = vec!["-c", &encoding, "commit-tree", tree];
|
||||
if let Some(parent) = parent {
|
||||
args.extend(["-p", parent]);
|
||||
}
|
||||
Ok(run_env(repo.root(), &args, Some(message), &env)?.stdout_str().trim().to_string())
|
||||
}
|
||||
|
||||
fn message(&self) -> &[u8] {
|
||||
&self.data[self.message_start..]
|
||||
}
|
||||
|
||||
fn encoding(&self) -> &str {
|
||||
self.encoding.as_deref().unwrap_or("UTF-8")
|
||||
}
|
||||
}
|
||||
|
||||
fn new_message(message: &str) -> IdeResult<String> {
|
||||
let message = message.trim();
|
||||
if message.is_empty() {
|
||||
return Err(IdeError::invalid("commit message is empty"));
|
||||
}
|
||||
Ok(format!("{message}\n"))
|
||||
}
|
||||
|
||||
pub(crate) fn reword(repo: &Repo, id: &str, message: &str) -> IdeResult<HeadChange> {
|
||||
let message = new_message(message)?;
|
||||
let history = History::load(repo, id, None)?;
|
||||
let commit = Commit::read(repo, &history.commits[0])?;
|
||||
let rewritten = commit.write(repo, &commit.tree, commit.parent.as_deref(), Some(&message))?;
|
||||
let reason = format!("reword: {}", message.lines().next().unwrap_or_default());
|
||||
history.rewrite_descendants(repo, rewritten, &reason)
|
||||
}
|
||||
|
||||
/// Builds the selected commit in a detached Git directory, using the real
|
||||
/// repository's config, hooks and objects. Only a successful replay changes HEAD.
|
||||
pub(crate) fn amend(
|
||||
repo: &Repo,
|
||||
target: &AmendTarget,
|
||||
message: &str,
|
||||
commit_args: &[&str],
|
||||
options: &CommitOptions,
|
||||
encoding: &dyn Fn(&Path) -> IdeResult<TextEncoding>,
|
||||
) -> IdeResult<String> {
|
||||
let history = History::load(repo, &target.commit, Some(&target.head))?;
|
||||
if history.commits.len() < 2 {
|
||||
return Err(IdeError::invalid("the commit to amend must be older than HEAD"));
|
||||
}
|
||||
let original = &history.commits[0];
|
||||
ensure_unpublished(repo, original, &target.protected_branches)?;
|
||||
let commit = Commit::read(repo, original)?;
|
||||
let before = history.head.to_string();
|
||||
let head = Commit::read(repo, &before)?;
|
||||
let git = repo.gix()?;
|
||||
let index_path = git.index_path();
|
||||
let index = read_index(&index_path)?;
|
||||
let scratch = tempfile::tempdir_in(&repo.git_dir)?;
|
||||
let chosen = TempIndex::new(repo);
|
||||
if let Some(index) = &index {
|
||||
fs::write(chosen.path(), index)?;
|
||||
// Split indexes refer to objects in the original per-worktree Git directory.
|
||||
run_env(repo.root(), &["update-index", "--no-split-index"], None, &chosen.env())?;
|
||||
}
|
||||
fs::write(scratch.path().join("HEAD"), format!("{before}\n"))?;
|
||||
let worktree_config = repo.git_dir.join("config.worktree");
|
||||
if worktree_config.is_file() {
|
||||
fs::copy(worktree_config, scratch.path().join("config.worktree"))?;
|
||||
}
|
||||
let common_dir = absolute(git.common_dir())?;
|
||||
let env = [
|
||||
("GIT_DIR", scratch.path().as_os_str()),
|
||||
("GIT_COMMON_DIR", common_dir.as_os_str()),
|
||||
("GIT_WORK_TREE", repo.root().as_os_str()),
|
||||
("GIT_INDEX_FILE", chosen.path().as_os_str()),
|
||||
];
|
||||
crate::write::fill_commit_index(repo, &env, options, encoding)?;
|
||||
let message = if message.trim().is_empty() { commit.message() } else { message.as_bytes() };
|
||||
run_env(repo.root(), commit_args, Some(message), &env)?;
|
||||
let selected = fs::read_to_string(scratch.path().join("HEAD"))?;
|
||||
let selected = selected.trim();
|
||||
let addition = Commit::read(repo, selected)?;
|
||||
|
||||
let (original_name, original_email, original_date) = commit.identity();
|
||||
let (new_name, new_email, new_date) = addition.identity();
|
||||
let (name, email) = if options.author.as_deref().is_some_and(|a| !a.trim().is_empty()) {
|
||||
(new_name, new_email)
|
||||
} else {
|
||||
(original_name, original_email)
|
||||
};
|
||||
let date = if options.author_date.as_deref().is_some_and(|date| !date.trim().is_empty()) {
|
||||
new_date
|
||||
} else {
|
||||
original_date
|
||||
};
|
||||
let author = (name, email, date);
|
||||
let paths = changed_paths(repo, &before, selected)?;
|
||||
let Some(rewritten) =
|
||||
replay_amend(repo, &history, &commit, &addition, author, selected, head.tree != addition.tree)?
|
||||
else {
|
||||
history.ensure_current(repo)?;
|
||||
let mut message = format!("amend! {original}\n\n").into_bytes();
|
||||
message.extend_from_slice(addition.message());
|
||||
let commit = Commit::write_commit(repo, &addition.tree, Some(&before), &message, addition.encoding(), author)?;
|
||||
let entries = affected_index_entries(repo, &before, index.as_deref(), &paths)?;
|
||||
*repo.amend_recovery.lock().unwrap_or_else(|e| e.into_inner()) =
|
||||
Some(PendingAmend { commit: commit.clone(), history, paths, entries });
|
||||
let mut error = IdeError::invalid("Amending this commit would cause a conflict.");
|
||||
error.data = Some(ErrorData::AmendConflict { commit });
|
||||
return Err(error);
|
||||
};
|
||||
ensure_unpublished(repo, original, &target.protected_branches)?;
|
||||
history.publish_amend(repo, index.as_deref(), &paths, &rewritten, "amend earlier commit")?;
|
||||
Ok(rewritten)
|
||||
}
|
||||
|
||||
fn replay_amend(
|
||||
repo: &Repo,
|
||||
history: &History,
|
||||
commit: &Commit,
|
||||
addition: &Commit,
|
||||
author: (&str, &str, &str),
|
||||
selected: &str,
|
||||
changed: bool,
|
||||
) -> IdeResult<Option<String>> {
|
||||
let tree = if changed {
|
||||
let Some(tree) = merge_onto(repo, &history.head.to_string(), &history.commits[0], selected)? else {
|
||||
return Ok(None);
|
||||
};
|
||||
tree
|
||||
} else {
|
||||
commit.tree.clone()
|
||||
};
|
||||
let mut rewritten =
|
||||
Commit::write_commit(repo, &tree, commit.parent.as_deref(), addition.message(), addition.encoding(), author)?;
|
||||
let mut final_tree = tree;
|
||||
for pair in history.commits.windows(2) {
|
||||
let next = Commit::read(repo, &pair[1])?;
|
||||
final_tree = if changed && next.tree != final_tree {
|
||||
let Some(tree) = merge_onto(repo, &pair[0], &rewritten, &pair[1])? else { return Ok(None) };
|
||||
tree
|
||||
} else {
|
||||
next.tree.clone()
|
||||
};
|
||||
rewritten = next.write(repo, &final_tree, Some(&rewritten), None)?;
|
||||
}
|
||||
// The replay must consume exactly the selected changes. The worktree can then
|
||||
// stay as it is, including local edits and untracked files on the same paths.
|
||||
Ok((final_tree == addition.tree).then_some(rewritten))
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct PendingAmend {
|
||||
commit: String,
|
||||
history: History,
|
||||
paths: Vec<u8>,
|
||||
entries: blake3::Hash,
|
||||
}
|
||||
|
||||
pub(crate) fn keep_amend(repo: &Repo, commit: &str) -> IdeResult<String> {
|
||||
let pending = repo.amend_recovery.lock().unwrap_or_else(|e| e.into_inner()).clone();
|
||||
let pending = pending
|
||||
.filter(|pending| pending.commit == commit)
|
||||
.ok_or_else(|| IdeError::invalid("The prepared amend commit is no longer available."))?;
|
||||
pending.history.ensure_current(repo)?;
|
||||
let index = read_index(&repo.gix()?.index_path())?;
|
||||
if affected_index_entries(repo, &pending.history.head.to_string(), index.as_deref(), &pending.paths)?
|
||||
!= pending.entries
|
||||
{
|
||||
return Err(IdeError::invalid("Staged changes for the prepared amend commit have changed."));
|
||||
}
|
||||
pending.history.publish_amend(repo, index.as_deref(), &pending.paths, commit, "keep prepared amend commit")?;
|
||||
let mut recovery = repo.amend_recovery.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if recovery.as_ref().is_some_and(|pending| pending.commit == commit) {
|
||||
*recovery = None;
|
||||
}
|
||||
Ok(pending.commit)
|
||||
}
|
||||
|
||||
fn read_index(path: &Path) -> IdeResult<Option<Vec<u8>>> {
|
||||
match fs::read(path) {
|
||||
Ok(bytes) => Ok(Some(bytes)),
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
|
||||
Err(error) => Err(error.into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn ensure_unpublished(repo: &Repo, commit: &str, protected: &[String]) -> IdeResult<()> {
|
||||
if protected.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let refs =
|
||||
run(repo.root(), &["for-each-ref", "--contains", commit, "--format=%(refname:strip=2)", "refs/remotes"], None)?
|
||||
.stdout_str();
|
||||
if let Some(branch) = refs.lines().find(|branch| protected.iter().any(|name| name == branch)) {
|
||||
return Err(IdeError::invalid(format!("The commit has already been pushed to protected branch '{branch}'.")));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn merge_onto(repo: &Repo, base: &str, ours: &str, theirs: &str) -> IdeResult<Option<String>> {
|
||||
let base = format!("--merge-base={base}");
|
||||
let args = ["merge-tree", "--write-tree", "--no-messages", &base, ours, theirs];
|
||||
let output = run_raw(repo.root(), &args, None)?;
|
||||
match output.code {
|
||||
Some(0) => Ok(Some(output.stdout_str().trim().to_string())),
|
||||
Some(1) => Ok(None),
|
||||
_ => Err(failure(&args, &output.stderr, &output.stdout, output.code)),
|
||||
}
|
||||
}
|
||||
|
||||
fn changed_paths(repo: &Repo, before: &str, selected: &str) -> IdeResult<Vec<u8>> {
|
||||
Ok(run(
|
||||
repo.root(),
|
||||
&["diff-tree", "-r", "--no-commit-id", "--no-renames", "--name-only", "-z", before, selected],
|
||||
None,
|
||||
)?
|
||||
.stdout)
|
||||
}
|
||||
|
||||
fn path_parents(path: &[u8]) -> impl Iterator<Item = &[u8]> {
|
||||
path.iter().enumerate().filter_map(|(i, byte)| (*byte == b'/').then_some(&path[..i]))
|
||||
}
|
||||
|
||||
/// Ignore index stat refreshes and unrelated staged edits. Ancestors and descendants
|
||||
/// matter too, since Git can replace a file with a directory at an affected path.
|
||||
fn affected_index_entries(repo: &Repo, head: &str, index: Option<&[u8]>, paths: &[u8]) -> IdeResult<blake3::Hash> {
|
||||
let mut hash = blake3::Hasher::new();
|
||||
if let Some(index) = index {
|
||||
let temp = TempIndex::new(repo);
|
||||
fs::write(temp.path(), index)?;
|
||||
let output = run_env(repo.root(), &["ls-files", "-v", "--stage", "-z"], None, &temp.env())?;
|
||||
let paths: HashSet<_> = paths.split(|&byte| byte == 0).filter(|path| !path.is_empty()).collect();
|
||||
let parents: HashSet<_> = paths.iter().flat_map(|path| path_parents(path)).collect();
|
||||
let related = |path: &[u8]| {
|
||||
paths.contains(path) || parents.contains(path) || path_parents(path).any(|p| paths.contains(p))
|
||||
};
|
||||
for entry in output.stdout.split(|&byte| byte == 0) {
|
||||
let Some(tab) = entry.find_byte(b'\t') else { continue };
|
||||
if related(&entry[tab + 1..]) {
|
||||
hash.update(entry);
|
||||
hash.update(b"\0");
|
||||
}
|
||||
}
|
||||
// ls-files gives both intent-to-add and a staged empty file the empty blob ID.
|
||||
let additions = run_env(
|
||||
repo.root(),
|
||||
&[
|
||||
"diff-index",
|
||||
"--cached",
|
||||
"--ita-invisible-in-index",
|
||||
"--diff-filter=A",
|
||||
"--name-only",
|
||||
"-z",
|
||||
"--no-renames",
|
||||
head,
|
||||
"--",
|
||||
],
|
||||
None,
|
||||
&temp.env(),
|
||||
)?;
|
||||
hash.update(b"\0");
|
||||
for path in additions.stdout.split(|&byte| byte == 0).filter(|path| related(path)) {
|
||||
hash.update(path);
|
||||
hash.update(b"\0");
|
||||
}
|
||||
}
|
||||
Ok(hash.finalize())
|
||||
}
|
||||
|
||||
fn index_after_amend(repo: &Repo, original: Option<&[u8]>, paths: &[u8], selected: &str) -> IdeResult<Option<Vec<u8>>> {
|
||||
if paths.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let next = TempIndex::new(repo);
|
||||
if let Some(original) = original {
|
||||
fs::write(next.path(), original)?;
|
||||
} else {
|
||||
run_env(repo.root(), &["read-tree", "--empty"], None, &next.env())?;
|
||||
}
|
||||
run_env(
|
||||
repo.root(),
|
||||
&["--literal-pathspecs", "reset", "-q", selected, "--pathspec-from-file=-", "--pathspec-file-nul"],
|
||||
Some(paths),
|
||||
&next.env(),
|
||||
)?;
|
||||
Ok(Some(fs::read(next.path())?))
|
||||
}
|
||||
|
||||
pub(crate) fn extract(
|
||||
repo: &Repo,
|
||||
id: &str,
|
||||
expected_head: &HistoryTip,
|
||||
paths: &[PathBuf],
|
||||
message: &str,
|
||||
) -> IdeResult<RewrittenCommit> {
|
||||
let message = new_message(message)?;
|
||||
let history = History::load(repo, id, Some(expected_head))?;
|
||||
let target = &history.commits[0];
|
||||
let commit = Commit::read(repo, target)?;
|
||||
let remaining = remaining_tree(repo, target, &commit, paths)?;
|
||||
let rewritten = commit.write(repo, &remaining, commit.parent.as_deref(), None)?;
|
||||
let extracted = commit.write(repo, &commit.tree, Some(&rewritten), Some(&message))?;
|
||||
let head = history.rewrite_descendants(repo, extracted.clone(), "extract selected changes")?;
|
||||
Ok(RewrittenCommit { head, commit: extracted })
|
||||
}
|
||||
|
||||
pub(crate) fn drop_changes(
|
||||
repo: &Repo,
|
||||
id: &str,
|
||||
expected_head: &HistoryTip,
|
||||
paths: &[PathBuf],
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<RewrittenCommit> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let history = History::load(repo, id, Some(expected_head))?;
|
||||
let target = &history.commits[0];
|
||||
let commit = Commit::read(repo, target)?;
|
||||
let remaining = remaining_tree(repo, target, &commit, paths)?;
|
||||
let replacement = commit.write(repo, &remaining, commit.parent.as_deref(), None)?;
|
||||
let mut todo = format!("drop {target}\npick {replacement}\n");
|
||||
for descendant in &history.commits[1..] {
|
||||
todo.push_str(&format!("pick {descendant}\n"));
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
history.ensure_current(repo)?;
|
||||
let work = tempfile::tempdir_in(&repo.git_dir)?;
|
||||
let args = [
|
||||
"-c",
|
||||
"rebase.missingCommitsCheck=error",
|
||||
"rebase",
|
||||
"--interactive",
|
||||
"--no-autosquash",
|
||||
"--empty=keep",
|
||||
commit.parent.as_deref().unwrap_or("--root"),
|
||||
];
|
||||
crate::ops::run_rebase_todo(repo, work.path(), &todo, &args, cancel, out)?;
|
||||
let after = run(repo.root(), &["rev-parse", "--verify", "HEAD"], None)?.stdout_str().trim().to_string();
|
||||
let rewritten = format!("{after}~{}", history.commits.len() - 1);
|
||||
let commit = run(repo.root(), &["rev-parse", "--verify", &rewritten], None)?.stdout_str().trim().to_string();
|
||||
Ok(RewrittenCommit { head: HeadChange { before: history.head.to_string(), after }, commit })
|
||||
}
|
||||
|
||||
fn remaining_tree(repo: &Repo, id: &str, commit: &Commit, paths: &[PathBuf]) -> IdeResult<String> {
|
||||
let paths = paths.iter().map(|path| repo.given_rel_path(path)).collect::<IdeResult<HashSet<_>>>()?;
|
||||
if paths.is_empty() || paths.contains("") {
|
||||
return Err(IdeError::invalid("select files from the commit"));
|
||||
}
|
||||
let source_tree = if let Some(parent) = &commit.parent {
|
||||
run(repo.root(), &["rev-parse", &format!("{parent}^{{tree}}")], None)?
|
||||
} else {
|
||||
run(repo.root(), &["hash-object", "-t", "tree", "-w", "--stdin"], Some(b""))?
|
||||
}
|
||||
.stdout_str();
|
||||
let source = format!("--source={}", source_tree.trim());
|
||||
let index = TempIndex::new(repo);
|
||||
let env = index.env();
|
||||
let config = ["-c", "core.sparseCheckout=false", "-c", "index.sparse=false"];
|
||||
run_env(repo.root(), &[&config[..], &["read-tree", id]].concat(), None, &env)?;
|
||||
let mut pathspec = Vec::new();
|
||||
for path in &paths {
|
||||
pathspec.extend_from_slice(path.as_bytes());
|
||||
pathspec.push(0);
|
||||
}
|
||||
let restore =
|
||||
["--literal-pathspecs", "restore", "--staged", &source, "--pathspec-from-file=-", "--pathspec-file-nul"];
|
||||
run_env(repo.root(), &[&config[..], &restore].concat(), Some(&pathspec), &env)?;
|
||||
let changed = run_env(
|
||||
repo.root(),
|
||||
&[&config[..], &["diff", "--cached", "--name-only", "--no-renames", "-z", id, "--"]].concat(),
|
||||
None,
|
||||
&env,
|
||||
)?;
|
||||
let restored: HashSet<&[u8]> = changed.stdout.split(|&b| b == 0).filter(|path| !path.is_empty()).collect();
|
||||
// A file/directory replacement can make a pathspec touch unselected paths.
|
||||
if restored.len() != paths.len() || paths.iter().any(|path| !restored.contains(path.as_bytes())) {
|
||||
return Err(IdeError::invalid("the selected paths cannot be split from the other changes in this commit"));
|
||||
}
|
||||
let tree = run_env(repo.root(), &[&config[..], &["write-tree"]].concat(), None, &env)?.stdout_str();
|
||||
if tree.trim() == source_tree.trim() {
|
||||
return Err(IdeError::invalid("select fewer than all changes in the commit"));
|
||||
}
|
||||
Ok(tree.trim().to_string())
|
||||
}
|
||||
@@ -129,7 +129,8 @@ impl Repos {
|
||||
continue;
|
||||
}
|
||||
let repo = self.at_root(&root.0).expect("scope comes from registry");
|
||||
let _scope = repo.execution_scope();
|
||||
let _scope =
|
||||
crate::ExecutionScope::enter(repo.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let mut missing_revision = false;
|
||||
let mut compare = || -> IdeResult<(String, Vec<WorkingTreeChange>)> {
|
||||
// Worktree comparisons must not run repository-defined clean/process filters
|
||||
@@ -705,45 +706,6 @@ mod tests {
|
||||
(marker, script.to_str().unwrap().replace('\\', "/"))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn log_details_reads_each_signed_commit_once_when_git_displays_signatures() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = normalized(temp.path());
|
||||
init(&root, "main");
|
||||
git(&root, &["commit", "--allow-empty", "-qm", "first signed"]);
|
||||
sign_head(&root, "PGP SIGNATURE");
|
||||
git(&root, &["commit", "--allow-empty", "-qm", "second signed"]);
|
||||
sign_head(&root, "PGP SIGNATURE");
|
||||
let (_, script) = verifier_script(&root);
|
||||
std::fs::write(
|
||||
&script,
|
||||
"#!/bin/sh\nprintf 'attempt\\n' >> verification-attempts\n\
|
||||
printf '%s\\n' 'gpg: Test diagnostic' >&2\n\
|
||||
printf '%s\\n' '[GNUPG:] NEWSIG' '[GNUPG:] BADSIG 61CF236723A1C18B Synthetic Signer'\nexit 1\n",
|
||||
)
|
||||
.unwrap();
|
||||
git(&root, &["config", "log.showSignature", "true"]);
|
||||
git(&root, &["config", "gpg.program", &script]);
|
||||
|
||||
let repo = crate::Repo::discover(&root).unwrap().unwrap();
|
||||
repo.set_execution_allowed(true);
|
||||
let revisions = ["HEAD^", "HEAD~2", "HEAD", "HEAD^"].map(String::from);
|
||||
let cancel = CancellationToken::new();
|
||||
let details = repo.log_details_batch_cancellable(&revisions, &cancel).unwrap();
|
||||
assert_eq!(
|
||||
details.iter().map(|d| (d.message.as_str(), d.signature.as_str())).collect::<Vec<_>>(),
|
||||
[("first signed", "B"), ("initial", "N"), ("second signed", "B"), ("first signed", "B")]
|
||||
);
|
||||
assert_eq!(details[0].signer, "Synthetic Signer");
|
||||
assert_eq!(details[2].key, "61CF236723A1C18B");
|
||||
assert_eq!(repo.log_details("HEAD").unwrap().signature, "B");
|
||||
|
||||
repo.set_execution_allowed(false);
|
||||
assert_eq!(repo.log_details("HEAD").unwrap().signature, "E");
|
||||
let attempts = std::fs::read_to_string(root.join("verification-attempts")).unwrap();
|
||||
assert_eq!(attempts.lines().count(), 2);
|
||||
}
|
||||
|
||||
/// Security audit lead 2: Restricted Mode `git log` must not run the repository's signature verifier.
|
||||
#[test]
|
||||
fn restricted_log_does_not_execute_signature_verifier() {
|
||||
|
||||
@@ -1,241 +0,0 @@
|
||||
//! Whole-file conflict resolution and the original stages Git saves for undo.
|
||||
|
||||
use crate::cli::run;
|
||||
use crate::repo::gx;
|
||||
use crate::{ConflictSide, Repo, StashApplyOutcome};
|
||||
use gix::bstr::BStr;
|
||||
use gix::index::entry::Stage;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::path::PathBuf;
|
||||
|
||||
const CONFLICT_STAGES: [Stage; 3] = [Stage::Base, Stage::Ours, Stage::Theirs];
|
||||
const RESTORE_CONFLICTS: &str = "openidea-manual-stash-conflicts.json";
|
||||
|
||||
#[derive(Clone, Copy, Default, serde::Serialize, serde::Deserialize)]
|
||||
pub(crate) enum RestoreConflict {
|
||||
#[default]
|
||||
ManualStash,
|
||||
AutomaticShelf,
|
||||
PatchApply,
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize, serde::Deserialize)]
|
||||
struct RestoreConflicts {
|
||||
#[serde(default)]
|
||||
kind: RestoreConflict,
|
||||
head: (Option<String>, Option<String>),
|
||||
stages: BTreeSet<String>,
|
||||
}
|
||||
|
||||
fn unmerged_stages(repo: &Repo) -> IdeResult<BTreeSet<String>> {
|
||||
let index = run(repo.root(), &["ls-files", "--unmerged", "-z"], None)?;
|
||||
Ok(index
|
||||
.stdout
|
||||
.split(|&byte| byte == 0)
|
||||
.filter(|entry| !entry.is_empty())
|
||||
.map(|entry| blake3::hash(entry).to_hex().to_string())
|
||||
.collect())
|
||||
}
|
||||
|
||||
fn save_restore_conflicts(repo: &Repo, kind: RestoreConflict, stages: BTreeSet<String>) -> IdeResult<()> {
|
||||
let conflicts = RestoreConflicts { kind, head: repo.head()?, stages };
|
||||
let mut file = tempfile::NamedTempFile::new_in(&repo.git_dir)?;
|
||||
serde_json::to_writer(&mut file, &conflicts).map_err(|error| IdeError::internal(error.to_string()))?;
|
||||
file.persist(repo.git_dir.join(RESTORE_CONFLICTS)).map_err(|error| error.error)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn clear_restore_conflicts(repo: &Repo) {
|
||||
let _ = std::fs::remove_file(repo.git_dir.join(RESTORE_CONFLICTS));
|
||||
}
|
||||
|
||||
pub(crate) fn record_conflicts(repo: &Repo, kind: RestoreConflict) {
|
||||
let result = unmerged_stages(repo).and_then(|stages| save_restore_conflicts(repo, kind, stages));
|
||||
if let Err(error) = result {
|
||||
tracing::warn!(?error, "could not record conflict sides");
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn run_manual_unstash(repo: &Repo, args: &[&str]) -> IdeResult<StashApplyOutcome> {
|
||||
let _guard = repo.conflict_mutation.lock().unwrap_or_else(|error| error.into_inner());
|
||||
let fresh = crate::write::unmerged_paths(repo)?.is_empty();
|
||||
if fresh {
|
||||
clear_restore_conflicts(repo);
|
||||
}
|
||||
match run(repo.root(), args, None) {
|
||||
Ok(_) => Ok(StashApplyOutcome::Done),
|
||||
Err(error) if fresh => {
|
||||
let Ok(stages) = unmerged_stages(repo) else { return Err(error) };
|
||||
if stages.is_empty() {
|
||||
return Err(error);
|
||||
}
|
||||
if let Err(error) = save_restore_conflicts(repo, RestoreConflict::ManualStash, stages) {
|
||||
tracing::warn!(?error, "could not record manual stash conflicts");
|
||||
}
|
||||
Ok(StashApplyOutcome::Conflicts { repository: repo.root().into() })
|
||||
}
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn restore_conflict(repo: &Repo) -> IdeResult<Option<RestoreConflict>> {
|
||||
let Ok(bytes) = std::fs::read(repo.git_dir.join(RESTORE_CONFLICTS)) else { return Ok(None) };
|
||||
let Ok(conflicts) = serde_json::from_slice::<RestoreConflicts>(&bytes) else { return Ok(None) };
|
||||
if conflicts.head != repo.head()? {
|
||||
return Ok(None);
|
||||
}
|
||||
// Resolving a file removes its stages from the index. The remaining files
|
||||
// keep the same side labels as long as their original stages still match.
|
||||
let stages = unmerged_stages(repo)?;
|
||||
Ok((!stages.is_empty() && stages.is_subset(&conflicts.stages)).then_some(conflicts.kind))
|
||||
}
|
||||
|
||||
pub(crate) fn accept_side(repo: &Repo, paths: &[PathBuf], side: ConflictSide) -> IdeResult<()> {
|
||||
if paths.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let _guard = repo.conflict_mutation.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let ours = (side == ConflictSide::Ours) != repo.merge_sides()?.reversed;
|
||||
let (stage, option) = if ours { (Stage::Ours, "--ours") } else { (Stage::Theirs, "--theirs") };
|
||||
let git = repo.gix()?;
|
||||
let index = git.open_index().map_err(gx)?;
|
||||
let paths = paths.iter().map(|path| repo.rel_path(path)).collect::<IdeResult<BTreeSet<_>>>()?;
|
||||
let mut kept = Vec::new();
|
||||
let mut deleted = Vec::new();
|
||||
for path in paths {
|
||||
let key = BStr::new(path.as_bytes());
|
||||
if let Some(entry) = index.entry_by_path_and_stage(key, stage) {
|
||||
kept.push((path, entry.mode, entry.id));
|
||||
} else if CONFLICT_STAGES.iter().any(|&s| index.entry_by_path_and_stage(key, s).is_some()) {
|
||||
deleted.push(path);
|
||||
} else {
|
||||
return Err(IdeError::invalid(format!("{path} has no conflict to resolve")));
|
||||
}
|
||||
}
|
||||
|
||||
let present: Vec<_> = kept.iter().map(|(path, _, _)| path.clone()).collect();
|
||||
checkout(repo, option, &present)?;
|
||||
run_literal_paths(repo, &["rm", "--sparse", "--ignore-unmatch"], &deleted)?;
|
||||
if !kept.is_empty() {
|
||||
let current = git.open_index().map_err(gx)?;
|
||||
let mut records = Vec::new();
|
||||
for (path, mode, id) in kept {
|
||||
let entry = current.entry_by_path_and_stage(BStr::new(path.as_bytes()), stage);
|
||||
if !entry.is_some_and(|entry| entry.mode == mode && entry.id == id) {
|
||||
return Err(IdeError::invalid(format!("the conflict in {path} changed while resolving it")));
|
||||
}
|
||||
// Stage the exact blob and mode. Replacing the unmerged entries this way
|
||||
// makes Git retain their original stages for Revert Resolved.
|
||||
records.extend_from_slice(format!("{:o} {id}\t{path}\0", mode.bits()).as_bytes());
|
||||
}
|
||||
run(repo.root(), &["update-index", "-z", "--index-info"], Some(&records))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
struct SavedStage {
|
||||
mode: String,
|
||||
id: String,
|
||||
stage: u8,
|
||||
}
|
||||
|
||||
fn saved_resolutions(repo: &Repo) -> IdeResult<BTreeMap<String, Vec<SavedStage>>> {
|
||||
let objects = repo.gix()?;
|
||||
let mut resolutions = BTreeMap::<String, Vec<SavedStage>>::new();
|
||||
if !matches!(
|
||||
crate::refs::operation(&objects).as_deref(),
|
||||
Some("merge" | "rebase" | "revert" | "cherry-pick" | "am")
|
||||
) {
|
||||
return Ok(resolutions);
|
||||
}
|
||||
let index = objects.index_or_empty().map_err(gx)?;
|
||||
if index.resolve_undo().is_none() {
|
||||
return Ok(resolutions);
|
||||
}
|
||||
let listed = run(repo.root(), &["ls-files", "--resolve-undo", "-z"], None)?;
|
||||
for entry in listed.stdout.split(|&b| b == 0).filter_map(|entry| std::str::from_utf8(entry).ok()) {
|
||||
let Some((info, path)) = entry.split_once('\t') else { continue };
|
||||
let path_key = BStr::new(path.as_bytes());
|
||||
if CONFLICT_STAGES.iter().any(|stage| index.entry_by_path_and_stage(path_key, *stage).is_some()) {
|
||||
continue;
|
||||
}
|
||||
let mut fields = info.split_ascii_whitespace();
|
||||
if let (Some(mode), Some(id), Some(Ok(stage @ 1..=3))) =
|
||||
(fields.next(), fields.next(), fields.next().map(str::parse::<u8>))
|
||||
{
|
||||
resolutions.entry(path.to_string()).or_default().push(SavedStage {
|
||||
mode: mode.to_string(),
|
||||
id: id.to_string(),
|
||||
stage,
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(resolutions)
|
||||
}
|
||||
|
||||
pub(crate) fn resolved_paths(repo: &Repo) -> IdeResult<Vec<PathBuf>> {
|
||||
Ok(saved_resolutions(repo)?.into_keys().map(|path| repo.abs_path(&path)).collect())
|
||||
}
|
||||
|
||||
pub(crate) fn revert_resolved(repo: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
|
||||
if paths.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let _guard = repo.conflict_mutation.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let paths = paths.iter().map(|path| repo.rel_path(path)).collect::<IdeResult<BTreeSet<_>>>()?;
|
||||
let resolutions = saved_resolutions(repo)?;
|
||||
if let Some(path) = paths.iter().find(|path| !resolutions.contains_key(*path)) {
|
||||
return Err(IdeError::invalid(format!("{path} has no resolution to revert")));
|
||||
}
|
||||
let mut merge = Vec::new();
|
||||
let mut ours = Vec::new();
|
||||
let mut theirs = Vec::new();
|
||||
let mut index_info = Vec::new();
|
||||
let zero = repo.gix()?.object_hash().null();
|
||||
for path in paths {
|
||||
let stages = &resolutions[&path];
|
||||
let has_ours = stages.iter().any(|s| s.stage == 2);
|
||||
let has_theirs = stages.iter().any(|s| s.stage == 3);
|
||||
if has_ours && has_theirs {
|
||||
merge.push(path);
|
||||
} else {
|
||||
// Checkout --merge needs both sides. For modify/delete, restore the
|
||||
// saved index stages and check out the surviving side.
|
||||
index_info.extend_from_slice(format!("0 {zero}\t{path}\0").as_bytes());
|
||||
for stage in stages {
|
||||
let SavedStage { mode, id, stage } = stage;
|
||||
index_info.extend_from_slice(format!("{mode} {id} {stage}\t{path}\0").as_bytes());
|
||||
}
|
||||
if has_ours {
|
||||
ours.push(path);
|
||||
} else if has_theirs {
|
||||
theirs.push(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
checkout(repo, "--merge", &merge)?;
|
||||
if !index_info.is_empty() {
|
||||
run(repo.root(), &["update-index", "-z", "--index-info"], Some(&index_info))?;
|
||||
checkout(repo, "--ours", &ours)?;
|
||||
checkout(repo, "--theirs", &theirs)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn checkout(repo: &Repo, option: &str, paths: &[String]) -> IdeResult<()> {
|
||||
run_literal_paths(repo, &["checkout", option, "--no-recurse-submodules", "--ignore-skip-worktree-bits"], paths)
|
||||
}
|
||||
|
||||
fn run_literal_paths(repo: &Repo, command: &[&str], paths: &[String]) -> IdeResult<()> {
|
||||
if paths.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let mut pathspec = paths.join("\0").into_bytes();
|
||||
pathspec.push(0);
|
||||
let mut args = vec!["--literal-pathspecs"];
|
||||
args.extend_from_slice(command);
|
||||
args.extend(["--pathspec-from-file=-", "--pathspec-file-nul"]);
|
||||
run(repo.root(), &args, Some(&pathspec))?;
|
||||
Ok(())
|
||||
}
|
||||
+7
-187
@@ -1,9 +1,8 @@
|
||||
//! Line diffs (imara-diff Histogram) for gutter markers and partial staging.
|
||||
|
||||
use crate::{HunkKind, LineHunk, PartialCommitHunk, StagingLineHunk};
|
||||
use crate::{HunkKind, LineHunk};
|
||||
use gix::diff::blob::{Algorithm, Diff, InternedInput};
|
||||
use std::borrow::Cow;
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::ops::Range;
|
||||
|
||||
/// Converts CRLF (and lone CR) line endings to LF.
|
||||
@@ -55,91 +54,6 @@ pub fn line_hunks(old: &str, new: &str) -> Vec<LineHunk> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
struct IndexRange {
|
||||
lines: Range<u32>,
|
||||
head_delta: i64,
|
||||
working_delta: i64,
|
||||
staged: bool,
|
||||
unstaged: bool,
|
||||
}
|
||||
|
||||
/// Combine the two diffs in index coordinates, then project each connected
|
||||
/// block onto HEAD and the working text.
|
||||
pub(crate) fn staging_line_hunks(head: &str, index: &str, working: &str) -> Vec<StagingLineHunk> {
|
||||
let head = normalize_eol(head);
|
||||
let working = normalize_eol(working);
|
||||
let head = split_lines(&head);
|
||||
let index = split_lines(index);
|
||||
let working = split_lines(&working);
|
||||
let delta = |from: &Range<u32>, to: &Range<u32>| to.len() as i64 - from.len() as i64;
|
||||
let mut changes: Vec<_> = raw_hunks(&head, &index)
|
||||
.into_iter()
|
||||
.map(|(before, after)| IndexRange {
|
||||
head_delta: delta(&after, &before),
|
||||
lines: after,
|
||||
working_delta: 0,
|
||||
staged: true,
|
||||
unstaged: false,
|
||||
})
|
||||
.chain(raw_hunks(&index, &working).into_iter().map(|(before, after)| IndexRange {
|
||||
working_delta: delta(&before, &after),
|
||||
lines: before,
|
||||
head_delta: 0,
|
||||
staged: false,
|
||||
unstaged: true,
|
||||
}))
|
||||
.collect();
|
||||
changes.sort_unstable_by_key(|block| block.lines.start);
|
||||
let mut blocks: Vec<IndexRange> = Vec::new();
|
||||
for change in changes {
|
||||
if let Some(block) = blocks.last_mut().filter(|block| change.lines.start <= block.lines.end) {
|
||||
block.lines.end = block.lines.end.max(change.lines.end);
|
||||
block.head_delta += change.head_delta;
|
||||
block.working_delta += change.working_delta;
|
||||
block.staged |= change.staged;
|
||||
block.unstaged |= change.unstaged;
|
||||
} else {
|
||||
blocks.push(change);
|
||||
}
|
||||
}
|
||||
let mut head_shift = 0;
|
||||
let mut working_shift = 0;
|
||||
blocks
|
||||
.into_iter()
|
||||
.map(|block| {
|
||||
let head_start = (i64::from(block.lines.start) + head_shift) as u32;
|
||||
let start = (i64::from(block.lines.start) + working_shift) as u32;
|
||||
head_shift += block.head_delta;
|
||||
working_shift += block.working_delta;
|
||||
let head_end = (i64::from(block.lines.end) + head_shift) as u32;
|
||||
let end = (i64::from(block.lines.end) + working_shift) as u32;
|
||||
let index_start = block.lines.start;
|
||||
let index_end = block.lines.end;
|
||||
let before_is_empty = if block.unstaged { index_end == index_start } else { head_end == head_start };
|
||||
let kind = if end == start {
|
||||
HunkKind::Deleted
|
||||
} else if before_is_empty {
|
||||
HunkKind::Added
|
||||
} else {
|
||||
HunkKind::Modified
|
||||
};
|
||||
StagingLineHunk {
|
||||
kind,
|
||||
start,
|
||||
lines: end - start,
|
||||
head_start,
|
||||
head_lines: head_end - head_start,
|
||||
head_text: head[head_start as usize..head_end as usize].concat(),
|
||||
index_start,
|
||||
index_lines: index_end - index_start,
|
||||
index_text: index[index_start as usize..index_end as usize].concat(),
|
||||
staged: block.staged,
|
||||
unstaged: block.unstaged,
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Hunks for a file that does not exist in the base (untracked / newly added).
|
||||
pub(crate) fn all_added(new: &str) -> Vec<LineHunk> {
|
||||
let new = normalize_eol(new);
|
||||
@@ -240,7 +154,7 @@ fn push_line(out: &mut String, prefix: char, line: &str) {
|
||||
}
|
||||
|
||||
/// C-style quoting for paths git would quote in patch headers.
|
||||
pub(crate) fn quote_path(path: &str) -> String {
|
||||
fn quote_path(path: &str) -> String {
|
||||
let needs = path.chars().any(|c| c == '"' || c == '\\' || c.is_control() || c == ' ' || c == '\t');
|
||||
if !needs {
|
||||
return path.to_string();
|
||||
@@ -262,53 +176,11 @@ pub(crate) fn quote_path(path: &str) -> String {
|
||||
|
||||
/// Apply selected line hunks while retaining the base's line separators.
|
||||
pub(crate) fn selected_text(old: &str, new: &str, selected: &[usize]) -> String {
|
||||
selected_lines_text(old, new, selected, &BTreeMap::new())
|
||||
}
|
||||
|
||||
pub(crate) fn selected_lines_text(
|
||||
old: &str,
|
||||
new: &str,
|
||||
selected: &[usize],
|
||||
lines: &BTreeMap<usize, &PartialCommitHunk>,
|
||||
) -> String {
|
||||
apply_text_hunks(old, new, |index| match lines.get(&index) {
|
||||
Some(selection) => HunkSelection::Lines(selection),
|
||||
None if selected.contains(&index) => HunkSelection::Whole,
|
||||
None => HunkSelection::Excluded,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn replace_text(old: &str, new: &str) -> String {
|
||||
apply_text_hunks(old, new, |_| HunkSelection::Whole)
|
||||
}
|
||||
|
||||
enum HunkSelection<'a> {
|
||||
Whole,
|
||||
Lines(&'a PartialCommitHunk),
|
||||
Excluded,
|
||||
}
|
||||
|
||||
fn apply_text_hunks<'a>(old: &str, new: &str, included: impl Fn(usize) -> HunkSelection<'a>) -> String {
|
||||
let old_norm = normalize_eol(old);
|
||||
let new_norm = normalize_eol(new);
|
||||
let old_lines = split_lines(&old_norm);
|
||||
let new_lines = split_lines(&new_norm);
|
||||
let mut start = 0;
|
||||
let old_raw: Vec<_> = old
|
||||
.bytes()
|
||||
.enumerate()
|
||||
.filter_map(|(i, byte)| {
|
||||
let end = i + 1;
|
||||
let separator = byte == b'\n' || (byte == b'\r' && old.as_bytes().get(end) != Some(&b'\n'));
|
||||
if separator || end == old.len() {
|
||||
let line = &old[start..end];
|
||||
start = end;
|
||||
Some(line)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
let old_raw = split_raw_lines(old);
|
||||
let eol = if old.contains("\r\n") {
|
||||
"\r\n"
|
||||
} else if old.contains('\r') {
|
||||
@@ -319,30 +191,13 @@ fn apply_text_hunks<'a>(old: &str, new: &str, included: impl Fn(usize) -> HunkSe
|
||||
let mut result = String::new();
|
||||
let mut cursor = 0;
|
||||
for (index, (before, after)) in raw_hunks(&old_lines, &new_lines).iter().enumerate() {
|
||||
let lines = match included(index) {
|
||||
HunkSelection::Excluded => continue,
|
||||
HunkSelection::Whole => None,
|
||||
HunkSelection::Lines(lines) => Some(lines),
|
||||
};
|
||||
if !selected.contains(&index) {
|
||||
continue;
|
||||
}
|
||||
for line in &old_raw[cursor..before.start as usize] {
|
||||
result.push_str(line);
|
||||
}
|
||||
if let Some(lines) = lines {
|
||||
let deletions: HashSet<_> = lines.deletions.iter().copied().collect();
|
||||
for (offset, line) in old_raw[before.start as usize..before.end as usize].iter().enumerate() {
|
||||
if !deletions.contains(&(offset as u32)) {
|
||||
result.push_str(line);
|
||||
}
|
||||
}
|
||||
}
|
||||
let additions = lines.map(|lines| lines.additions.iter().copied().collect::<HashSet<_>>());
|
||||
for (offset, line) in new_lines[after.start as usize..after.end as usize].iter().enumerate() {
|
||||
if additions.as_ref().is_some_and(|lines| !lines.contains(&(offset as u32))) {
|
||||
continue;
|
||||
}
|
||||
if lines.is_some() && !result.is_empty() && !result.ends_with(['\r', '\n']) {
|
||||
result.push_str(eol);
|
||||
}
|
||||
for line in &new_lines[after.start as usize..after.end as usize] {
|
||||
if let Some(body) = line.strip_suffix('\n') {
|
||||
result.push_str(body);
|
||||
result.push_str(eol);
|
||||
@@ -362,41 +217,6 @@ fn apply_text_hunks<'a>(old: &str, new: &str, included: impl Fn(usize) -> HunkSe
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn staging_line_hunks_keep_both_changes_when_head_and_worktree_match() {
|
||||
let hunks = staging_line_hunks("top\r\nhead\r\nend", "top\nindex\nend", "top\nhead\nend");
|
||||
assert_eq!(hunks.len(), 1);
|
||||
let hunk = &hunks[0];
|
||||
assert!(hunk.staged && hunk.unstaged);
|
||||
assert_eq!((hunk.start, hunk.lines, hunk.index_start, hunk.index_lines), (1, 1, 1, 1));
|
||||
assert_eq!(hunk.head_text, "head\n");
|
||||
assert_eq!(hunk.index_text, "index\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn staging_line_hunks_project_deletions_and_insertions_into_worktree_lines() {
|
||||
let hunks = staging_line_hunks(
|
||||
"intro\nremoved\npivot\ntarget\ntail\nend\n",
|
||||
"intro\npivot\ntarget\ntail\nstaged tail\nend\n",
|
||||
"intro\ninserted A\ninserted B\npivot\nworking target\ntail\nstaged tail\nend\n",
|
||||
);
|
||||
assert_eq!(hunks.len(), 3);
|
||||
assert!(hunks[0].staged && hunks[0].unstaged);
|
||||
assert_eq!((hunks[0].start, hunks[0].lines, hunks[0].head_start), (1, 2, 1));
|
||||
assert_eq!(hunks[0].head_text, "removed\n");
|
||||
assert_eq!(hunks[0].index_text, "");
|
||||
assert!(!hunks[1].staged && hunks[1].unstaged);
|
||||
assert_eq!((hunks[1].start, hunks[1].head_start, hunks[1].index_start), (4, 3, 2));
|
||||
assert_eq!(hunks[1].index_text, "target\n");
|
||||
assert!(hunks[2].staged && !hunks[2].unstaged);
|
||||
assert_eq!((hunks[2].start, hunks[2].head_start, hunks[2].index_start), (6, 5, 4));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selected_text_handles_lone_carriage_returns() {
|
||||
assert_eq!(selected_text("old\rkeep\r", "new\rkeep\r", &[0]), "new\rkeep\r");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hunk_kinds() {
|
||||
let old = "a\nb\nc\nd\n";
|
||||
|
||||
@@ -1,212 +1,12 @@
|
||||
//! Commit history (topological walk) and per-commit changed files via gitoxide.
|
||||
|
||||
use crate::repo::{gx, link_target, resolve, to_string};
|
||||
use crate::{ChangeKind, ChangedFile, Commit, LogDetails, LogOrder, LogQuery, Repo, RevisionChange};
|
||||
use crate::{ChangeKind, ChangedFile, Commit, LogOrder, LogQuery, Repo, RevisionChange};
|
||||
use gix::ObjectId;
|
||||
use gix::bstr::ByteSlice;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use redb::ReadableDatabase;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::Path;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
pub(crate) struct LogSignature {
|
||||
pub code: String,
|
||||
pub signer: String,
|
||||
pub key: String,
|
||||
pub fingerprint: String,
|
||||
}
|
||||
|
||||
impl LogSignature {
|
||||
pub(crate) fn apply(&self, details: &mut LogDetails) {
|
||||
details.signature.clone_from(&self.code);
|
||||
details.signer.clone_from(&self.signer);
|
||||
details.key.clone_from(&self.key);
|
||||
details.fingerprint.clone_from(&self.fingerprint);
|
||||
}
|
||||
}
|
||||
|
||||
const SIGNATURE_TTL: Duration = Duration::from_secs(60);
|
||||
const MAX_SIGNATURES: usize = 1_000;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct LogSignatureCache {
|
||||
pub generation: u64,
|
||||
entries: HashMap<ObjectId, (Instant, LogSignature)>,
|
||||
}
|
||||
|
||||
impl LogSignatureCache {
|
||||
pub(crate) fn clear(&mut self) {
|
||||
self.generation = self.generation.wrapping_add(1);
|
||||
self.entries.clear();
|
||||
}
|
||||
|
||||
pub(crate) fn get(&self, id: &ObjectId, now: Instant) -> Option<&LogSignature> {
|
||||
self.entries
|
||||
.get(id)
|
||||
.filter(|(checked_at, _)| now.saturating_duration_since(*checked_at) < SIGNATURE_TTL)
|
||||
.map(|(_, signature)| signature)
|
||||
}
|
||||
|
||||
pub(crate) fn store(&mut self, generation: u64, checked_at: Instant, signatures: HashMap<ObjectId, LogSignature>) {
|
||||
if generation != self.generation || signatures.is_empty() {
|
||||
return;
|
||||
}
|
||||
self.entries.retain(|_, (time, _)| checked_at.saturating_duration_since(*time) < SIGNATURE_TTL);
|
||||
for (id, signature) in signatures {
|
||||
if self.entries.get(&id).is_none_or(|(time, _)| *time <= checked_at) {
|
||||
self.entries.insert(id, (checked_at, signature));
|
||||
}
|
||||
}
|
||||
let excess = self.entries.len().saturating_sub(MAX_SIGNATURES);
|
||||
if excess > 0 {
|
||||
let mut ages: Vec<_> = self.entries.iter().map(|(id, (time, _))| (*time, *id)).collect();
|
||||
ages.sort_unstable();
|
||||
for (_, id) in ages.into_iter().take(excess) {
|
||||
self.entries.remove(&id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn log_signatures(
|
||||
root: &Path,
|
||||
commits: &HashSet<ObjectId>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HashMap<ObjectId, LogSignature>> {
|
||||
if commits.is_empty() {
|
||||
return Ok(HashMap::new());
|
||||
}
|
||||
let mut stdin = String::new();
|
||||
for id in commits {
|
||||
use std::fmt::Write;
|
||||
let _ = writeln!(stdin, "{id}");
|
||||
}
|
||||
let output = crate::cli::run_cancellable_stdin(
|
||||
root,
|
||||
&[
|
||||
"log",
|
||||
"--no-walk=unsorted",
|
||||
"--no-show-signature",
|
||||
"--no-notes",
|
||||
"--no-decorate",
|
||||
"-z",
|
||||
"--format=%H%x00%G?%x00%GS%x00%GK%x00%GF",
|
||||
"--stdin",
|
||||
"--",
|
||||
],
|
||||
stdin.as_bytes(),
|
||||
cancel,
|
||||
)?;
|
||||
let text = output.stdout_str();
|
||||
let fields: Vec<_> = text.split_terminator('\0').collect();
|
||||
Ok(fields
|
||||
.as_chunks::<5>()
|
||||
.0
|
||||
.iter()
|
||||
.filter_map(|row| {
|
||||
let id = ObjectId::from_hex(row[0].as_bytes()).ok()?;
|
||||
let code = match row[1] {
|
||||
"G" | "U" | "B" | "E" | "X" | "Y" | "R" => row[1],
|
||||
// The caller only requests commits with a signature header.
|
||||
_ => "E",
|
||||
};
|
||||
Some((
|
||||
id,
|
||||
LogSignature {
|
||||
code: code.into(),
|
||||
signer: row[2].into(),
|
||||
key: row[3].into(),
|
||||
fingerprint: row[4].into(),
|
||||
},
|
||||
))
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Source-side commits that have no equivalent on the target branch.
|
||||
pub(crate) fn not_cherry_picked(
|
||||
r: &Repo,
|
||||
source: &str,
|
||||
target: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Option<Vec<String>>> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let repo = r.gix()?;
|
||||
let Some(source) = comparison_tip(&repo, source)? else { return Ok(None) };
|
||||
let Some(target) = comparison_tip(&repo, target)? else { return Ok(None) };
|
||||
if source == target {
|
||||
return Ok(Some(Vec::new()));
|
||||
}
|
||||
let out = crate::cli::run_cancellable(r.root(), &["cherry", "--no-abbrev", &target, &source], cancel)?;
|
||||
let mut unmatched =
|
||||
out.stdout_str().lines().filter_map(|line| line.strip_prefix("+ ").map(str::to_owned)).collect::<HashSet<_>>();
|
||||
if unmatched.is_empty() {
|
||||
return Ok(Some(Vec::new()));
|
||||
}
|
||||
|
||||
// A pick resolved with conflicts can have a different patch-id. Match the recorded
|
||||
// origin or the original author, author time and message on the other side.
|
||||
let range = format!("{target}...{source}");
|
||||
let history = crate::cli::run_cancellable(
|
||||
r.root(),
|
||||
&[
|
||||
"log",
|
||||
"--left-right",
|
||||
"--no-merges",
|
||||
"--no-notes",
|
||||
"--no-show-signature",
|
||||
"-z",
|
||||
"--format=%m%H%x00%an%x00%ae%x00%at%x00%B",
|
||||
&range,
|
||||
"--",
|
||||
],
|
||||
cancel,
|
||||
)?;
|
||||
let fields: Vec<_> = history.stdout.split(|byte| *byte == 0).collect();
|
||||
let records = fields.as_chunks::<5>().0.iter();
|
||||
let mut target_metadata = HashSet::new();
|
||||
for row in records.clone().filter(|row| row[0].starts_with(b"<")) {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
target_metadata.insert(&row[1..]);
|
||||
if let Some(origin) = String::from_utf8_lossy(row[4])
|
||||
.trim_end()
|
||||
.lines()
|
||||
.last()
|
||||
.and_then(|line| line.strip_prefix("(cherry picked from commit "))
|
||||
.and_then(|line| line.strip_suffix(')'))
|
||||
{
|
||||
unmatched.remove(origin);
|
||||
}
|
||||
}
|
||||
for row in records.filter(|row| row[0].starts_with(b">")) {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if target_metadata.contains(&row[1..]) {
|
||||
unmatched.remove(String::from_utf8_lossy(&row[0][1..]).as_ref());
|
||||
}
|
||||
}
|
||||
let mut commits: Vec<_> = unmatched.into_iter().collect();
|
||||
commits.sort_unstable();
|
||||
Ok(Some(commits))
|
||||
}
|
||||
|
||||
fn comparison_tip(repo: &gix::Repository, rev: &str) -> IdeResult<Option<String>> {
|
||||
if rev != "HEAD" && !rev.starts_with("refs/") {
|
||||
for namespace in ["heads", "remotes"] {
|
||||
let name = format!("refs/{namespace}/{rev}");
|
||||
if let Some(mut reference) = repo.try_find_reference(name.as_str()).map_err(gx)? {
|
||||
return reference.peel_to_id().map(|id| Some(id.to_string())).map_err(gx);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(resolve(repo, rev).ok().map(|id| id.to_string()))
|
||||
}
|
||||
|
||||
/// Log "Text or hash" filter: the message (substring or regex), or a hash prefix.
|
||||
enum TextFilter {
|
||||
@@ -1521,48 +1321,10 @@ struct Merged {
|
||||
/// after the last one, following renames. Files added and then deleted drop out.
|
||||
pub(crate) fn commits_changes(r: &Repo, commits: &[String]) -> IdeResult<Vec<RevisionChange>> {
|
||||
let repo = r.gix()?;
|
||||
merge_commit_changes(&repo, commits, &CancellationToken::new())
|
||||
}
|
||||
|
||||
pub(crate) fn commit_selection_changes(
|
||||
r: &Repo,
|
||||
commits: &[String],
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<RevisionChange>> {
|
||||
let repo = r.gix()?;
|
||||
if commits.len() <= 1 {
|
||||
return merge_commit_changes(&repo, commits, cancel);
|
||||
}
|
||||
let mut ids = Vec::with_capacity(commits.len());
|
||||
let mut seen = HashSet::new();
|
||||
for rev in commits {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let id = resolve(&repo, rev)?;
|
||||
let id = repo.find_object(id).map_err(gx)?.peel_to_commit().map_err(gx)?.id;
|
||||
if seen.insert(id) {
|
||||
ids.push(id);
|
||||
}
|
||||
}
|
||||
let shallow = repo.shallow_commits().map_err(gx)?.map(|ids| ids.iter().copied().collect()).unwrap_or_default();
|
||||
let ordered = sort_subset(&repo, ids, LogOrder::Topo, false, &shallow, cancel, &HashMap::new())?;
|
||||
let commits: Vec<_> = ordered.into_iter().rev().map(|id| id.to_string()).collect();
|
||||
merge_commit_changes(&repo, &commits, cancel)
|
||||
}
|
||||
|
||||
fn merge_commit_changes(
|
||||
repo: &gix::Repository,
|
||||
commits: &[String],
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<RevisionChange>> {
|
||||
let mut merged: Vec<Merged> = Vec::new();
|
||||
let mut seen = HashSet::new();
|
||||
for rev in commits {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let c = first_parent_changes(repo, rev)?;
|
||||
let c = first_parent_changes(&repo, rev)?;
|
||||
if !seen.insert(c.id) {
|
||||
continue;
|
||||
}
|
||||
@@ -1617,39 +1379,7 @@ fn merge_commit_changes(
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{LogSignature, LogSignatureCache, SIGNATURE_TTL, revision_args};
|
||||
use gix::ObjectId;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
#[test]
|
||||
fn signature_cache_expires_and_ignores_results_from_before_refresh() {
|
||||
let mut cache = LogSignatureCache::default();
|
||||
let id = ObjectId::from_hex(b"0000000000000000000000000000000000000001").unwrap();
|
||||
let now = Instant::now();
|
||||
let entry = |code: &str| {
|
||||
[(
|
||||
id,
|
||||
LogSignature {
|
||||
code: code.into(),
|
||||
signer: String::new(),
|
||||
key: String::new(),
|
||||
fingerprint: String::new(),
|
||||
},
|
||||
)]
|
||||
.into()
|
||||
};
|
||||
let before_refresh = cache.generation;
|
||||
cache.store(before_refresh, now, entry("E"));
|
||||
assert_eq!(cache.get(&id, now + SIGNATURE_TTL - Duration::from_millis(1)).unwrap().code, "E");
|
||||
assert!(cache.get(&id, now + SIGNATURE_TTL).is_none());
|
||||
|
||||
cache.clear();
|
||||
let refreshed = now + Duration::from_secs(1);
|
||||
cache.store(cache.generation, refreshed, entry("G"));
|
||||
cache.store(before_refresh, refreshed, entry("E"));
|
||||
cache.store(cache.generation, now, entry("E"));
|
||||
assert_eq!(cache.get(&id, refreshed).unwrap().code, "G");
|
||||
}
|
||||
use super::revision_args;
|
||||
|
||||
#[test]
|
||||
fn small_revision_walks_keep_their_arguments() {
|
||||
|
||||
@@ -161,7 +161,7 @@ fn pattern(path: &Path, directory: bool) -> IdeResult<String> {
|
||||
}
|
||||
|
||||
/// A symlink, or a Windows reparse point such as a junction, is a single entry for Git.
|
||||
pub(crate) fn is_link(meta: &fs::Metadata) -> bool {
|
||||
fn is_link(meta: &fs::Metadata) -> bool {
|
||||
if meta.file_type().is_symlink() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1,169 +0,0 @@
|
||||
//! Remote ref checks that leave the object database and tracking refs alone.
|
||||
|
||||
use crate::{Repo, TrackedTip, UpstreamTracking, cli, ops::remote_fetch_url, refs, repo};
|
||||
use gix::bstr::ByteSlice;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct UnfetchedBranch {
|
||||
pub branch: String,
|
||||
pub tracked_tip: TrackedTip,
|
||||
pub advertised_commit: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
pub struct IncomingRemoteError {
|
||||
pub remote: String,
|
||||
pub error: IdeError,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
pub struct IncomingRefsReport {
|
||||
pub branches: Vec<UnfetchedBranch>,
|
||||
pub errors: Vec<IncomingRemoteError>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct IncomingObservations {
|
||||
generation: u64,
|
||||
branches: HashMap<String, UnfetchedBranch>,
|
||||
// Resolved URLs may contain credentials. Keep them in the repository, outside IPC reports.
|
||||
endpoints: HashMap<String, String>,
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
pub fn check_incoming_refs(&self, cancel: &CancellationToken) -> IdeResult<IncomingRefsReport> {
|
||||
let _scope = self.execution_scope();
|
||||
let generation = {
|
||||
let mut observations = self.incoming_observations.lock().unwrap_or_else(|p| p.into_inner());
|
||||
observations.generation += 1;
|
||||
observations.generation
|
||||
};
|
||||
let mut endpoints = HashMap::new();
|
||||
let report = self.read_incoming_refs(&mut endpoints, cancel);
|
||||
let mut observations = self.incoming_observations.lock().unwrap_or_else(|p| p.into_inner());
|
||||
if generation == observations.generation && !cancel.is_cancelled() {
|
||||
observations.branches = report
|
||||
.as_ref()
|
||||
.into_iter()
|
||||
.flat_map(|report| &report.branches)
|
||||
.map(|branch| (branch.branch.clone(), branch.clone()))
|
||||
.collect();
|
||||
observations.endpoints = endpoints;
|
||||
}
|
||||
report
|
||||
}
|
||||
|
||||
pub(crate) fn observed_incoming_tip(
|
||||
&self,
|
||||
branch: &str,
|
||||
tracking: &UpstreamTracking,
|
||||
tracked_tip: &str,
|
||||
endpoint: &str,
|
||||
) -> Option<String> {
|
||||
let observations = self.incoming_observations.lock().unwrap_or_else(|p| p.into_inner());
|
||||
let observed = observations.branches.get(branch)?;
|
||||
if &observed.tracked_tip.tracking != tracking
|
||||
|| observed.tracked_tip.commit != tracked_tip
|
||||
|| observations.endpoints.get(&tracking.remote)? != endpoint
|
||||
{
|
||||
return None;
|
||||
}
|
||||
Some(observed.advertised_commit.clone())
|
||||
}
|
||||
|
||||
fn read_incoming_refs(
|
||||
&self,
|
||||
endpoints: &mut HashMap<String, String>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<IncomingRefsReport> {
|
||||
let repo = self.gix()?;
|
||||
let remotes = repo.remote_names();
|
||||
let mut by_remote: BTreeMap<String, Vec<(String, TrackedTip)>> = BTreeMap::new();
|
||||
for reference in repo.references().map_err(repo::gx)?.local_branches().map_err(repo::gx)? {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let reference = reference.map_err(repo::gx)?;
|
||||
if reference.target().try_name().is_some() {
|
||||
continue;
|
||||
}
|
||||
let name = reference.name();
|
||||
let Some(tracking) = refs::configured_upstream(&repo, name) else { continue };
|
||||
if !remotes.iter().any(|remote| remote.as_bstr() == tracking.remote.as_str()) {
|
||||
continue;
|
||||
}
|
||||
let Some((_, tip)) = refs::upstream_of(&repo, name) else { continue };
|
||||
by_remote
|
||||
.entry(tracking.remote.clone())
|
||||
.or_default()
|
||||
.push((repo::to_string(name.shorten()), TrackedTip { tracking, commit: tip.to_string() }));
|
||||
}
|
||||
|
||||
let mut branches = Vec::new();
|
||||
let mut errors = Vec::new();
|
||||
for (remote, tracked) in by_remote {
|
||||
let mut refs: Vec<_> =
|
||||
tracked.iter().map(|(_, tip)| format!("refs/heads/{}", tip.tracking.branch)).collect();
|
||||
refs.sort_unstable();
|
||||
refs.dedup();
|
||||
let advertised = match remote_fetch_url(self, &remote, cancel)
|
||||
.and_then(|url| self.advertised_heads(&remote, &refs, cancel).map(|advertised| (url, advertised)))
|
||||
{
|
||||
Ok(advertised) => advertised,
|
||||
Err(error) if error.kind == ErrorKind::Cancelled => return Err(error),
|
||||
Err(error) => {
|
||||
errors.push(IncomingRemoteError { remote, error });
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let (endpoint, advertised) = advertised;
|
||||
let before = branches.len();
|
||||
for (branch, tracked_tip) in tracked {
|
||||
let Some(commit) = advertised.get(tracked_tip.tracking.branch.as_str()) else { continue };
|
||||
if *commit != tracked_tip.commit {
|
||||
branches.push(UnfetchedBranch { branch, tracked_tip, advertised_commit: commit.clone() });
|
||||
}
|
||||
}
|
||||
if branches.len() > before {
|
||||
if remote_fetch_url(self, &remote, cancel).is_ok_and(|url| url == endpoint) {
|
||||
endpoints.insert(remote, endpoint);
|
||||
} else {
|
||||
branches.truncate(before);
|
||||
}
|
||||
}
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
Ok(IncomingRefsReport { branches, errors })
|
||||
}
|
||||
|
||||
fn advertised_heads(
|
||||
&self,
|
||||
remote: &str,
|
||||
refs: &[String],
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HashMap<String, String>> {
|
||||
let base = ["ls-remote", "--heads", "--refs", "--", remote];
|
||||
let mut heads = HashMap::new();
|
||||
for batch in cli::batch_paths(cli::base_command_line_len(&base), refs, 16 * 1024) {
|
||||
let mut args = base.to_vec();
|
||||
args.extend(batch.iter().map(String::as_str));
|
||||
let output = cli::run_with_saved_credentials(self.root(), &args, cancel)?;
|
||||
for line in output.stdout_str().lines() {
|
||||
let Some((commit, reference)) = line.split_once('\t') else { continue };
|
||||
let Some(branch) = reference.strip_prefix("refs/heads/") else { continue };
|
||||
if let Ok(commit) = gix::ObjectId::from_hex(commit.as_bytes()) {
|
||||
heads.insert(branch.to_owned(), commit.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(heads)
|
||||
}
|
||||
}
|
||||
+190
-1068
File diff suppressed because it is too large.
Load diff
@@ -446,7 +446,7 @@ pub(crate) fn matches_user(query: &str, name: &str, email: &str) -> bool {
|
||||
|
||||
/// git's subject (`%s`, `git log --oneline`): the message's first paragraph on one line.
|
||||
/// A whitespace-only line ends the paragraph, as in git; `\r\n` endings count as newlines.
|
||||
pub(crate) fn subject(message: &gix::bstr::BStr) -> String {
|
||||
fn subject(message: &gix::bstr::BStr) -> String {
|
||||
let lines = message.lines().map(|l| l.trim_end()).skip_while(|l| l.is_empty());
|
||||
let paragraph: Vec<String> = lines.take_while(|l| !l.is_empty()).map(|l| to_string(l.as_bstr())).collect();
|
||||
// git skips leading whitespace (blank lines and the first line's indent) before the subject.
|
||||
|
||||
+30
-185
@@ -5,7 +5,7 @@ use crate::cli::{self, run};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::path::Path;
|
||||
|
||||
/// Merge dialog › Modify options (shared by the Pull dialog).
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -19,45 +19,22 @@ pub struct MergeOptions {
|
||||
pub squash: bool,
|
||||
#[serde(default)]
|
||||
pub no_commit: bool,
|
||||
#[serde(default)]
|
||||
pub no_verify: bool,
|
||||
/// Merge histories whose commits have no common ancestor.
|
||||
#[serde(default)]
|
||||
pub allow_unrelated_histories: bool,
|
||||
/// `-m`: message of the merge commit (Merge dialog only).
|
||||
#[serde(default)]
|
||||
pub message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum MergeOutcome {
|
||||
Done,
|
||||
LocalChanges { files: Vec<String> },
|
||||
Conflicts,
|
||||
AlreadyUpToDate,
|
||||
ReadyToCommit,
|
||||
Squashed,
|
||||
}
|
||||
|
||||
/// Rebase dialog options.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RebaseOptions {
|
||||
/// Replay the selected commits onto this revision instead.
|
||||
/// `--onto <newbase>`: replay `upstream..HEAD` onto this revision instead.
|
||||
#[serde(default)]
|
||||
pub onto: Option<String>,
|
||||
/// Switch to this local branch before rebasing it.
|
||||
#[serde(default)]
|
||||
pub branch: Option<String>,
|
||||
#[serde(default)]
|
||||
pub rebase_merges: bool,
|
||||
#[serde(default)]
|
||||
pub keep_empty: bool,
|
||||
#[serde(default)]
|
||||
pub update_refs: bool,
|
||||
#[serde(default)]
|
||||
pub autosquash: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -72,10 +49,6 @@ pub struct Worktree {
|
||||
pub main: bool,
|
||||
pub locked: bool,
|
||||
pub prunable: bool,
|
||||
/// This worktree belongs to a repository checked out as a submodule.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub submodule: bool,
|
||||
}
|
||||
|
||||
/// Manage Remotes edits.
|
||||
@@ -125,9 +98,6 @@ fn merge_flags(o: &MergeOptions) -> IdeResult<Vec<&'static str>> {
|
||||
if o.no_commit {
|
||||
flags.push("--no-commit");
|
||||
}
|
||||
if o.no_verify {
|
||||
flags.push("--no-verify");
|
||||
}
|
||||
Ok(flags)
|
||||
}
|
||||
|
||||
@@ -138,9 +108,6 @@ pub(crate) fn merge_args(branches: &[String], o: &MergeOptions) -> IdeResult<Vec
|
||||
}
|
||||
let mut args: Vec<String> = vec!["merge".into()];
|
||||
args.extend(merge_flags(o)?.into_iter().map(String::from));
|
||||
if o.allow_unrelated_histories {
|
||||
args.push("--allow-unrelated-histories".into());
|
||||
}
|
||||
match o.message.as_deref().map(str::trim).filter(|m| !m.is_empty()) {
|
||||
Some(m) => args.extend(["-m".into(), m.to_string()]),
|
||||
None => args.push("--no-edit".into()),
|
||||
@@ -152,7 +119,7 @@ pub(crate) fn merge_args(branches: &[String], o: &MergeOptions) -> IdeResult<Vec
|
||||
}
|
||||
|
||||
/// `git rebase` arguments for the Rebase dialog.
|
||||
pub(crate) fn rebase_args(upstream: Option<&str>, o: &RebaseOptions) -> IdeResult<Vec<String>> {
|
||||
pub(crate) fn rebase_args(upstream: &str, o: &RebaseOptions) -> IdeResult<Vec<String>> {
|
||||
let mut args: Vec<String> = vec!["rebase".into()];
|
||||
if o.rebase_merges {
|
||||
args.push("--rebase-merges".into());
|
||||
@@ -160,44 +127,26 @@ pub(crate) fn rebase_args(upstream: Option<&str>, o: &RebaseOptions) -> IdeResul
|
||||
if o.keep_empty {
|
||||
args.push("--keep-empty".into());
|
||||
}
|
||||
if o.update_refs {
|
||||
args.push("--update-refs".into());
|
||||
}
|
||||
if let Some(autosquash) = o.autosquash {
|
||||
args.push(if autosquash { "--autosquash" } else { "--no-autosquash" }.into());
|
||||
}
|
||||
if let Some(onto) = o.onto.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
|
||||
args.extend(["--onto".into(), arg(onto, "revision")?]);
|
||||
}
|
||||
if let Some(upstream) = upstream {
|
||||
args.push(arg(upstream, "revision")?);
|
||||
} else {
|
||||
args.push("--root".into());
|
||||
}
|
||||
if let Some(branch) = o.branch.as_deref() {
|
||||
args.push(arg(branch, "branch")?);
|
||||
}
|
||||
args.push(arg(upstream, "revision")?);
|
||||
Ok(args)
|
||||
}
|
||||
|
||||
/// `git pull` arguments for the Pull dialog: `remote` and its `branches` (none = the
|
||||
/// upstream's configured merge branch).
|
||||
pub(crate) fn pull_args(
|
||||
remote: &str,
|
||||
branches: &[String],
|
||||
rebase: Option<bool>,
|
||||
o: &MergeOptions,
|
||||
) -> IdeResult<Vec<String>> {
|
||||
pub(crate) fn pull_args(remote: &str, branches: &[String], rebase: bool, o: &MergeOptions) -> IdeResult<Vec<String>> {
|
||||
let mut args: Vec<String> = vec!["pull".into(), "--progress".into()];
|
||||
if rebase == Some(true) {
|
||||
if rebase {
|
||||
if o.no_ff || o.ff_only || o.squash || o.no_commit {
|
||||
return Err(IdeError::invalid("--rebase cannot be combined with merge options"));
|
||||
}
|
||||
args.push("--rebase".into());
|
||||
} else if rebase == Some(false) {
|
||||
} else {
|
||||
args.push("--no-rebase".into());
|
||||
args.extend(merge_flags(o)?.into_iter().map(String::from));
|
||||
}
|
||||
args.extend(merge_flags(o)?.into_iter().map(String::from));
|
||||
args.push(arg(remote, "remote")?);
|
||||
for b in branches {
|
||||
args.push(arg(b, "branch")?);
|
||||
@@ -222,7 +171,6 @@ pub(crate) fn parse_worktrees(text: &str) -> Vec<Worktree> {
|
||||
main: out.is_empty(),
|
||||
locked: false,
|
||||
prunable: false,
|
||||
submodule: false,
|
||||
})
|
||||
}
|
||||
"HEAD" => {
|
||||
@@ -260,81 +208,33 @@ pub(crate) fn parse_worktrees(text: &str) -> Vec<Worktree> {
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
/// Git can list the repository's separate Git directory as the first worktree.
|
||||
fn main_worktree_checkout(&self, reported: &Path) -> Option<PathBuf> {
|
||||
let repo = self.gix().ok()?;
|
||||
let common = crate::repo::absolute(repo.common_dir()).ok()?;
|
||||
if reported != common {
|
||||
return None;
|
||||
}
|
||||
if self.git_dir == common {
|
||||
return Some(self.root().to_path_buf());
|
||||
}
|
||||
let configured = repo.config_snapshot().string("core.worktree")?;
|
||||
let path = crate::repo::absolute(&common.join(gix::path::from_bstr(&configured).ok()?)).ok()?;
|
||||
let main = Self::discover(&path).ok()??;
|
||||
(main.root() == path && main.git_dir == common).then_some(path)
|
||||
}
|
||||
|
||||
/// Merges `branches` into the current branch (Git › Merge…).
|
||||
pub fn merge_with(&self, branches: &[String], options: &MergeOptions) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let args = merge_args(branches, options)?;
|
||||
let args: Vec<&str> = args.iter().map(String::as_str).collect();
|
||||
crate::preserve::around(self, "Local changes saved before merge", || run(self.root(), &args, None).map(|_| ()))
|
||||
}
|
||||
|
||||
/// Tries the merge as requested. Smart Merge preserves local changes after user confirmation.
|
||||
pub fn merge_attempt(&self, branches: &[String], options: &MergeOptions, smart: bool) -> IdeResult<MergeOutcome> {
|
||||
let _scope = self.execution_scope();
|
||||
let branches = branches
|
||||
.iter()
|
||||
.map(|branch| crate::write::unambiguous_branch_name(self, branch.trim()).to_owned())
|
||||
.collect::<Vec<_>>();
|
||||
let args = merge_args(&branches, options)?;
|
||||
let args: Vec<_> = args.iter().map(String::as_str).collect();
|
||||
crate::write::merge_attempt(self, &args, options, smart)
|
||||
}
|
||||
|
||||
/// Predicts which tracked local changes a branch merge may have to save.
|
||||
pub fn merge_affected_files(&self, branch: &str) -> IdeResult<Vec<String>> {
|
||||
let _scope = self.execution_scope();
|
||||
crate::write::merge_affected_files(self, branch)
|
||||
}
|
||||
|
||||
/// Rebases the chosen branch or HEAD. Without an upstream, rebases from the root.
|
||||
pub fn rebase_with(&self, upstream: Option<&str>, options: &RebaseOptions) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
/// Rebases the current branch onto `upstream` (or `upstream..HEAD` onto `options.onto`).
|
||||
pub fn rebase_with(&self, upstream: &str, options: &RebaseOptions) -> IdeResult<()> {
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let args = rebase_args(upstream, options)?;
|
||||
self.validate_rebase(options)?;
|
||||
let args: Vec<&str> = args.iter().map(String::as_str).collect();
|
||||
crate::preserve::around(self, "Local changes saved before rebase", || run(self.root(), &args, None).map(|_| ()))
|
||||
}
|
||||
|
||||
pub(crate) fn validate_rebase(&self, options: &RebaseOptions) -> IdeResult<()> {
|
||||
if self.operation()?.is_some() {
|
||||
return Err(IdeError::invalid("another merge, rebase, cherry-pick or revert is in progress"));
|
||||
}
|
||||
if let Some(branch) = options.branch.as_deref() {
|
||||
let name = format!("refs/heads/{}", branch.trim());
|
||||
if self.gix()?.try_find_reference(name.as_str()).map_err(crate::repo::gx)?.is_none() {
|
||||
return Err(IdeError::invalid("Select an existing local branch to rebase."));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Git › Pull…: pulls `branches` of `remote` into the current branch.
|
||||
pub fn pull_from(
|
||||
&self,
|
||||
remote: &str,
|
||||
branches: &[String],
|
||||
rebase: Option<bool>,
|
||||
rebase: bool,
|
||||
options: &MergeOptions,
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let args = pull_args(remote, branches, rebase, options)?;
|
||||
let args: Vec<&str> = args.iter().map(String::as_str).collect();
|
||||
crate::preserve::around(self, "Local changes saved before update", || {
|
||||
@@ -344,7 +244,7 @@ impl Repo {
|
||||
|
||||
/// Manage Remotes: adds, removes or edits a remote.
|
||||
pub fn edit_remote(&self, edit: &RemoteEdit) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
match edit {
|
||||
RemoteEdit::Add { name, url } => {
|
||||
let (name, url) = (arg(name, "remote name")?, arg(url, "URL")?);
|
||||
@@ -368,29 +268,15 @@ impl Repo {
|
||||
|
||||
/// Working trees of the repository, the main one first.
|
||||
pub fn worktrees(&self) -> IdeResult<Vec<Worktree>> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let out = run(self.root(), &["worktree", "list", "--porcelain"], None)?;
|
||||
let mut trees = parse_worktrees(&out.stdout_str());
|
||||
if let Some(main) = trees.first_mut().filter(|main| main.head.is_some()) {
|
||||
if let Some(path) = self.main_worktree_checkout(&main.path) {
|
||||
main.path = path.into();
|
||||
}
|
||||
let parent = main.path.parent().and_then(|path| Self::discover(path).ok().flatten());
|
||||
let submodule =
|
||||
parent.and_then(|parent| parent.file_mode_at(&main.path, Some(":0")).ok().flatten()).as_deref()
|
||||
== Some("160000");
|
||||
if submodule {
|
||||
for tree in &mut trees {
|
||||
tree.submodule = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(trees)
|
||||
Ok(parse_worktrees(&out.stdout_str()))
|
||||
}
|
||||
|
||||
/// Checks out a local branch, a new branch, or a detached revision in a new worktree.
|
||||
/// Git › New Worktree…: checks out `commitish` at `path`, on a new branch `new_branch`
|
||||
/// when given (otherwise `commitish` must be a branch not checked out elsewhere).
|
||||
pub fn add_worktree(&self, path: &Path, commitish: &str, new_branch: Option<&str>) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let path = path.to_string_lossy().into_owned();
|
||||
let commitish = arg(commitish, "revision")?;
|
||||
let mut args: Vec<String> = vec!["worktree".into(), "add".into()];
|
||||
@@ -399,8 +285,6 @@ impl Repo {
|
||||
args.push("--no-track".into());
|
||||
}
|
||||
args.extend(["-b".into(), arg(b, "branch name")?]);
|
||||
} else if commitish.starts_with("refs/tags/") {
|
||||
args.push("--detach".into());
|
||||
}
|
||||
args.extend(["--".into(), path, commitish]);
|
||||
let args: Vec<&str> = args.iter().map(String::as_str).collect();
|
||||
@@ -410,7 +294,7 @@ impl Repo {
|
||||
/// Move Worktree…: moves a linked worktree's folder to exactly `to`. An empty folder there
|
||||
/// is replaced (Git would move the worktree inside it); any other existing `to` is refused.
|
||||
pub fn move_worktree(&self, path: &Path, to: &Path) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
if std::fs::symlink_metadata(to).is_ok() {
|
||||
let empty_dir = to.is_dir() && std::fs::read_dir(to).is_ok_and(|mut d| d.next().is_none());
|
||||
if !empty_dir {
|
||||
@@ -423,7 +307,7 @@ impl Repo {
|
||||
}
|
||||
|
||||
pub fn remove_worktree(&self, path: &Path, force: bool) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let path = path.to_string_lossy().into_owned();
|
||||
let mut args = vec!["worktree", "remove"];
|
||||
if force {
|
||||
@@ -432,17 +316,6 @@ impl Repo {
|
||||
args.extend(["--", &path]);
|
||||
run(self.root(), &args, None).map(|_| ())
|
||||
}
|
||||
|
||||
pub fn set_worktree_locked(&self, path: &Path, locked: bool) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let operation = if locked { "lock" } else { "unlock" };
|
||||
run(self.root(), &["worktree", operation, "--", &path.to_string_lossy()], None).map(|_| ())
|
||||
}
|
||||
|
||||
pub fn prune_worktrees(&self) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
run(self.root(), &["worktree", "prune", "--expire", "now"], None).map(|_| ())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -451,17 +324,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn merge_args_follow_the_options() {
|
||||
let o = MergeOptions {
|
||||
no_ff: true,
|
||||
no_verify: true,
|
||||
allow_unrelated_histories: true,
|
||||
message: Some("Merge it".into()),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(
|
||||
merge_args(&["dev".into()], &o).unwrap(),
|
||||
["merge", "--no-ff", "--no-verify", "--allow-unrelated-histories", "-m", "Merge it", "dev"]
|
||||
);
|
||||
let o = MergeOptions { no_ff: true, message: Some("Merge it".into()), ..Default::default() };
|
||||
assert_eq!(merge_args(&["dev".into()], &o).unwrap(), ["merge", "--no-ff", "-m", "Merge it", "dev"]);
|
||||
assert_eq!(
|
||||
merge_args(&["a".into(), "b".into()], &MergeOptions::default()).unwrap(),
|
||||
["merge", "--no-edit", "a", "b"]
|
||||
@@ -474,37 +338,18 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn rebase_and_pull_args() {
|
||||
let o = RebaseOptions { onto: Some("main".into()), rebase_merges: true, ..Default::default() };
|
||||
let o = RebaseOptions { onto: Some("main".into()), rebase_merges: true, keep_empty: false };
|
||||
assert_eq!(rebase_args("feature~3", &o).unwrap(), ["rebase", "--rebase-merges", "--onto", "main", "feature~3"]);
|
||||
assert_eq!(
|
||||
rebase_args(Some("feature~3"), &o).unwrap(),
|
||||
["rebase", "--rebase-merges", "--onto", "main", "feature~3"]
|
||||
);
|
||||
let root = RebaseOptions {
|
||||
onto: Some("main".into()),
|
||||
branch: Some("topic".into()),
|
||||
update_refs: true,
|
||||
autosquash: Some(false),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(
|
||||
rebase_args(None, &root).unwrap(),
|
||||
["rebase", "--update-refs", "--no-autosquash", "--onto", "main", "--root", "topic"]
|
||||
);
|
||||
assert!(rebase_args(Some("--quit"), &o).is_err());
|
||||
assert_eq!(
|
||||
pull_args("origin", &["main".into()], Some(false), &MergeOptions { ff_only: true, ..Default::default() })
|
||||
pull_args("origin", &["main".into()], false, &MergeOptions { ff_only: true, ..Default::default() })
|
||||
.unwrap(),
|
||||
["pull", "--progress", "--no-rebase", "--ff-only", "origin", "main"]
|
||||
);
|
||||
assert_eq!(
|
||||
pull_args("origin", &[], Some(true), &MergeOptions { no_verify: true, ..Default::default() }).unwrap(),
|
||||
["pull", "--progress", "--rebase", "--no-verify", "origin"]
|
||||
pull_args("origin", &[], true, &MergeOptions::default()).unwrap(),
|
||||
["pull", "--progress", "--rebase", "origin"]
|
||||
);
|
||||
assert_eq!(
|
||||
pull_args("origin", &["main".into()], None, &MergeOptions::default()).unwrap(),
|
||||
["pull", "--progress", "origin", "main"]
|
||||
);
|
||||
assert!(pull_args("origin", &[], Some(true), &MergeOptions { squash: true, ..Default::default() }).is_err());
|
||||
assert!(pull_args("origin", &[], true, &MergeOptions { squash: true, ..Default::default() }).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
+64
-246
@@ -3,13 +3,9 @@
|
||||
|
||||
use crate::cli::{self, run};
|
||||
use crate::repo::{gx, resolve};
|
||||
use crate::{
|
||||
ApplyCommitOptions, ChangeKind, ChangedFile, FileLineStats, MergeSides, RebaseAction, RebaseEntry, Repo, ResetMode,
|
||||
};
|
||||
use ide_core::workflow_settings::EmptyCherryPickAction;
|
||||
use crate::{ChangeKind, ChangedFile, FileLineStats, MergeSides, RebaseAction, RebaseEntry, Repo, ResetMode};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use std::collections::HashSet;
|
||||
use std::io::Write;
|
||||
|
||||
/// The in-progress operation git can continue / abort / skip.
|
||||
fn sequencer(r: &Repo) -> IdeResult<&'static str> {
|
||||
@@ -61,17 +57,12 @@ pub(crate) fn merge_sides(r: &Repo) -> IdeResult<MergeSides> {
|
||||
}
|
||||
Some("cherry-pick") => sides.commit = read("CHERRY_PICK_HEAD").map(short),
|
||||
Some("revert") => sides.commit = read("REVERT_HEAD").map(short),
|
||||
// Conflicts outside an operation come from restoring stashed changes (Smart
|
||||
// Checkout, local changes put aside for a merge or update): stage 2 is the new HEAD,
|
||||
// stage 3 the user's.
|
||||
None if !crate::write::unmerged_paths(r)?.is_empty() => {
|
||||
use crate::conflict_resolution::RestoreConflict;
|
||||
let (name, reversed) = match crate::conflict_resolution::restore_conflict(r)? {
|
||||
Some(RestoreConflict::ManualStash) => ("stash-apply", false),
|
||||
Some(RestoreConflict::AutomaticShelf) => ("unshelve", true),
|
||||
Some(RestoreConflict::PatchApply) => ("apply-patch", false),
|
||||
// During automatic restoration stage 2 is the new HEAD, stage 3 the user's work.
|
||||
None => ("unstash", true),
|
||||
};
|
||||
sides.operation = Some(name.into());
|
||||
sides.reversed = reversed;
|
||||
sides.operation = Some("unstash".into());
|
||||
sides.reversed = true;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
@@ -137,7 +128,7 @@ fn changed_paths(r: &Repo, args: &[&str]) -> IdeResult<Vec<String>> {
|
||||
/// `stage` first stages the changes of tracked files (Stage and Retry). Without it a
|
||||
/// rebase stages only edits of files already staged (made while resolving them) and
|
||||
/// otherwise fails with [`UNSTAGED_CHANGES_PREVENT_REBASE`].
|
||||
pub(crate) fn continue_op<T>(r: &Repo, stage: bool, run_command: impl FnOnce(&[&str]) -> IdeResult<T>) -> IdeResult<T> {
|
||||
pub(crate) fn continue_op(r: &Repo, stage: bool, cancel: &CancellationToken, out: &dyn Fn(String)) -> IdeResult<()> {
|
||||
let op = sequencer(r)?;
|
||||
let unresolved = unmerged_paths(r)?;
|
||||
if !unresolved.is_empty() {
|
||||
@@ -164,179 +155,102 @@ pub(crate) fn continue_op<T>(r: &Repo, stage: bool, run_command: impl FnOnce(&[&
|
||||
"revert" => &["revert", "--continue"],
|
||||
_ => &["am", "--continue"],
|
||||
};
|
||||
let result = run_command(args);
|
||||
let result = cli::run_streaming(r.root(), args, cancel, out);
|
||||
let finished = finish_operation(r);
|
||||
result.and_then(|value| finished.map(|()| value))
|
||||
result.and(finished)
|
||||
}
|
||||
|
||||
pub(crate) fn commit_apply_message(
|
||||
r: &Repo,
|
||||
message: &str,
|
||||
options: &ApplyCommitOptions,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let mut file = tempfile::NamedTempFile::new_in(&r.git_dir)?;
|
||||
file.write_all(message.as_bytes())?;
|
||||
let path = file.path().to_str().ok_or_else(|| IdeError::invalid("Invalid commit message file path"))?;
|
||||
let flags = crate::write::commit_metadata_flags(
|
||||
options.sign_off,
|
||||
options.run_hooks,
|
||||
options.author.as_deref(),
|
||||
options.author_date.as_deref(),
|
||||
);
|
||||
let mut args = vec!["commit", "--cleanup=whitespace", "-F", path];
|
||||
args.extend(flags.iter().map(String::as_str));
|
||||
cli::run_streaming(r.root(), &args, cancel, out)
|
||||
}
|
||||
|
||||
pub(crate) fn abort_op(
|
||||
r: &Repo,
|
||||
expected: Option<&str>,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
pub(crate) fn abort_op(r: &Repo, cancel: &CancellationToken, out: &dyn Fn(String)) -> IdeResult<()> {
|
||||
let op = sequencer(r)?;
|
||||
if expected.is_some_and(|expected| expected != op) {
|
||||
return Err(IdeError::invalid("Git operation changed before it could be aborted"));
|
||||
}
|
||||
let result = cli::run_streaming(r.root(), &[op, "--abort"], cancel, out);
|
||||
let finished = finish_operation(r);
|
||||
result.and(finished)
|
||||
}
|
||||
|
||||
pub(crate) fn finish_merge(
|
||||
r: &Repo,
|
||||
branch: Option<&str>,
|
||||
head: &str,
|
||||
target: &str,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let (current_branch, current_head) = r.head()?;
|
||||
let merge_head = std::fs::read_to_string(r.git_dir.join("MERGE_HEAD")).ok();
|
||||
if current_branch.as_deref() != branch
|
||||
|| current_head.as_deref() != Some(head)
|
||||
|| merge_head.as_deref().map(str::trim) != Some(target)
|
||||
{
|
||||
return Err(IdeError::invalid("The merge changed before it could be finished"));
|
||||
}
|
||||
let result = cli::run_streaming(r.root(), &["merge", "--continue"], cancel, out);
|
||||
let finished = finish_operation(r);
|
||||
result.and(finished)
|
||||
}
|
||||
|
||||
pub(crate) fn skip_op<T>(r: &Repo, run_command: impl FnOnce(&[&str]) -> IdeResult<T>) -> IdeResult<T> {
|
||||
pub(crate) fn skip_op(r: &Repo, cancel: &CancellationToken, out: &dyn Fn(String)) -> IdeResult<()> {
|
||||
let op = sequencer(r)?;
|
||||
if op == "merge" {
|
||||
return Err(IdeError::invalid("a merge cannot be skipped; abort it instead"));
|
||||
}
|
||||
let result = run_command(&[op, "--skip"]);
|
||||
let result = cli::run_streaming(r.root(), &[op, "--skip"], cancel, out);
|
||||
let finished = finish_operation(r);
|
||||
result.and_then(|value| finished.map(|()| value))
|
||||
result.and(finished)
|
||||
}
|
||||
|
||||
/// Merge commits need a mainline (`-m`), which IDEA doesn't offer for cherry-pick / revert.
|
||||
pub(crate) fn checked_apply_commits(r: &Repo, commits: &[String], verb: &str) -> IdeResult<Vec<String>> {
|
||||
check_commits(commits)?;
|
||||
fn reject_merges(r: &Repo, commits: &[String], verb: &str) -> IdeResult<()> {
|
||||
let repo = r.gix()?;
|
||||
commits
|
||||
.iter()
|
||||
.map(|c| {
|
||||
let commit = repo.find_object(resolve(&repo, c)?).map_err(gx)?.peel_to_commit().map_err(gx)?;
|
||||
for c in commits {
|
||||
let commit = repo.find_object(resolve(&repo, c)?).map_err(gx)?.peel_to_commit().map_err(gx)?;
|
||||
if commit.parent_ids().count() > 1 {
|
||||
let hex = commit.id.to_string();
|
||||
if commit.parent_ids().count() > 1 {
|
||||
return Err(IdeError::invalid(format!("cannot {verb} merge commit {}", &hex[..8])));
|
||||
}
|
||||
Ok(hex)
|
||||
})
|
||||
.collect()
|
||||
return Err(IdeError::invalid(format!("cannot {verb} merge commit {}", &hex[..8])));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn apply_cherry_pick(
|
||||
/// Applies `commits` on top of HEAD, in the given order (pass oldest first);
|
||||
/// `record_origin` adds "(cherry picked from commit …)" to their messages.
|
||||
pub(crate) fn cherry_pick(
|
||||
r: &Repo,
|
||||
commits: &[String],
|
||||
record_origin: bool,
|
||||
empty_action: EmptyCherryPickAction,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<u32> {
|
||||
) -> IdeResult<()> {
|
||||
check_commits(commits)?;
|
||||
reject_merges(r, commits, "cherry-pick")?;
|
||||
let mut args = vec!["cherry-pick"];
|
||||
if record_origin {
|
||||
args.push("-x");
|
||||
}
|
||||
args.extend(commits.iter().map(String::as_str));
|
||||
apply_resolving_empty(r, "cherry-pick", &args, empty_action, cancel, out)
|
||||
apply_skipping_empty(r, "cherry-pick", &args, cancel, out)
|
||||
}
|
||||
|
||||
/// Creates commits undoing `commits`, in the given order (pass newest first).
|
||||
pub(crate) fn revert(r: &Repo, commits: &[String], cancel: &CancellationToken, out: &dyn Fn(String)) -> IdeResult<()> {
|
||||
let commits = checked_apply_commits(r, commits, "revert")?;
|
||||
check_commits(commits)?;
|
||||
reject_merges(r, commits, "revert")?;
|
||||
let mut args = vec!["revert", "--no-edit"];
|
||||
args.extend(commits.iter().map(String::as_str));
|
||||
apply_resolving_empty(r, "revert", &args, EmptyCherryPickAction::Skip, cancel, out).map(|_| ())
|
||||
apply_skipping_empty(r, "revert", &args, cancel, out)
|
||||
}
|
||||
|
||||
/// Resolves empty steps while leaving conflicts and other failures to the caller.
|
||||
pub(crate) fn apply_resolving_empty(
|
||||
/// Runs a cherry-pick / revert sequence. A commit whose changes are already there leaves
|
||||
/// nothing to commit: it is skipped and the rest of the sequence goes on.
|
||||
fn apply_skipping_empty(
|
||||
r: &Repo,
|
||||
verb: &str,
|
||||
args: &[&str],
|
||||
action: EmptyCherryPickAction,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<u32> {
|
||||
let cherry_pick = verb == "cherry-pick";
|
||||
let head_file = if cherry_pick { "CHERRY_PICK_HEAD" } else { "REVERT_HEAD" };
|
||||
let is_empty = std::cell::Cell::new(false);
|
||||
let run = |args: &[&str]| {
|
||||
is_empty.set(false);
|
||||
cli::run_streaming(r.root(), args, cancel, &|line| {
|
||||
// Git runs with LC_ALL=C. An empty pick leaves a prepared commit message.
|
||||
is_empty.set(
|
||||
is_empty.get()
|
||||
|| line.contains("nothing to commit")
|
||||
|| line.contains("nothing added to commit but untracked files present")
|
||||
|| line.contains("previous cherry-pick is now empty"),
|
||||
);
|
||||
out(line);
|
||||
})
|
||||
) -> IdeResult<()> {
|
||||
let head_file = if verb == "revert" { "REVERT_HEAD" } else { "CHERRY_PICK_HEAD" };
|
||||
let said_nothing = std::cell::Cell::new(false);
|
||||
let watch = |line: String| {
|
||||
// git runs with LC_ALL=C; a single commit with nothing left to apply stops here.
|
||||
said_nothing.set(said_nothing.get() || line.contains("nothing to commit"));
|
||||
out(line)
|
||||
};
|
||||
let mut empty_count = 0;
|
||||
let mut result = run(args);
|
||||
let mut result = cli::run_streaming(r.root(), args, cancel, &watch);
|
||||
if result.is_err() && said_nothing.get() && r.branch_info()?.operation.is_none() {
|
||||
out("Skipped: its changes are already applied".into());
|
||||
return Ok(());
|
||||
}
|
||||
while result.is_err() && !cancel.is_cancelled() {
|
||||
let Ok(stopped) = std::fs::read_to_string(r.git_dir.join(head_file)) else {
|
||||
if is_empty.get() && action == EmptyCherryPickAction::Skip && r.operation()?.is_none() {
|
||||
out("Skipped: its changes are already applied".into());
|
||||
return Ok(empty_count + 1);
|
||||
}
|
||||
break;
|
||||
};
|
||||
if (cherry_pick && !is_empty.get())
|
||||
|| !unmerged_paths(r)?.is_empty()
|
||||
|| cli::run_raw(r.root(), &["diff", "--cached", "--quiet", "--"], None)?.code != Some(0)
|
||||
{
|
||||
let Ok(stopped) = std::fs::read_to_string(r.git_dir.join(head_file)) else { break };
|
||||
let empty = unmerged_paths(r)?.is_empty()
|
||||
&& cli::run_raw(r.root(), &["diff", "--cached", "--quiet", "HEAD", "--"], None)?.code == Some(0);
|
||||
if !empty {
|
||||
break;
|
||||
}
|
||||
let id = stopped.trim();
|
||||
let short = &id[..id.len().min(8)];
|
||||
empty_count += 1;
|
||||
match action {
|
||||
EmptyCherryPickAction::Skip => {
|
||||
out(format!("{short} skipped: its changes are already applied"));
|
||||
result = run(&[verb, "--skip"]);
|
||||
}
|
||||
EmptyCherryPickAction::CreateEmpty => {
|
||||
cli::run_streaming(r.root(), &["commit", "--allow-empty"], cancel, out)?;
|
||||
// The commit clears CHERRY_PICK_HEAD. A native multi-pick still has its todo.
|
||||
if !r.git_dir.join("sequencer/todo").is_file() {
|
||||
return Ok(empty_count);
|
||||
}
|
||||
result = run(&[verb, "--continue"]);
|
||||
}
|
||||
}
|
||||
out(format!("{} skipped: its changes are already applied", &id[..id.len().min(8)]));
|
||||
result = cli::run_streaming(r.root(), &[verb, "--skip"], cancel, out);
|
||||
}
|
||||
result.map(|()| empty_count)
|
||||
result
|
||||
}
|
||||
|
||||
pub(crate) fn reset(
|
||||
@@ -415,6 +329,7 @@ pub(crate) fn interactive_rebase(
|
||||
let work = r.git_dir.join("openidea-rebase");
|
||||
let _ = std::fs::remove_dir_all(&work);
|
||||
std::fs::create_dir_all(&work)?;
|
||||
let quote = |p: &std::path::Path| format!("'{}'", p.to_string_lossy().replace('\\', "/").replace('\'', "'\\''"));
|
||||
let mut todo = String::new();
|
||||
for (i, (e, id)) in entries.iter().zip(&ids).enumerate() {
|
||||
let verb = match e.action {
|
||||
@@ -429,8 +344,7 @@ pub(crate) fn interactive_rebase(
|
||||
let next_joins =
|
||||
entries.get(i + 1).is_some_and(|n| matches!(n.action, RebaseAction::Squash | RebaseAction::Fixup));
|
||||
let message = e.message.as_deref().map(str::trim).filter(|m| !m.is_empty());
|
||||
let wants_message =
|
||||
matches!(e.action, RebaseAction::Reword | RebaseAction::Squash | RebaseAction::Fixup | RebaseAction::Pick);
|
||||
let wants_message = matches!(e.action, RebaseAction::Reword | RebaseAction::Squash | RebaseAction::Pick);
|
||||
if let Some(m) = message.filter(|_| wants_message) {
|
||||
if next_joins {
|
||||
return Err(IdeError::invalid(
|
||||
@@ -441,34 +355,20 @@ pub(crate) fn interactive_rebase(
|
||||
std::fs::write(&file, m)?;
|
||||
todo.push_str(&format!(
|
||||
"exec git commit --amend --allow-empty --no-verify --quiet --cleanup=whitespace -F {}\n",
|
||||
quote_for_shell(&file)
|
||||
quote(&file)
|
||||
));
|
||||
}
|
||||
}
|
||||
let args = ["rebase", "--interactive", "--no-autosquash", base.unwrap_or("--root")];
|
||||
run_rebase_todo(r, &work, &todo, &args, cancel, out)
|
||||
}
|
||||
|
||||
pub(crate) fn quote_for_shell(path: &std::path::Path) -> String {
|
||||
format!("'{}'", path.to_string_lossy().replace('\\', "/").replace('\'', "'\\''"))
|
||||
}
|
||||
|
||||
pub(crate) fn run_rebase_todo(
|
||||
r: &Repo,
|
||||
work: &std::path::Path,
|
||||
todo: &str,
|
||||
args: &[&str],
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let todo_file = work.join("todo");
|
||||
std::fs::write(&todo_file, todo)?;
|
||||
let editor = format!("cp {}", quote_for_shell(&todo_file));
|
||||
let editor = format!("cp {}", quote(&todo_file));
|
||||
// Local changes are put aside and restored when the rebase is over, staged ones as
|
||||
// staged (git's --autostash would bring them all back unstaged).
|
||||
crate::preserve::save(r, "Local changes saved before rebase")?;
|
||||
let mut args = vec!["rebase", "--interactive", "--no-autosquash"];
|
||||
args.push(base.unwrap_or("--root"));
|
||||
let env = [("GIT_SEQUENCE_EDITOR", std::ffi::OsStr::new(&editor))];
|
||||
let result = cli::run_streaming_env(r.root(), args, &env, cancel, out);
|
||||
let result = cli::run_streaming_env(r.root(), &args, &env, cancel, out);
|
||||
// A stopped rebase still needs the message files for its remaining `exec` lines.
|
||||
let finished = finish_operation(r);
|
||||
result.and(finished)
|
||||
@@ -480,7 +380,6 @@ pub(crate) fn finish_operation(r: &Repo) -> IdeResult<()> {
|
||||
if r.branch_info()?.operation.is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
crate::cherry_pick_plan::clear(r);
|
||||
let _ = std::fs::remove_dir_all(r.git_dir.join("openidea-rebase"));
|
||||
crate::preserve::restore(r)
|
||||
}
|
||||
@@ -545,95 +444,14 @@ pub(crate) fn push_tag(
|
||||
delete: bool,
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<crate::PushReport> {
|
||||
) -> IdeResult<()> {
|
||||
let tag = tag_ref(name)?;
|
||||
remote_push_urls(r, remote, cancel)?;
|
||||
let spec = if delete { format!(":{tag}") } else { format!("{tag}:{tag}") };
|
||||
let mut report = crate::PushReport::new(Some(remote.to_owned()));
|
||||
crate::push_report::run(
|
||||
&mut report,
|
||||
r.root(),
|
||||
&["push", "--progress", "--porcelain", "--", remote, &spec],
|
||||
cancel,
|
||||
on_output,
|
||||
)?;
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
pub(crate) fn remote_fetch_url(r: &Repo, remote: &str, cancel: &CancellationToken) -> IdeResult<String> {
|
||||
let output = cli::run_cancellable(r.root(), &["remote", "get-url", "--", remote], cancel)?;
|
||||
output
|
||||
.stdout_str()
|
||||
.lines()
|
||||
.next()
|
||||
.filter(|url| !url.is_empty())
|
||||
.map(str::to_owned)
|
||||
.ok_or_else(|| IdeError::invalid(format!("remote '{remote}' has no fetch URL")))
|
||||
}
|
||||
|
||||
pub(crate) fn remote_push_urls(r: &Repo, remote: &str, cancel: &CancellationToken) -> IdeResult<Vec<String>> {
|
||||
let remote = remote.trim();
|
||||
if remote.is_empty() || remote.starts_with('-') {
|
||||
return Err(IdeError::invalid(format!("invalid remote '{remote}'")));
|
||||
}
|
||||
let output = cli::run_cancellable(r.root(), &["remote", "get-url", "--push", "--all", remote], cancel)?;
|
||||
let urls: Vec<_> = output.stdout_str().lines().filter(|url| !url.is_empty()).map(str::to_owned).collect();
|
||||
if urls.is_empty() {
|
||||
return Err(IdeError::invalid(format!("remote '{remote}' has no push URL")));
|
||||
}
|
||||
Ok(urls)
|
||||
}
|
||||
|
||||
pub(crate) fn delete_tag_on_remotes(
|
||||
r: &Repo,
|
||||
deleted: &crate::DeletedTag,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let tag = tag_ref(&deleted.name)?;
|
||||
let expected = gix::ObjectId::from_hex(deleted.target.as_bytes()).map_err(gx)?.to_string();
|
||||
let lease = format!("--force-with-lease={tag}:{expected}");
|
||||
let deletion = format!(":{tag}");
|
||||
let mut failures = Vec::new();
|
||||
for remote in r.remotes()? {
|
||||
out(format!("Checking tag {} on {}", deleted.name, remote.name));
|
||||
let urls = match remote_push_urls(r, &remote.name, cancel) {
|
||||
Ok(urls) => urls,
|
||||
Err(e) if cancel.is_cancelled() => return Err(e),
|
||||
Err(e) => {
|
||||
failures.push(format!("{}: {e}", remote.name));
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let receive_pack =
|
||||
if urls.len() > 1 { r.config_get(&format!("remote.{}.receivepack", remote.name))? } else { None };
|
||||
for url in &urls {
|
||||
let push_target = if urls.len() == 1 { remote.name.as_str() } else { url.as_str() };
|
||||
let result = (|| {
|
||||
let args = ["ls-remote", "--exit-code", "--refs", "--tags", "--", url, &tag];
|
||||
let refs = cli::run_cancellable_raw(r.root(), &args, cancel)?;
|
||||
if !matches!(refs.code, Some(0 | 2)) {
|
||||
return Err(cli::failure(&args, &refs.stderr, &refs.stdout, refs.code));
|
||||
}
|
||||
if !refs.stdout_str().lines().any(|line| line.split_once('\t').is_some_and(|(_, name)| name == tag)) {
|
||||
out(format!("Tag {} is already absent on {}", deleted.name, remote.name));
|
||||
return Ok(());
|
||||
}
|
||||
let mut args = vec!["push", "--progress", &lease];
|
||||
if let Some(receive_pack) = receive_pack.as_deref() {
|
||||
args.extend(["--receive-pack", receive_pack]);
|
||||
}
|
||||
args.extend(["--", push_target, &deletion]);
|
||||
cli::run_streaming(r.root(), &args, cancel, out)
|
||||
})();
|
||||
if let Err(e) = result {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(e);
|
||||
}
|
||||
failures.push(format!("{}: {e}", remote.name));
|
||||
}
|
||||
}
|
||||
}
|
||||
if failures.is_empty() { Ok(()) } else { Err(IdeError::invalid(failures.join("\n"))) }
|
||||
let spec = if delete { format!(":{tag}") } else { format!("{tag}:{tag}") };
|
||||
cli::run_streaming(r.root(), &["push", "--progress", remote, &spec], cancel, on_output)
|
||||
}
|
||||
|
||||
/// Tag names, sorted.
|
||||
|
||||
+41
-540
@@ -2,23 +2,37 @@
|
||||
//! and applying them (falling back to a 3-way merge that leaves conflicts for the
|
||||
//! merge UI), as Create Patch / Apply Patch / Shelve do in IDEA.
|
||||
|
||||
use crate::cli::{self, TempIndex, run, run_env};
|
||||
use crate::cli::{self, run, run_env};
|
||||
use crate::repo::gx;
|
||||
use crate::{ApplyOutcome, ChangeKind, ChangedFile, PatchFile, Repo, Repos, StagingPatchEntry, StagingPatchSide};
|
||||
use crate::{ApplyOutcome, ChangeKind, ChangedFile, PatchFile, Repo};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::collections::{BTreeMap, BTreeSet, HashSet};
|
||||
use std::ffi::OsStr;
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
pub(crate) mod file_diff;
|
||||
mod mapping;
|
||||
pub use mapping::{
|
||||
MappedPatch, PatchDirectoryMatches, PatchDirectoryScope, PatchPathMapping, PatchPlacement,
|
||||
discover_patch_directories,
|
||||
};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicU32, Ordering};
|
||||
|
||||
const EMPTY_TREE: &str = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
|
||||
|
||||
/// A throwaway index file in `.git`, removed on drop.
|
||||
struct TempIndex(PathBuf);
|
||||
|
||||
impl TempIndex {
|
||||
fn new(r: &Repo) -> Self {
|
||||
static SEQ: AtomicU32 = AtomicU32::new(0);
|
||||
let n = SEQ.fetch_add(1, Ordering::Relaxed);
|
||||
TempIndex(r.git_dir.join(format!("openidea-index-{}-{n}", std::process::id())))
|
||||
}
|
||||
fn env(&self) -> [(&'static str, &OsStr); 1] {
|
||||
[("GIT_INDEX_FILE", self.0.as_os_str())]
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TempIndex {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.0);
|
||||
let _ = std::fs::remove_file(self.0.with_extension("lock"));
|
||||
}
|
||||
}
|
||||
|
||||
/// Binary-safe patch of the working-tree changes (staged or not, untracked files
|
||||
/// included) of `rel_paths` against HEAD, plus the files it touches (renames split
|
||||
/// into delete + add). The real index is left untouched.
|
||||
@@ -27,16 +41,6 @@ pub(crate) fn working_patch(
|
||||
rel_paths: &[String],
|
||||
reverse: bool,
|
||||
detect_renames: bool,
|
||||
) -> IdeResult<(String, Vec<ChangedFile>)> {
|
||||
working_patch_with_prefix(r, rel_paths, reverse, detect_renames, None)
|
||||
}
|
||||
|
||||
pub(crate) fn working_patch_with_prefix(
|
||||
r: &Repo,
|
||||
rel_paths: &[String],
|
||||
reverse: bool,
|
||||
detect_renames: bool,
|
||||
prefix: Option<&str>,
|
||||
) -> IdeResult<(String, Vec<ChangedFile>)> {
|
||||
if rel_paths.is_empty() {
|
||||
return Err(IdeError::invalid("no files selected"));
|
||||
@@ -62,115 +66,11 @@ pub(crate) fn working_patch_with_prefix(
|
||||
if reverse {
|
||||
diff.push("-R");
|
||||
}
|
||||
let prefixes = prefix.map(|prefix| [format!("--src-prefix=a/{prefix}"), format!("--dst-prefix=b/{prefix}")]);
|
||||
if let Some(prefixes) = &prefixes {
|
||||
diff.extend(prefixes.iter().map(String::as_str));
|
||||
}
|
||||
let patch = lossless_diff(r, &diff, &env)?;
|
||||
let names = run_env(r.root(), &["diff", "--cached", "--name-status", "-z", "--no-renames"], None, &env)?;
|
||||
Ok((patch, crate::ops::parse_name_status(&names.stdout_str())))
|
||||
}
|
||||
|
||||
pub(crate) fn staging_patch(r: &Repo, entries: &[StagingPatchEntry], reverse: bool, prefix: &str) -> IdeResult<String> {
|
||||
use StagingPatchSide::{Both, Staged, Unstaged};
|
||||
let mut selected = BTreeMap::new();
|
||||
for entry in entries {
|
||||
let path = r.given_rel_path(&entry.path.0)?;
|
||||
let old = entry.renamed_from.as_ref().map(|old| r.given_rel_path(&old.0)).transpose()?;
|
||||
if path.is_empty() || old.as_deref() == Some("") {
|
||||
return Err(IdeError::invalid("no files selected"));
|
||||
}
|
||||
let (side, names) = selected.entry(path.clone()).or_insert_with(|| (entry.side, BTreeSet::new()));
|
||||
if *side != entry.side {
|
||||
*side = Both;
|
||||
}
|
||||
names.extend(old.into_iter().chain([path]));
|
||||
}
|
||||
if selected.is_empty() {
|
||||
return Err(IdeError::invalid("no files selected"));
|
||||
}
|
||||
|
||||
let repo = r.gix()?;
|
||||
let head = r.head()?.1.unwrap_or_else(|| repo.object_hash().empty_tree().to_string());
|
||||
let index = TempIndex::new(r);
|
||||
let env = index.env();
|
||||
match std::fs::copy(repo.index_path(), index.path()) {
|
||||
Ok(_) => {}
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
|
||||
run_env(r.root(), &["read-tree", "--empty"], None, &env)?;
|
||||
}
|
||||
Err(error) => return Err(error.into()),
|
||||
}
|
||||
|
||||
// An intent-to-add entry lets Git diff an untracked file against an absent index
|
||||
// version, without staging its content or changing the user's index.
|
||||
let worktree: BTreeSet<_> =
|
||||
selected.values().filter(|(side, _)| *side != Staged).flat_map(|(_, names)| names).collect();
|
||||
if !worktree.is_empty() {
|
||||
let tracked = run_env(r.root(), &["ls-files", "--cached", "-z"], None, &env)?.stdout;
|
||||
let tracked: HashSet<_> = tracked.split(|byte| *byte == 0).collect();
|
||||
let untracked: Vec<_> = worktree
|
||||
.into_iter()
|
||||
.filter(|path| !tracked.contains(path.as_bytes()) && r.root().join(path).symlink_metadata().is_ok())
|
||||
.cloned()
|
||||
.collect();
|
||||
if !untracked.is_empty() {
|
||||
cli::run_paths_env(
|
||||
r.root(),
|
||||
&["--literal-pathspecs", "add", "--intent-to-add", "--"],
|
||||
&untracked,
|
||||
None,
|
||||
&env,
|
||||
)?;
|
||||
}
|
||||
}
|
||||
|
||||
// Git swaps custom prefixes along with the endpoints under -R.
|
||||
let (a, b) = if reverse { ("b", "a") } else { ("a", "b") };
|
||||
let src = format!("--src-prefix={a}/{prefix}");
|
||||
let dst = format!("--dst-prefix={b}/{prefix}");
|
||||
let mut options = vec![
|
||||
"--literal-pathspecs",
|
||||
"diff",
|
||||
"--binary",
|
||||
"--full-index",
|
||||
"-M",
|
||||
"--no-color",
|
||||
"--no-ext-diff",
|
||||
"--no-textconv",
|
||||
"--ita-invisible-in-index",
|
||||
&src,
|
||||
&dst,
|
||||
];
|
||||
if reverse {
|
||||
options.push("-R");
|
||||
}
|
||||
let mut patch = String::new();
|
||||
let sides = if reverse { [Both, Unstaged, Staged] } else { [Staged, Unstaged, Both] };
|
||||
for side in sides {
|
||||
let paths: Vec<_> = selected
|
||||
.values()
|
||||
.filter(|(selected, _)| *selected == side)
|
||||
.flat_map(|(_, names)| names.iter().cloned())
|
||||
.collect::<BTreeSet<_>>()
|
||||
.into_iter()
|
||||
.collect();
|
||||
if paths.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let mut args = options.clone();
|
||||
if side == Staged {
|
||||
args.push("--cached");
|
||||
}
|
||||
if side != Unstaged {
|
||||
args.push(&head);
|
||||
}
|
||||
args.push("--");
|
||||
patch.push_str(&selected_diff(r, args, &paths, prefix, &env)?);
|
||||
}
|
||||
Ok(patch)
|
||||
}
|
||||
|
||||
/// The changes of `commits` (oldest first), each against its first parent.
|
||||
pub(crate) fn commits_patch(r: &Repo, commits: &[String], reverse: bool) -> IdeResult<String> {
|
||||
if commits.is_empty() {
|
||||
@@ -196,193 +96,11 @@ pub(crate) fn commits_patch(r: &Repo, commits: &[String], reverse: bool) -> IdeR
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// An automatic Shelf snapshot follows the same per-path layout as a manually created shelf.
|
||||
pub(crate) fn shelf_tree_patch_with_prefix(r: &Repo, base: &str, tree: &str, prefix: &str) -> IdeResult<String> {
|
||||
lossless_diff(
|
||||
r,
|
||||
&[
|
||||
"diff",
|
||||
"--binary",
|
||||
"--full-index",
|
||||
"--no-renames",
|
||||
"--no-color",
|
||||
"--no-ext-diff",
|
||||
"--no-textconv",
|
||||
&format!("--src-prefix=a/{prefix}"),
|
||||
&format!("--dst-prefix=b/{prefix}"),
|
||||
base,
|
||||
tree,
|
||||
"--",
|
||||
],
|
||||
&[],
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn revisions_patch(r: &Repo, before: &str, after: &str, paths: &[PathBuf]) -> IdeResult<String> {
|
||||
if [before, after].iter().any(|rev| rev.trim().is_empty() || rev.starts_with('-')) {
|
||||
return Err(IdeError::invalid("invalid revision"));
|
||||
}
|
||||
let paths = paths.iter().map(|path| r.given_rel_path(path)).collect::<IdeResult<Vec<_>>>()?;
|
||||
if paths.is_empty() || paths.iter().any(String::is_empty) {
|
||||
return Err(IdeError::invalid("no files selected"));
|
||||
}
|
||||
let empty_tree = if before == EMPTY_TREE || after == EMPTY_TREE {
|
||||
r.gix()?.object_hash().empty_tree().to_string()
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
let before = if before == EMPTY_TREE { empty_tree.as_str() } else { before };
|
||||
let after = if after == EMPTY_TREE { empty_tree.as_str() } else { after };
|
||||
let args = vec![
|
||||
"--literal-pathspecs",
|
||||
"diff",
|
||||
"--binary",
|
||||
"--full-index",
|
||||
"-M",
|
||||
"--no-color",
|
||||
"--no-ext-diff",
|
||||
"--no-textconv",
|
||||
"--src-prefix=a/",
|
||||
"--dst-prefix=b/",
|
||||
before,
|
||||
after,
|
||||
"--",
|
||||
];
|
||||
selected_diff(r, args, &paths, "", &[])
|
||||
}
|
||||
|
||||
fn selected_diff<'a>(
|
||||
r: &Repo,
|
||||
mut args: Vec<&'a str>,
|
||||
paths: &'a [String],
|
||||
prefix: &str,
|
||||
env: &[(&str, &OsStr)],
|
||||
) -> IdeResult<String> {
|
||||
// The long-selection fallback keeps both sides of a rename in the same diff.
|
||||
if cli::batch_paths(cli::base_command_line_len(&args), paths, cli::command_line_limit()).len() > 1 {
|
||||
let diff = prefix_rename_headers(lossless_diff(r, &args, env)?, prefix);
|
||||
let selected: HashSet<_> = paths.iter().map(|path| format!("{prefix}{path}")).collect();
|
||||
return Ok(sections(&diff)
|
||||
.into_iter()
|
||||
.filter(|(_, file)| {
|
||||
selected.contains(file.path.as_str()) || file.old_path.as_deref().is_some_and(|p| selected.contains(p))
|
||||
})
|
||||
.map(|(section, _)| section)
|
||||
.collect());
|
||||
}
|
||||
args.extend(paths.iter().map(String::as_str));
|
||||
lossless_diff(r, &args, env).map(|patch| prefix_rename_headers(patch, prefix))
|
||||
}
|
||||
|
||||
/// Git's --src-prefix and --dst-prefix cover file headers, but not rename metadata.
|
||||
fn prefix_rename_headers(patch: String, prefix: &str) -> String {
|
||||
if prefix.is_empty() {
|
||||
return patch;
|
||||
}
|
||||
let mut out = String::with_capacity(patch.len());
|
||||
for line in patch.split_inclusive('\n') {
|
||||
if let Some((tag, path)) =
|
||||
["rename from ", "rename to "].into_iter().find_map(|tag| line.strip_prefix(tag).map(|path| (tag, path)))
|
||||
{
|
||||
let path = git_path(path.trim_end_matches('\n'));
|
||||
out.push_str(tag);
|
||||
out.push_str(&crate::diff::quote_path(&format!("{prefix}{path}")));
|
||||
out.push('\n');
|
||||
} else {
|
||||
out.push_str(line);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub(crate) fn sections(patch: &str) -> Vec<(&str, PatchFile)> {
|
||||
let mut starts: Vec<_> = patch
|
||||
.match_indices("diff --git ")
|
||||
.filter(|(i, _)| *i == 0 || patch.as_bytes()[i - 1] == b'\n')
|
||||
.map(|(i, _)| i)
|
||||
.collect();
|
||||
if starts.is_empty() {
|
||||
let (mut old, mut new) = (0u32, 0u32);
|
||||
let mut offset = 0;
|
||||
let mut lines = patch.split_inclusive('\n').peekable();
|
||||
while let Some(line) = lines.next() {
|
||||
if old > 0 || new > 0 {
|
||||
match line.as_bytes().first() {
|
||||
Some(b'-') => old = old.saturating_sub(1),
|
||||
Some(b'+') => new = new.saturating_sub(1),
|
||||
Some(b' ') => {
|
||||
old = old.saturating_sub(1);
|
||||
new = new.saturating_sub(1);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
} else if line.starts_with("--- ") && lines.peek().is_some_and(|l| l.starts_with("+++ ")) {
|
||||
starts.push(offset);
|
||||
}
|
||||
if let Some(range) = line.strip_prefix("@@ ") {
|
||||
let mut parts = range.split_whitespace();
|
||||
let count = |s: &str| s.split_once(',').map_or(1, |(_, n)| n.parse().unwrap_or(0));
|
||||
old = parts.next().map(count).unwrap_or(0);
|
||||
new = parts.next().map(count).unwrap_or(0);
|
||||
}
|
||||
offset += line.len();
|
||||
}
|
||||
}
|
||||
starts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(n, &start)| {
|
||||
let section = &patch[start..starts.get(n + 1).copied().unwrap_or(patch.len())];
|
||||
parse_patch(section).into_iter().next().map(|file| (section, file))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Changes the base of an exported patch without modifying its hunks or binary payloads.
|
||||
pub fn rebase_patch(patch: &str, root: &Path, prefix: &str, base: &Path) -> IdeResult<String> {
|
||||
if patch.is_empty() || (root == base && prefix.is_empty()) {
|
||||
return Ok(patch.to_owned());
|
||||
}
|
||||
let patch = normalized(patch)?;
|
||||
let sections = sections(&patch);
|
||||
let Some((first, _)) = sections.first() else {
|
||||
return Err(IdeError::invalid("no file changes found in the patch"));
|
||||
};
|
||||
let relative = |path: &str| {
|
||||
let path = path
|
||||
.strip_prefix(prefix)
|
||||
.map(Path::new)
|
||||
.filter(|path| valid_patch_path(path))
|
||||
.ok_or_else(|| IdeError::invalid("The patch contains a path outside its repository"))?;
|
||||
root.join(path)
|
||||
.strip_prefix(base)
|
||||
.ok()
|
||||
.filter(|path| valid_patch_path(path))
|
||||
.map(ide_core::ipc_path::to_ipc)
|
||||
.ok_or_else(|| IdeError::invalid("The base directory must contain every selected path"))
|
||||
};
|
||||
let mut output = String::with_capacity(patch.len());
|
||||
if let Some((preamble, _)) = patch.split_once(*first) {
|
||||
output.push_str(preamble);
|
||||
}
|
||||
for (section, file) in sections {
|
||||
let before = relative(file.old_path.as_deref().unwrap_or(&file.path))?;
|
||||
let after = relative(&file.path)?;
|
||||
mapping::rewrite_headers(&mut output, section, &before, &after, false);
|
||||
}
|
||||
Ok(output)
|
||||
}
|
||||
|
||||
fn normalized(patch: &str) -> IdeResult<String> {
|
||||
if patch.trim().is_empty() {
|
||||
return Err(IdeError::invalid("the patch is empty"));
|
||||
}
|
||||
// Git emits LF headers even when the hunk payload contains CRLF lines.
|
||||
let crlf_headers = patch
|
||||
.split('\n')
|
||||
.find(|line| line.starts_with("diff --git ") || line.starts_with("--- "))
|
||||
.is_some_and(|line| line.ends_with('\r'));
|
||||
let mut p = if crlf_headers { patch.replace("\r\n", "\n") } else { patch.to_string() };
|
||||
let mut p = patch.replace("\r\n", "\n");
|
||||
if !p.ends_with('\n') {
|
||||
p.push('\n');
|
||||
}
|
||||
@@ -391,25 +109,17 @@ fn normalized(patch: &str) -> IdeResult<String> {
|
||||
|
||||
/// The files of a patch, whether each applies cleanly to the working tree.
|
||||
pub(crate) fn preview(r: &Repo, patch: &str) -> IdeResult<Vec<PatchFile>> {
|
||||
preview_with_prefix(r, patch, "")
|
||||
}
|
||||
|
||||
fn preview_with_prefix(r: &Repo, patch: &str, prefix: &str) -> IdeResult<Vec<PatchFile>> {
|
||||
let patch = normalized(patch)?;
|
||||
let mut files = parse_patch(&patch);
|
||||
if files.is_empty() {
|
||||
return Err(IdeError::invalid("no file changes found in the patch"));
|
||||
}
|
||||
let strip = strip_option(prefix);
|
||||
let mut args = vec!["apply", "--check", "--binary"];
|
||||
args.extend(strip.as_deref());
|
||||
args.push("-");
|
||||
let out = cli::run_raw(r.root(), &args, Some(patch.as_bytes()))?;
|
||||
let out = cli::run_raw(r.root(), &["apply", "--check", "--binary", "-"], Some(patch.as_bytes()))?;
|
||||
if out.code != Some(0) {
|
||||
let err = String::from_utf8_lossy(&out.stderr).into_owned();
|
||||
let failing = failing_paths(&err);
|
||||
for f in &mut files {
|
||||
let hit = |p: &str| failing.iter().any(|x| x == p.strip_prefix(prefix).unwrap_or(p));
|
||||
let hit = |p: &str| failing.iter().any(|x| x == p);
|
||||
f.applies = !(hit(&f.path) || f.old_path.as_deref().is_some_and(hit));
|
||||
}
|
||||
// An error we could not attribute to a file: nothing applies cleanly.
|
||||
@@ -417,30 +127,9 @@ fn preview_with_prefix(r: &Repo, patch: &str, prefix: &str) -> IdeResult<Vec<Pat
|
||||
files.iter_mut().for_each(|f| f.applies = false);
|
||||
}
|
||||
}
|
||||
for file in &mut files {
|
||||
if let Some(base) = file.old_path.as_deref().unwrap_or(&file.path).strip_prefix(prefix) {
|
||||
file.missing_base = missing_patch_base(r.root(), file, base);
|
||||
}
|
||||
}
|
||||
Ok(files)
|
||||
}
|
||||
|
||||
fn valid_patch_path(path: &Path) -> bool {
|
||||
!path.as_os_str().is_empty()
|
||||
&& path
|
||||
.components()
|
||||
.all(|part| matches!(part, std::path::Component::Normal(name) if !name.eq_ignore_ascii_case(".git")))
|
||||
}
|
||||
|
||||
fn patch_file_exists(path: &Path) -> bool {
|
||||
std::fs::symlink_metadata(path).is_ok_and(|metadata| metadata.is_file() || metadata.is_symlink())
|
||||
}
|
||||
|
||||
fn missing_patch_base(root: &Path, file: &PatchFile, before: &str) -> bool {
|
||||
let before = Path::new(before);
|
||||
file.kind != ChangeKind::Added && valid_patch_path(before) && !patch_file_exists(&root.join(before))
|
||||
}
|
||||
|
||||
/// Paths named in `git apply` errors (`error: path: …`, `error: patch failed: path:12`).
|
||||
fn failing_paths(stderr: &str) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
@@ -461,196 +150,19 @@ fn failing_paths(stderr: &str) -> Vec<String> {
|
||||
/// merge is attempted; conflicting files are left with conflict markers and index
|
||||
/// stages for the merge UI and returned in [`ApplyOutcome::conflicts`].
|
||||
pub(crate) fn apply(r: &Repo, patch: &str) -> IdeResult<ApplyOutcome> {
|
||||
apply_with_prefix(r, patch, "")
|
||||
}
|
||||
|
||||
/// Keep complete file sections, including rename metadata and binary payloads.
|
||||
pub(crate) fn apply_selected(r: &Repo, patch: &str, paths: &[String]) -> IdeResult<ApplyOutcome> {
|
||||
let patch = normalized(patch)?;
|
||||
let selected: String = selected_sections(&patch, Some(paths))?.into_iter().map(|(section, _)| section).collect();
|
||||
apply_for_review(r, &selected, "")
|
||||
}
|
||||
|
||||
fn selected_sections<'a>(patch: &'a str, paths: Option<&[String]>) -> IdeResult<Vec<(&'a str, PatchFile)>> {
|
||||
let mut sections = sections(patch);
|
||||
let Some(paths) = paths else { return Ok(sections) };
|
||||
if paths.is_empty() {
|
||||
return Err(IdeError::invalid("select files to apply from the patch"));
|
||||
}
|
||||
let paths: HashSet<_> = paths.iter().map(String::as_str).collect();
|
||||
let mut remaining = paths.clone();
|
||||
sections.retain(|(_, file)| {
|
||||
remaining.remove(file.path.as_str());
|
||||
paths.contains(file.path.as_str())
|
||||
});
|
||||
if !remaining.is_empty() {
|
||||
return Err(IdeError::invalid("the selection contains files outside the patch"));
|
||||
}
|
||||
Ok(sections)
|
||||
}
|
||||
|
||||
/// An apply plan with paths based at a common project directory.
|
||||
pub struct ProjectPatch {
|
||||
pub base: PathBuf,
|
||||
pub groups: Vec<ProjectPatchGroup>,
|
||||
}
|
||||
|
||||
pub struct ProjectPatchGroup {
|
||||
pub root: PathBuf,
|
||||
prefix: String,
|
||||
patch: String,
|
||||
}
|
||||
|
||||
impl ProjectPatchGroup {
|
||||
pub fn preview(&self, r: &Repo) -> IdeResult<Vec<PatchFile>> {
|
||||
let _scope = r.execution_scope();
|
||||
preview_with_prefix(r, &self.patch, &self.prefix)
|
||||
}
|
||||
|
||||
pub fn apply(&self, r: &Repo) -> IdeResult<ApplyOutcome> {
|
||||
let _scope = r.execution_scope();
|
||||
let outcome = apply_for_review(r, &self.patch, &self.prefix)?;
|
||||
let based = |paths: Vec<String>| paths.into_iter().map(|path| format!("{}{path}", self.prefix)).collect();
|
||||
Ok(ApplyOutcome { applied: based(outcome.applied), conflicts: based(outcome.conflicts) })
|
||||
}
|
||||
|
||||
pub fn file_diff(
|
||||
&self,
|
||||
r: &Repo,
|
||||
path: &str,
|
||||
encoding: &dyn Fn(&Path, &[u8]) -> crate::TextEncoding,
|
||||
) -> IdeResult<crate::PatchFileDiff> {
|
||||
let _scope = r.execution_scope();
|
||||
file_diff::generate(r, &self.patch, path, &self.prefix, encoding)
|
||||
}
|
||||
}
|
||||
|
||||
impl ProjectPatch {
|
||||
/// Automatically use project paths when all files map and the patch spans repositories.
|
||||
pub fn discover(repos: &Repos, project: &Path, patch: &str, multiple: bool) -> IdeResult<Option<Self>> {
|
||||
let patch = normalized(patch)?;
|
||||
let files = sections(&patch);
|
||||
let mut single = None;
|
||||
for plan in project.ancestors().filter_map(|base| Self::route(repos, base, &files)) {
|
||||
if plan.groups.len() > 1 {
|
||||
return Ok(Some(plan));
|
||||
}
|
||||
if !multiple && single.is_none() {
|
||||
single = Some(plan);
|
||||
}
|
||||
}
|
||||
Ok(single)
|
||||
}
|
||||
|
||||
pub fn at_base(
|
||||
repos: &Repos,
|
||||
project: &Path,
|
||||
base: &Path,
|
||||
patch: &str,
|
||||
paths: Option<&[String]>,
|
||||
) -> IdeResult<Self> {
|
||||
if !project.starts_with(base) || !base.is_absolute() {
|
||||
return Err(IdeError::invalid("The patch base is outside the project"));
|
||||
}
|
||||
let patch = normalized(patch)?;
|
||||
let files = selected_sections(&patch, paths)?;
|
||||
Self::route(repos, base, &files)
|
||||
.ok_or_else(|| IdeError::invalid("The patch paths do not match the project's Git repositories"))
|
||||
}
|
||||
|
||||
fn route(repos: &Repos, base: &Path, files: &[(&str, PatchFile)]) -> Option<Self> {
|
||||
if files.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let resolve = |path: &str| {
|
||||
let path = Path::new(path);
|
||||
if path.as_os_str().is_empty() || !path.components().all(|c| matches!(c, Component::Normal(_))) {
|
||||
return None;
|
||||
}
|
||||
let full = base.join(path);
|
||||
let repo = repos.for_path(&full)?;
|
||||
let relative_root = repo.root().strip_prefix(base).ok()?;
|
||||
(full != repo.root()).then_some((repo.root(), relative_root))
|
||||
};
|
||||
let mut groups = BTreeMap::new();
|
||||
for (section, file) in files {
|
||||
let (root, relative_root) = resolve(&file.path)?;
|
||||
if let Some(old) = &file.old_path
|
||||
&& resolve(old)?.0 != root
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let group = groups.entry(root).or_insert_with(|| ProjectPatchGroup {
|
||||
root: root.to_owned(),
|
||||
prefix: if relative_root.as_os_str().is_empty() {
|
||||
String::new()
|
||||
} else {
|
||||
format!("{}/", ide_core::ipc_path::to_ipc(relative_root))
|
||||
},
|
||||
patch: String::new(),
|
||||
});
|
||||
group.patch.push_str(section);
|
||||
}
|
||||
Some(Self { base: base.to_owned(), groups: groups.into_values().collect() })
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn strip_option(prefix: &str) -> Option<String> {
|
||||
(!prefix.is_empty()).then(|| format!("-p{}", 1 + prefix.bytes().filter(|&byte| byte == b'/').count()))
|
||||
}
|
||||
|
||||
pub(crate) fn apply_with_prefix(r: &Repo, patch: &str, prefix: &str) -> IdeResult<ApplyOutcome> {
|
||||
apply_patch(r, patch, prefix, false)
|
||||
}
|
||||
|
||||
pub(crate) fn apply_for_review(r: &Repo, patch: &str, prefix: &str) -> IdeResult<ApplyOutcome> {
|
||||
apply_patch(r, patch, prefix, true)
|
||||
}
|
||||
|
||||
fn apply_patch(r: &Repo, patch: &str, prefix: &str, identify_conflicts: bool) -> IdeResult<ApplyOutcome> {
|
||||
let patch = normalized(patch)?;
|
||||
let files = parse_patch(&patch);
|
||||
let paths = files
|
||||
.iter()
|
||||
.map(|f| {
|
||||
if f.old_path.as_deref().is_some_and(|old| !old.starts_with(prefix)) {
|
||||
return Err(IdeError::invalid("The patch contains a path outside its repository"));
|
||||
}
|
||||
f.path
|
||||
.strip_prefix(prefix)
|
||||
.map(str::to_owned)
|
||||
.ok_or_else(|| IdeError::invalid("The patch contains a path outside its repository"))
|
||||
})
|
||||
.collect::<IdeResult<Vec<_>>>()?;
|
||||
let strip = strip_option(prefix);
|
||||
let mut args = vec!["apply", "--binary"];
|
||||
args.extend(strip.as_deref());
|
||||
let check = cli::run_raw(r.root(), &[args.as_slice(), &["--check", "-"]].concat(), Some(patch.as_bytes()))?;
|
||||
let paths: Vec<String> = files.iter().map(|f| f.path.clone()).collect();
|
||||
let check = cli::run_raw(r.root(), &["apply", "--check", "--binary", "-"], Some(patch.as_bytes()))?;
|
||||
if check.code == Some(0) {
|
||||
run(r.root(), &[args.as_slice(), &["-"]].concat(), Some(patch.as_bytes()))?;
|
||||
run(r.root(), &["apply", "--binary", "-"], Some(patch.as_bytes()))?;
|
||||
return Ok(ApplyOutcome { applied: paths, conflicts: Vec::new() });
|
||||
}
|
||||
let _guard = identify_conflicts.then(|| r.conflict_mutation.lock().unwrap_or_else(|error| error.into_inner()));
|
||||
let record = identify_conflicts && unmerged(r)?.is_empty();
|
||||
if record {
|
||||
crate::conflict_resolution::clear_restore_conflicts(r);
|
||||
}
|
||||
let out = cli::run_raw(r.root(), &[args.as_slice(), &["--3way", "-"]].concat(), Some(patch.as_bytes()))?;
|
||||
let conflicts: Vec<_> = unmerged(r)?
|
||||
.into_iter()
|
||||
.filter(|path| {
|
||||
paths.contains(path)
|
||||
|| files
|
||||
.iter()
|
||||
.any(|f| f.old_path.as_deref().and_then(|old| old.strip_prefix(prefix)) == Some(path.as_str()))
|
||||
})
|
||||
.collect();
|
||||
let out = cli::run_raw(r.root(), &["apply", "--3way", "--binary", "-"], Some(patch.as_bytes()))?;
|
||||
let conflicts = unmerged(r)?;
|
||||
if out.code != Some(0) && conflicts.is_empty() {
|
||||
return Err(cli::failure(&["apply"], &out.stderr, &out.stdout, out.code));
|
||||
}
|
||||
if record && !conflicts.is_empty() {
|
||||
crate::conflict_resolution::record_conflicts(r, crate::conflict_resolution::RestoreConflict::PatchApply);
|
||||
}
|
||||
// `--3way` stages what it applied; keep the index as it was for the clean files.
|
||||
let clean: Vec<String> = paths.iter().filter(|p| !conflicts.contains(p)).cloned().collect();
|
||||
if !clean.is_empty() && r.has_head()? {
|
||||
@@ -664,7 +176,7 @@ fn unmerged(r: &Repo) -> IdeResult<Vec<String>> {
|
||||
Ok(out.stdout_str().split('\0').filter(|s| !s.is_empty()).map(str::to_string).collect())
|
||||
}
|
||||
|
||||
pub(super) fn git_path(p: &str) -> String {
|
||||
fn git_path(p: &str) -> String {
|
||||
let Some(p) = p.strip_prefix('"').and_then(|p| p.strip_suffix('"')) else { return p.to_string() };
|
||||
let mut bytes = Vec::new();
|
||||
let mut chars = p.bytes().peekable();
|
||||
@@ -713,7 +225,6 @@ fn strip_prefix(p: &str) -> Option<String> {
|
||||
pub(crate) fn parse_patch(patch: &str) -> Vec<PatchFile> {
|
||||
let mut out: Vec<PatchFile> = Vec::new();
|
||||
let mut cur: Option<PatchFile> = None;
|
||||
let mut before_path: Option<String> = None;
|
||||
// From a `diff --git` header and no hunk seen yet: `---` belongs to it.
|
||||
let mut fresh_header = false;
|
||||
let (mut old_left, mut new_left) = (0u32, 0u32);
|
||||
@@ -725,7 +236,6 @@ pub(crate) fn parse_patch(patch: &str) -> Vec<PatchFile> {
|
||||
removed: 0,
|
||||
binary: false,
|
||||
applies: true,
|
||||
missing_base: false,
|
||||
};
|
||||
for line in patch.lines() {
|
||||
if old_left > 0 || new_left > 0 {
|
||||
@@ -749,7 +259,6 @@ pub(crate) fn parse_patch(patch: &str) -> Vec<PatchFile> {
|
||||
}
|
||||
if let Some(rest) = line.strip_prefix("diff --git ") {
|
||||
out.extend(cur.take());
|
||||
before_path = None;
|
||||
let path = rest
|
||||
.rsplit_once(" \"b/")
|
||||
.map(|(_, b)| git_path(&format!("\"{b}")))
|
||||
@@ -764,10 +273,9 @@ pub(crate) fn parse_patch(patch: &str) -> Vec<PatchFile> {
|
||||
cur = Some(new_file(String::new()));
|
||||
}
|
||||
fresh_header = false;
|
||||
before_path = strip_prefix(rest);
|
||||
if let Some(c) = cur.as_mut() {
|
||||
match &before_path {
|
||||
Some(p) if c.path.is_empty() => c.path = p.clone(),
|
||||
match strip_prefix(rest) {
|
||||
Some(p) if c.path.is_empty() => c.path = p,
|
||||
Some(_) => {}
|
||||
None => c.kind = ChangeKind::Added,
|
||||
}
|
||||
@@ -775,12 +283,7 @@ pub(crate) fn parse_patch(patch: &str) -> Vec<PatchFile> {
|
||||
} else if let Some(c) = cur.as_mut() {
|
||||
if let Some(rest) = line.strip_prefix("+++ ") {
|
||||
match strip_prefix(rest) {
|
||||
Some(p) => {
|
||||
if let Some(old) = before_path.take().filter(|old| old != &p) {
|
||||
c.old_path.get_or_insert(old);
|
||||
}
|
||||
c.path = p;
|
||||
}
|
||||
Some(p) => c.path = p,
|
||||
None => c.kind = ChangeKind::Deleted,
|
||||
}
|
||||
} else if let Some(range) = line.strip_prefix("@@ ") {
|
||||
@@ -799,12 +302,10 @@ pub(crate) fn parse_patch(patch: &str) -> Vec<PatchFile> {
|
||||
c.kind = ChangeKind::Added;
|
||||
} else if line.starts_with("deleted file mode") {
|
||||
c.kind = ChangeKind::Deleted;
|
||||
} else if let Some(p) = line.strip_prefix("rename from ").or_else(|| line.strip_prefix("copy from ")) {
|
||||
} else if let Some(p) = line.strip_prefix("rename from ") {
|
||||
c.old_path = Some(git_path(p));
|
||||
if line.starts_with("rename ") {
|
||||
c.kind = ChangeKind::Renamed;
|
||||
}
|
||||
} else if let Some(p) = line.strip_prefix("rename to ").or_else(|| line.strip_prefix("copy to ")) {
|
||||
c.kind = ChangeKind::Renamed;
|
||||
} else if let Some(p) = line.strip_prefix("rename to ") {
|
||||
c.path = git_path(p);
|
||||
} else if line.starts_with("GIT binary patch") || line.starts_with("Binary files ") {
|
||||
c.binary = true;
|
||||
@@ -891,7 +392,7 @@ pub(crate) fn stage_converted_patch(
|
||||
let env = tmp.env();
|
||||
let index = r.git_dir.join("index");
|
||||
if index.exists() {
|
||||
std::fs::copy(index, tmp.path())?;
|
||||
std::fs::copy(index, &tmp.0)?;
|
||||
} else {
|
||||
run_env(r.root(), &["read-tree", "--empty"], None, &env)?;
|
||||
}
|
||||
|
||||
@@ -1,164 +0,0 @@
|
||||
use super::{normalized, selected_sections, strip_option, valid_patch_path};
|
||||
use crate::cli::{run, run_raw_env};
|
||||
use crate::text_encoding;
|
||||
use crate::{ChangeKind, PatchDiffContent, PatchFileDiff, Repo, TextEncoding};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::fs;
|
||||
use std::io::Read;
|
||||
use std::path::Path;
|
||||
|
||||
const MAX_PREVIEW_BYTES: u64 = 4 << 20;
|
||||
|
||||
pub(crate) fn generate(
|
||||
repo: &Repo,
|
||||
patch: &str,
|
||||
path: &str,
|
||||
prefix: &str,
|
||||
encoding: &dyn Fn(&Path, &[u8]) -> TextEncoding,
|
||||
) -> IdeResult<PatchFileDiff> {
|
||||
let patch = normalized(patch)?;
|
||||
let sections = selected_sections(&patch, Some(&[path.to_owned()]))?;
|
||||
let (first_section, first) = §ions[0];
|
||||
let before = safe_path(first.old_path.as_deref().unwrap_or(path), prefix)?;
|
||||
let after = safe_path(path, prefix)?;
|
||||
for (_, file) in §ions {
|
||||
if let Some(old) = &file.old_path {
|
||||
safe_path(old, prefix)?;
|
||||
}
|
||||
}
|
||||
let before_path = repo.root().join(before);
|
||||
let after_path = repo.root().join(after);
|
||||
let mut result = PatchFileDiff {
|
||||
path: (&after_path).into(),
|
||||
old_path: (before != after).then(|| (&before_path).into()),
|
||||
content: PatchDiffContent::Binary,
|
||||
};
|
||||
if sections.iter().any(|(_, file)| file.binary) {
|
||||
return Ok(result);
|
||||
}
|
||||
let Some(local) = read_regular(repo.root(), before)? else { return Ok(result) };
|
||||
let view = |bytes: Option<&[u8]>, path: &Path| {
|
||||
bytes.map_or(Some(None), |bytes| {
|
||||
let charset = encoding(path, bytes);
|
||||
(!text_encoding::is_binary(bytes, charset))
|
||||
.then(|| Some(text_encoding::decode(bytes, charset).into_owned()))
|
||||
})
|
||||
};
|
||||
let Some(local_text) = view(local.as_deref(), &before_path) else { return Ok(result) };
|
||||
let body: String = sections.iter().map(|(section, _)| *section).collect();
|
||||
if body.len() as u64 > MAX_PREVIEW_BYTES {
|
||||
return Err(too_large());
|
||||
}
|
||||
let autocrlf = run(repo.root(), &["config", "--get", "core.autocrlf"], None)
|
||||
.map(|result| result.stdout_str().trim().to_owned())
|
||||
.unwrap_or_else(|_| "false".to_owned());
|
||||
let autocrlf = format!("core.autocrlf={autocrlf}");
|
||||
|
||||
let sandbox = tempfile::tempdir()?;
|
||||
if let Some(applied) = apply_in_sandbox(sandbox.path(), &body, prefix, before, after, local.as_deref(), &autocrlf)?
|
||||
{
|
||||
let Some(after_text) = view(applied.as_deref(), &after_path) else { return Ok(result) };
|
||||
result.content = if local_text == after_text && before == after {
|
||||
PatchDiffContent::Raw { local: local_text, patch: body, applies: true }
|
||||
} else {
|
||||
PatchDiffContent::Text { before: local_text, after: after_text }
|
||||
};
|
||||
return Ok(result);
|
||||
}
|
||||
|
||||
let base = if first.kind == ChangeKind::Added { Some(None) } else { original_blob(repo, first_section).map(Some) };
|
||||
if let Some(base) = base {
|
||||
// The first attempt can leave a copied input in place. Use a fresh directory for the base.
|
||||
let original = tempfile::tempdir()?;
|
||||
if let Some(patched) =
|
||||
apply_in_sandbox(original.path(), &body, prefix, before, after, base.as_deref(), &autocrlf)?
|
||||
{
|
||||
let Some(base) = view(base.as_deref(), &before_path) else { return Ok(result) };
|
||||
let Some(patched) = view(patched.as_deref(), &after_path) else { return Ok(result) };
|
||||
result.content = PatchDiffContent::Conflict { local: local_text, base, patched };
|
||||
return Ok(result);
|
||||
}
|
||||
}
|
||||
result.content = PatchDiffContent::Raw { local: local_text, patch: body, applies: false };
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn safe_path<'a>(path: &'a str, prefix: &str) -> IdeResult<&'a Path> {
|
||||
path.strip_prefix(prefix)
|
||||
.map(Path::new)
|
||||
.filter(|path| valid_patch_path(path))
|
||||
.ok_or_else(|| IdeError::invalid("The patch contains a path outside its repository"))
|
||||
}
|
||||
|
||||
fn too_large() -> IdeError {
|
||||
IdeError::invalid("Patch file is too large to preview")
|
||||
}
|
||||
|
||||
// Outer None means non-regular content, inner None means the file is absent.
|
||||
fn read_regular(root: &Path, rel: &Path) -> IdeResult<Option<Option<Vec<u8>>>> {
|
||||
let path = root.join(rel);
|
||||
let metadata = match path.symlink_metadata() {
|
||||
Ok(metadata) => metadata,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(Some(None)),
|
||||
Err(error) => return Err(error.into()),
|
||||
};
|
||||
if !metadata.is_file() {
|
||||
return Ok(None);
|
||||
}
|
||||
let resolved = dunce::canonicalize(&path)?;
|
||||
if !resolved.starts_with(dunce::canonicalize(root)?) {
|
||||
return Err(IdeError::invalid("The patch contains a path outside its repository"));
|
||||
}
|
||||
let mut bytes = Vec::new();
|
||||
fs::File::open(resolved)?.take(MAX_PREVIEW_BYTES + 1).read_to_end(&mut bytes)?;
|
||||
if bytes.len() as u64 > MAX_PREVIEW_BYTES {
|
||||
return Err(too_large());
|
||||
}
|
||||
Ok(Some(Some(bytes)))
|
||||
}
|
||||
|
||||
fn apply_in_sandbox(
|
||||
root: &Path,
|
||||
patch: &str,
|
||||
prefix: &str,
|
||||
before: &Path,
|
||||
after: &Path,
|
||||
bytes: Option<&[u8]>,
|
||||
autocrlf: &str,
|
||||
) -> IdeResult<Option<Option<Vec<u8>>>> {
|
||||
let worktree = root.join("worktree");
|
||||
fs::create_dir(&worktree)?;
|
||||
if let Some(bytes) = bytes {
|
||||
let path = worktree.join(before);
|
||||
fs::create_dir_all(path.parent().expect("relative file path"))?;
|
||||
fs::write(path, bytes)?;
|
||||
}
|
||||
let boundary =
|
||||
std::env::join_paths([dunce::canonicalize(root)?]).map_err(|error| IdeError::invalid(error.to_string()))?;
|
||||
let strip = strip_option(prefix);
|
||||
let mut args = vec!["-c", autocrlf, "apply", "--binary"];
|
||||
args.extend(strip.as_deref());
|
||||
args.push("-");
|
||||
let output = run_raw_env(&worktree, &args, Some(patch.as_bytes()), &[("GIT_CEILING_DIRECTORIES", &boundary)])?;
|
||||
if output.code != Some(0) {
|
||||
return Ok(None);
|
||||
}
|
||||
read_regular(&worktree, after)
|
||||
}
|
||||
|
||||
fn original_blob(repo: &Repo, section: &str) -> Option<Vec<u8>> {
|
||||
let oid = section
|
||||
.lines()
|
||||
.take_while(|line| !line.starts_with("@@"))
|
||||
.find_map(|line| line.strip_prefix("index ")?.split_once("..").map(|(oid, _)| oid));
|
||||
let oid = oid.filter(|oid| {
|
||||
(4..=64).contains(&oid.len())
|
||||
&& oid.bytes().all(|byte| byte.is_ascii_hexdigit())
|
||||
&& oid.bytes().any(|byte| byte != b'0')
|
||||
})?;
|
||||
let size = run(repo.root(), &["cat-file", "-s", oid], None).ok()?;
|
||||
if size.stdout_str().trim().parse::<u64>().map_or(true, |size| size > MAX_PREVIEW_BYTES) {
|
||||
return None;
|
||||
}
|
||||
run(repo.root(), &["cat-file", "blob", oid], None).ok().map(|blob| blob.stdout)
|
||||
}
|
||||
@@ -1,294 +0,0 @@
|
||||
use super::{
|
||||
ProjectPatchGroup, missing_patch_base, normalized, patch_file_exists, selected_sections, valid_patch_path,
|
||||
};
|
||||
use crate::diff::quote_path;
|
||||
use crate::{ApplyOutcome, ChangeKind, PatchFile, PatchFileDiff, Repo, Repos, TextEncoding};
|
||||
use ide_core::{IdeError, IdeResult, IpcPath, ipc_path::to_ipc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
mod candidates;
|
||||
pub use candidates::{PatchDirectoryMatches, PatchDirectoryScope, discover_patch_directories};
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PatchPathMapping {
|
||||
pub path: String,
|
||||
pub directory: Option<IpcPath>,
|
||||
pub strip: u32,
|
||||
pub file: Option<IpcPath>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PatchPlacement {
|
||||
pub path: String,
|
||||
pub target: Option<IpcPath>,
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
pub struct MappedPatch {
|
||||
pub files: Vec<PatchFile>,
|
||||
pub placements: Vec<PatchPlacement>,
|
||||
pub groups: Vec<MappedPatchGroup>,
|
||||
}
|
||||
|
||||
pub struct MappedPatchGroup {
|
||||
pub group: ProjectPatchGroup,
|
||||
entries: Vec<(usize, String)>,
|
||||
}
|
||||
|
||||
struct Destination {
|
||||
root: PathBuf,
|
||||
full: PathBuf,
|
||||
before: String,
|
||||
after: String,
|
||||
}
|
||||
|
||||
impl MappedPatchGroup {
|
||||
pub fn preview(&self, repo: &Repo, files: &mut [PatchFile]) -> IdeResult<()> {
|
||||
let preview = self.group.preview(repo)?;
|
||||
if preview.len() != self.entries.len() {
|
||||
return Err(IdeError::invalid("The mapped patch contains inconsistent file headers"));
|
||||
}
|
||||
for (file, (index, _)) in preview.into_iter().zip(&self.entries) {
|
||||
files[*index].applies = file.applies;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn file_diff(&self, repo: &Repo, encoding: &dyn Fn(&Path, &[u8]) -> TextEncoding) -> IdeResult<PatchFileDiff> {
|
||||
let (_, path) = &self.entries[0];
|
||||
self.group.file_diff(repo, path, encoding)
|
||||
}
|
||||
|
||||
pub fn apply(&self, repo: &Repo) -> IdeResult<ApplyOutcome> {
|
||||
let outcome = self.group.apply(repo)?;
|
||||
let absolute = |paths: Vec<String>| paths.into_iter().map(|path| to_ipc(&repo.root().join(path))).collect();
|
||||
Ok(ApplyOutcome { applied: absolute(outcome.applied), conflicts: absolute(outcome.conflicts) })
|
||||
}
|
||||
}
|
||||
|
||||
impl MappedPatch {
|
||||
pub fn new(
|
||||
repos: &Repos,
|
||||
repo_root: Option<&Path>,
|
||||
base: Option<&Path>,
|
||||
patch: &str,
|
||||
paths: Option<&[String]>,
|
||||
mappings: &[PatchPathMapping],
|
||||
) -> IdeResult<Self> {
|
||||
let default = match repo_root {
|
||||
Some(root) => repos.at_root(root),
|
||||
None => repos.primary(),
|
||||
}
|
||||
.ok_or_else(|| IdeError::unavailable("The patch repository is not in the project"))?;
|
||||
let patch = normalized(patch)?;
|
||||
let sections = selected_sections(&patch, paths)?;
|
||||
if sections.is_empty() {
|
||||
return Err(IdeError::invalid("no file changes found in the patch"));
|
||||
}
|
||||
let mappings: HashMap<_, _> = mappings.iter().map(|mapping| (mapping.path.as_str(), mapping)).collect();
|
||||
let destinations: Vec<_> = sections
|
||||
.iter()
|
||||
.map(|(section, file)| {
|
||||
if let Some(target) = mappings.get(file.path.as_str()).and_then(|m| m.file.as_deref()) {
|
||||
return file_destination(repos, file, section, target);
|
||||
}
|
||||
destination(repos, default, base, file, mappings.get(file.path.as_str()).copied())
|
||||
})
|
||||
.collect();
|
||||
let mut owners = HashMap::new();
|
||||
let mut duplicates = std::collections::HashSet::new();
|
||||
for ((_, file), destination) in sections.iter().zip(&destinations) {
|
||||
if let Ok(destination) = destination {
|
||||
let target = to_ipc(&destination.full);
|
||||
let target = if cfg!(windows) { target.to_lowercase() } else { target };
|
||||
if owners.insert(target.clone(), &file.path).is_some_and(|owner| owner != &file.path) {
|
||||
duplicates.insert(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut files = Vec::new();
|
||||
let mut placements = Vec::new();
|
||||
let mut groups = BTreeMap::new();
|
||||
for ((section, mut file), destination) in sections.into_iter().zip(destinations) {
|
||||
let mut placement = PatchPlacement { path: file.path.clone(), target: None, error: None };
|
||||
file.applies = false;
|
||||
match destination {
|
||||
Ok(destination) => {
|
||||
file.missing_base = missing_patch_base(&destination.root, &file, &destination.before);
|
||||
let target = to_ipc(&destination.full);
|
||||
let key = if cfg!(windows) { target.to_lowercase() } else { target };
|
||||
placement.target = Some(destination.full.into());
|
||||
if duplicates.contains(&key) {
|
||||
placement.error = Some("Multiple patch files target the same path".into());
|
||||
} else {
|
||||
let group = groups.entry(destination.root.clone()).or_insert_with(|| MappedPatchGroup {
|
||||
group: ProjectPatchGroup {
|
||||
root: destination.root,
|
||||
prefix: String::new(),
|
||||
patch: String::new(),
|
||||
},
|
||||
entries: Vec::new(),
|
||||
});
|
||||
rewrite_headers(
|
||||
&mut group.group.patch,
|
||||
section,
|
||||
&destination.before,
|
||||
&destination.after,
|
||||
mappings.get(file.path.as_str()).is_some_and(|m| m.file.is_some()),
|
||||
);
|
||||
group.entries.push((files.len(), destination.after));
|
||||
}
|
||||
}
|
||||
Err(error) => placement.error = Some(error.message),
|
||||
}
|
||||
placements.push(placement);
|
||||
files.push(file);
|
||||
}
|
||||
Ok(Self { files, placements, groups: groups.into_values().collect() })
|
||||
}
|
||||
|
||||
pub fn require_destinations(&self) -> IdeResult<()> {
|
||||
if let Some(placement) = self.placements.iter().find(|placement| placement.error.is_some()) {
|
||||
return Err(IdeError::invalid(format!(
|
||||
"{}: {}",
|
||||
placement.path,
|
||||
placement.error.as_deref().unwrap_or_default()
|
||||
)));
|
||||
}
|
||||
if let Some(file) = self.files.iter().find(|file| file.missing_base) {
|
||||
return Err(IdeError::invalid(format!("{}: missing base file", file.path)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn file_destination(repos: &Repos, file: &PatchFile, section: &str, target: &Path) -> IdeResult<Destination> {
|
||||
if file.kind == ChangeKind::Added {
|
||||
return Err(IdeError::invalid("A new file does not need a base file"));
|
||||
}
|
||||
if !valid_patch_path(Path::new(&file.path))
|
||||
|| file.old_path.as_deref().is_some_and(|path| !valid_patch_path(Path::new(path)))
|
||||
{
|
||||
return Err(IdeError::invalid("The patch contains a path outside its repository"));
|
||||
}
|
||||
let repo = repos
|
||||
.for_path(target)
|
||||
.ok_or_else(|| IdeError::invalid("The patch destination is outside the project's Git repositories"))?;
|
||||
let relative = target
|
||||
.strip_prefix(repo.root())
|
||||
.ok()
|
||||
.filter(|path| valid_patch_path(path))
|
||||
.ok_or_else(|| IdeError::invalid("Choose an existing file inside a Git repository"))?;
|
||||
if !patch_file_exists(target) {
|
||||
return Err(IdeError::invalid("Choose an existing file inside a Git repository"));
|
||||
}
|
||||
if file.old_path.is_some()
|
||||
&& !file.binary
|
||||
&& file.added == 0
|
||||
&& file.removed == 0
|
||||
&& !section.lines().any(|line| line.starts_with("old mode "))
|
||||
{
|
||||
return Err(IdeError::invalid("This patch only renames or copies the file"));
|
||||
}
|
||||
let path = to_ipc(relative);
|
||||
Ok(Destination { root: repo.root().to_owned(), full: target.to_owned(), before: path.clone(), after: path })
|
||||
}
|
||||
|
||||
fn destination(
|
||||
repos: &Repos,
|
||||
default: &Repo,
|
||||
base: Option<&Path>,
|
||||
file: &PatchFile,
|
||||
mapping: Option<&PatchPathMapping>,
|
||||
) -> IdeResult<Destination> {
|
||||
let directory = mapping.and_then(|m| m.directory.as_deref()).or(base).unwrap_or_else(|| default.root());
|
||||
if !directory.is_absolute()
|
||||
|| directory.components().any(|part| match part {
|
||||
Component::ParentDir => true,
|
||||
Component::Normal(name) => name.eq_ignore_ascii_case(".git"),
|
||||
_ => false,
|
||||
})
|
||||
{
|
||||
return Err(IdeError::invalid("Choose an absolute directory inside a Git repository"));
|
||||
}
|
||||
let strip = mapping.map_or(0, |m| m.strip) as usize;
|
||||
let resolve = |path: &str| {
|
||||
let path = Path::new(path);
|
||||
if !valid_patch_path(path) {
|
||||
return Err(IdeError::invalid("The patch contains a path outside its repository"));
|
||||
}
|
||||
let path: PathBuf = path.components().skip(strip).collect();
|
||||
if path.as_os_str().is_empty() {
|
||||
return Err(IdeError::invalid("The patch path has no file name after removing directories"));
|
||||
}
|
||||
Ok(directory.join(path))
|
||||
};
|
||||
let full = resolve(&file.path)?;
|
||||
let before = resolve(file.old_path.as_deref().unwrap_or(&file.path))?;
|
||||
let repo = if base.is_none() && mapping.and_then(|m| m.directory.as_ref()).is_none() {
|
||||
default
|
||||
} else {
|
||||
repos
|
||||
.for_path(&full)
|
||||
.map(|repo| repo.as_ref())
|
||||
.ok_or_else(|| IdeError::invalid("The patch destination is outside the project's Git repositories"))?
|
||||
};
|
||||
let rel = |path: &Path| {
|
||||
path.strip_prefix(repo.root())
|
||||
.ok()
|
||||
.filter(|path| !path.as_os_str().is_empty())
|
||||
.map(to_ipc)
|
||||
.ok_or_else(|| IdeError::invalid("Both paths of a rename or copy must be in the same Git repository"))
|
||||
};
|
||||
if (base.is_some() || mapping.and_then(|m| m.directory.as_ref()).is_some())
|
||||
&& repos.for_path(&before).is_some_and(|other| other.root() != repo.root())
|
||||
{
|
||||
return Err(IdeError::invalid("Both paths of a rename or copy must be in the same Git repository"));
|
||||
}
|
||||
let after = rel(&full)?;
|
||||
Ok(Destination { root: repo.root().to_path_buf(), before: rel(&before)?, full, after })
|
||||
}
|
||||
|
||||
/// Change names in the file header only. Hunks and Git's binary payload stay byte-for-byte intact.
|
||||
pub(super) fn rewrite_headers(out: &mut String, section: &str, before: &str, after: &str, same_file: bool) {
|
||||
let old = quote_path(&format!("a/{before}"));
|
||||
let new = quote_path(&format!("b/{after}"));
|
||||
let mut offset = 0;
|
||||
for line in section.split_inclusive('\n') {
|
||||
if line.starts_with("@@") || line.starts_with("GIT binary patch") {
|
||||
break;
|
||||
}
|
||||
if same_file
|
||||
&& ["rename ", "copy ", "similarity index ", "dissimilarity index "]
|
||||
.iter()
|
||||
.any(|prefix| line.starts_with(prefix))
|
||||
{
|
||||
offset += line.len();
|
||||
continue;
|
||||
}
|
||||
let replacement = if line.starts_with("diff --git ") {
|
||||
Some(format!("diff --git {old} {new}\n"))
|
||||
} else if line.starts_with("--- ") && !line.starts_with("--- /dev/null") {
|
||||
Some(format!("--- {old}\n"))
|
||||
} else if line.starts_with("+++ ") && !line.starts_with("+++ /dev/null") {
|
||||
Some(format!("+++ {new}\n"))
|
||||
} else {
|
||||
["rename from ", "rename to ", "copy from ", "copy to "]
|
||||
.into_iter()
|
||||
.find(|prefix| line.starts_with(prefix))
|
||||
.map(|prefix| {
|
||||
let path = if prefix.ends_with("from ") { before } else { after };
|
||||
format!("{prefix}{}\n", quote_path(path))
|
||||
})
|
||||
};
|
||||
out.push_str(replacement.as_deref().unwrap_or(line));
|
||||
offset += line.len();
|
||||
}
|
||||
out.push_str(§ion[offset..]);
|
||||
}
|
||||
@@ -1,247 +0,0 @@
|
||||
use super::{
|
||||
Destination, PatchPathMapping, ProjectPatchGroup, destination, file_destination, missing_patch_base, normalized,
|
||||
rewrite_headers, selected_sections, valid_patch_path,
|
||||
};
|
||||
use crate::{ChangeKind, PatchFile, Repo, Repos};
|
||||
use ide_core::{IdeResult, IpcPath, ipc_path::to_ipc};
|
||||
use serde::Serialize;
|
||||
use specta::Type;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::ffi::OsStr;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
const MENU_LIMIT: usize = 8;
|
||||
const CHECK_LIMIT: usize = 32;
|
||||
|
||||
#[derive(Debug, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PatchDirectoryCandidate {
|
||||
pub directory: IpcPath,
|
||||
pub source: IpcPath,
|
||||
pub strip: u32,
|
||||
pub applies: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PatchDirectoryMatches {
|
||||
pub path: String,
|
||||
pub candidates: Vec<PatchDirectoryCandidate>,
|
||||
}
|
||||
|
||||
struct Match {
|
||||
candidate: PatchDirectoryCandidate,
|
||||
target: Destination,
|
||||
}
|
||||
|
||||
pub struct PatchDirectoryScope<'a> {
|
||||
pub repo: &'a Repo,
|
||||
pub base: Option<&'a Path>,
|
||||
pub only_repository: bool,
|
||||
pub automatic: bool,
|
||||
}
|
||||
|
||||
/// Match missing base files and additions to existing path suffixes. Check the resulting
|
||||
/// mappings with Git before adopting any inferred destination.
|
||||
pub fn discover_patch_directories(
|
||||
repos: &Repos,
|
||||
scope: PatchDirectoryScope<'_>,
|
||||
patch: &str,
|
||||
overrides: &[PatchPathMapping],
|
||||
indexed_files: impl FnOnce(&HashSet<&OsStr>) -> Vec<PathBuf>,
|
||||
existing_directories: impl FnOnce(&HashSet<&OsStr>) -> Vec<PathBuf>,
|
||||
) -> IdeResult<(Vec<PatchDirectoryMatches>, Vec<PatchPathMapping>)> {
|
||||
let PatchDirectoryScope { repo: default, base, automatic, .. } = scope;
|
||||
let patch = normalized(patch)?;
|
||||
let sections = selected_sections(&patch, None)?;
|
||||
let overrides: HashMap<_, _> = overrides.iter().map(|mapping| (mapping.path.as_str(), mapping)).collect();
|
||||
let mut occupied = HashSet::new();
|
||||
let mut missing = Vec::new();
|
||||
for (section, file) in §ions {
|
||||
let before = Path::new(file.old_path.as_deref().unwrap_or(&file.path));
|
||||
let original = destination(repos, default, base, file, None);
|
||||
if valid_patch_path(before) {
|
||||
let needs_base = if file.kind == ChangeKind::Added {
|
||||
new_file_anchors(before).next().is_some()
|
||||
&& !original.as_ref().is_ok_and(|route| route.full.parent().is_some_and(Path::is_dir))
|
||||
} else {
|
||||
original.as_ref().map_or(true, |route| missing_patch_base(&route.root, file, &route.before))
|
||||
};
|
||||
if needs_base {
|
||||
missing.push((*section, file, before));
|
||||
}
|
||||
}
|
||||
let mapping = overrides.get(file.path.as_str()).copied();
|
||||
let active = match mapping {
|
||||
Some(mapping) => match mapping.file.as_deref() {
|
||||
Some(path) => file_destination(repos, file, section, path),
|
||||
None => destination(repos, default, base, file, Some(mapping)),
|
||||
},
|
||||
None => original,
|
||||
};
|
||||
if let Ok(route) = active {
|
||||
occupied.extend(path_keys(&route));
|
||||
}
|
||||
}
|
||||
|
||||
let names: HashSet<_> = missing
|
||||
.iter()
|
||||
.filter(|(_, file, _)| file.kind != ChangeKind::Added)
|
||||
.filter_map(|(_, _, before)| before.file_name())
|
||||
.collect();
|
||||
let dir_names: HashSet<_> = missing
|
||||
.iter()
|
||||
.filter(|(_, file, _)| file.kind == ChangeKind::Added)
|
||||
.flat_map(|(_, _, path)| new_file_anchors(path))
|
||||
.filter_map(Path::file_name)
|
||||
.collect();
|
||||
let indexed = indexed_files(&names);
|
||||
let dirs = existing_directories(&dir_names);
|
||||
let indexed = by_name(&indexed);
|
||||
let dirs = by_name(&dirs);
|
||||
|
||||
let mut checks_left = CHECK_LIMIT;
|
||||
let mut matches = Vec::new();
|
||||
let mut inferred = Vec::new();
|
||||
let mut seen = HashSet::new();
|
||||
for (section, file, before) in missing {
|
||||
// Several sections for the same path have no single hunk context to rank on.
|
||||
if !seen.insert(file.path.as_str()) {
|
||||
inferred.retain(|(mapping, _): &(PatchPathMapping, Destination)| mapping.path != file.path);
|
||||
continue;
|
||||
}
|
||||
let mut choices = if file.kind == ChangeKind::Added {
|
||||
new_file_anchors(before)
|
||||
.flat_map(|anchor| named_paths(&dirs, anchor).map(move |path| (anchor, path)))
|
||||
.filter_map(|(anchor, path)| candidate_for(repos, &scope, file, anchor, path))
|
||||
.collect::<Vec<_>>()
|
||||
} else {
|
||||
named_paths(&indexed, before).filter_map(|path| candidate_for(repos, &scope, file, before, path)).collect()
|
||||
};
|
||||
choices.sort_by(|a, b| {
|
||||
a.candidate.strip.cmp(&b.candidate.strip).then(a.candidate.source.cmp(&b.candidate.source))
|
||||
});
|
||||
let mut locations = HashSet::new();
|
||||
choices.retain(|entry| locations.insert(entry.candidate.source.clone()));
|
||||
let truncated = choices.len() > MENU_LIMIT;
|
||||
choices.truncate(MENU_LIMIT);
|
||||
for entry in choices.iter_mut().take(checks_left) {
|
||||
checks_left -= 1;
|
||||
let Some(repo) = repos.at_root(&entry.target.root) else { continue };
|
||||
let mut rewritten = String::new();
|
||||
rewrite_headers(&mut rewritten, section, &entry.target.before, &entry.target.after, false);
|
||||
let group = ProjectPatchGroup { root: entry.target.root.clone(), prefix: String::new(), patch: rewritten };
|
||||
entry.candidate.applies = group.preview(repo).ok().map(|files| files.iter().all(|file| file.applies));
|
||||
}
|
||||
choices.sort_by_key(|entry| (entry.candidate.applies != Some(true), entry.candidate.strip));
|
||||
let best = choices.first();
|
||||
if automatic
|
||||
&& !truncated
|
||||
&& !overrides.contains_key(file.path.as_str())
|
||||
&& let Some(best) = best
|
||||
&& best.candidate.applies == Some(true)
|
||||
&& choices.iter().skip(1).all(|entry| {
|
||||
entry.candidate.strip > best.candidate.strip
|
||||
|| (file.kind != ChangeKind::Added && entry.candidate.applies == Some(false))
|
||||
})
|
||||
{
|
||||
let mapping = mapping_for(file, &best.candidate);
|
||||
if let Ok(route) = destination(repos, default, base, file, Some(&mapping))
|
||||
&& path_keys(&route).all(|key| !occupied.contains(&key))
|
||||
{
|
||||
inferred.push((mapping, route));
|
||||
}
|
||||
}
|
||||
if !choices.is_empty() {
|
||||
matches.push(PatchDirectoryMatches {
|
||||
path: file.path.clone(),
|
||||
candidates: choices.into_iter().map(|entry| entry.candidate).collect(),
|
||||
});
|
||||
}
|
||||
}
|
||||
let mut owners = HashMap::new();
|
||||
for (_, route) in &inferred {
|
||||
for key in path_keys(route) {
|
||||
*owners.entry(key).or_insert(0) += 1;
|
||||
}
|
||||
}
|
||||
let automatic = inferred
|
||||
.into_iter()
|
||||
.filter(|(_, route)| path_keys(route).all(|key| owners[&key] == 1))
|
||||
.map(|(mapping, _)| mapping)
|
||||
.collect();
|
||||
Ok((matches, automatic))
|
||||
}
|
||||
|
||||
/// A new file can be inside new subfolders. Match any existing ancestor that retains
|
||||
/// at least two components, so a generic name such as "src" cannot move an addition.
|
||||
fn new_file_anchors(path: &Path) -> impl Iterator<Item = &Path> {
|
||||
path.ancestors().skip(1).take_while(|dir| dir.parent().is_some_and(|parent| !parent.as_os_str().is_empty()))
|
||||
}
|
||||
|
||||
fn by_name(paths: &[PathBuf]) -> HashMap<&OsStr, Vec<&Path>> {
|
||||
let mut grouped: HashMap<_, Vec<_>> = HashMap::new();
|
||||
for path in paths {
|
||||
if let Some(name) = path.file_name() {
|
||||
grouped.entry(name).or_default().push(path.as_path());
|
||||
}
|
||||
}
|
||||
grouped
|
||||
}
|
||||
|
||||
fn named_paths<'a>(paths: &'a HashMap<&OsStr, Vec<&'a Path>>, path: &Path) -> impl Iterator<Item = &'a Path> {
|
||||
path.file_name().and_then(|name| paths.get(name)).into_iter().flatten().copied()
|
||||
}
|
||||
|
||||
fn path_keys(route: &Destination) -> impl Iterator<Item = String> + '_ {
|
||||
let key = |path: &str| {
|
||||
let absolute = to_ipc(&route.root.join(path));
|
||||
if cfg!(windows) { absolute.to_lowercase() } else { absolute }
|
||||
};
|
||||
let after = key(&route.after);
|
||||
let before = key(&route.before);
|
||||
let differs = before != after;
|
||||
std::iter::once(after).chain(differs.then_some(before))
|
||||
}
|
||||
|
||||
fn mapping_for(file: &PatchFile, candidate: &PatchDirectoryCandidate) -> PatchPathMapping {
|
||||
PatchPathMapping {
|
||||
path: file.path.clone(),
|
||||
directory: Some(candidate.directory.clone()),
|
||||
strip: candidate.strip,
|
||||
file: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn candidate_for(
|
||||
repos: &Repos,
|
||||
scope: &PatchDirectoryScope<'_>,
|
||||
file: &PatchFile,
|
||||
anchor: &Path,
|
||||
local: &Path,
|
||||
) -> Option<Match> {
|
||||
let added = file.kind == ChangeKind::Added;
|
||||
let common = anchor.components().rev().zip(local.components().rev()).take_while(|(a, b)| a == b).count();
|
||||
if common < if added { 2 } else { 1 } {
|
||||
return None;
|
||||
}
|
||||
let mapping = PatchPathMapping {
|
||||
path: file.path.clone(),
|
||||
directory: Some(local.ancestors().nth(common)?.into()),
|
||||
strip: u32::try_from(anchor.components().count() - common).ok()?,
|
||||
file: None,
|
||||
};
|
||||
let target = destination(repos, scope.repo, scope.base, file, Some(&mapping)).ok()?;
|
||||
if (scope.only_repository && target.root != scope.repo.root())
|
||||
|| missing_patch_base(&target.root, file, &target.before)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let candidate = PatchDirectoryCandidate {
|
||||
source: if added { target.full.as_path() } else { local }.into(),
|
||||
directory: mapping.directory?,
|
||||
strip: mapping.strip,
|
||||
applies: None,
|
||||
};
|
||||
Some(Match { candidate, target })
|
||||
}
|
||||
+29
-380
@@ -1,415 +1,64 @@
|
||||
//! Local changes put aside around checkout, merge, rebase and pull, and brought back once the
|
||||
//! Local changes put aside around merge, rebase and pull, and brought back once the
|
||||
//! operation is over: staged changes as staged (git's `--autostash` brings everything
|
||||
//! back unstaged). An operation that stops on conflicts keeps them aside until it is
|
||||
//! continued, skipped, aborted or concluded by a commit.
|
||||
|
||||
use crate::Repo;
|
||||
use crate::cli::{self, run};
|
||||
use crate::shelf::SavedShelves;
|
||||
use crate::write::{drop_restored_stash, selected_stash_index, unmerged_paths};
|
||||
use crate::{Repo, Stash};
|
||||
use crate::write::unmerged_paths;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// `.git/<MARKER>` holds the saved entry to restore. Older versions stored only a stash commit id.
|
||||
/// `.git/<MARKER>` holds the id of the stash the changes went to.
|
||||
const MARKER: &str = "openidea-saved-changes";
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
#[serde(untagged)]
|
||||
enum Saved {
|
||||
Shelves(SavedShelves),
|
||||
Shelf { directory: PathBuf, entry: String, snapshot: String },
|
||||
Stash(Stash),
|
||||
}
|
||||
|
||||
/// Saves the local changes of tracked files, if any.
|
||||
/// Stashes the local changes of tracked files, if any.
|
||||
pub(crate) fn save(r: &Repo, message: &str) -> IdeResult<()> {
|
||||
let _stash_lock = crate::write::lock_stashes(r)?;
|
||||
save_locked(r, message).map(|_| ())
|
||||
}
|
||||
|
||||
fn save_locked(r: &Repo, message: &str) -> IdeResult<Option<Saved>> {
|
||||
if r.git_dir.join(MARKER).exists() {
|
||||
let marker = r.git_dir.join(MARKER);
|
||||
if marker.exists() {
|
||||
// Changes saved by an operation still in progress stay where they are; those of
|
||||
// one concluded outside the IDE come back first.
|
||||
restore_saved(r, None)?;
|
||||
if r.git_dir.join(MARKER).exists() {
|
||||
return Ok(None);
|
||||
if r.branch_info()?.operation.is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
restore(r)?;
|
||||
}
|
||||
if run(r.root(), &["status", "--porcelain", "--untracked-files=no"], None)?.stdout_str().trim().is_empty() {
|
||||
return Ok(None);
|
||||
return Ok(());
|
||||
}
|
||||
let Some(stash) = stash_local_changes(r, message)? else { return Ok(None) };
|
||||
let saved = Saved::Stash(stash);
|
||||
write_marker(r, &saved)?;
|
||||
let options = r.automatic_shelf.read().unwrap_or_else(|poison| poison.into_inner()).clone();
|
||||
let (Some(options), Saved::Stash(stash)) = (options, &saved) else { return Ok(Some(saved)) };
|
||||
let shelves = match crate::shelf::capture_stash(r, options, message, stash) {
|
||||
Ok(shelves) => Saved::Shelves(shelves),
|
||||
Err(error) => return Err(rolled_back(error, restore_entry(r, saved, false))),
|
||||
};
|
||||
if let Err(error) = write_marker(r, &shelves) {
|
||||
if let Saved::Shelves(entries) = &shelves {
|
||||
entries.discard();
|
||||
}
|
||||
return Err(rolled_back(error, restore_entry(r, saved, false)));
|
||||
}
|
||||
if let Err(error) = selected_stash_index(r, stash)
|
||||
.and_then(|index| index.map_or(Ok(()), |index| crate::write::stash_drop(r, index)))
|
||||
{
|
||||
return Err(rolled_back(error, restore_entry(r, shelves, false)));
|
||||
}
|
||||
Ok(Some(shelves))
|
||||
}
|
||||
|
||||
/// The error that stopped saving, with the rollback's error when that failed too.
|
||||
fn rolled_back<T>(error: IdeError, rollback: IdeResult<T>) -> IdeError {
|
||||
match rollback {
|
||||
Ok(_) => error,
|
||||
Err(rollback) => IdeError::invalid(format!("{}\n{}", error.message, rollback.message)),
|
||||
}
|
||||
}
|
||||
|
||||
fn write_marker(r: &Repo, saved: &Saved) -> IdeResult<()> {
|
||||
let saved = serde_json::to_vec(saved).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
let mut temporary = tempfile::NamedTempFile::new_in(&r.git_dir)?;
|
||||
temporary.write_all(&saved)?;
|
||||
temporary.persist(r.git_dir.join(MARKER)).map_err(|error| error.error)?;
|
||||
let before = stash_top(r);
|
||||
run(r.root(), &["stash", "push", "-q", "-m", message], None)?;
|
||||
// A stash that succeeds without a new entry found nothing it saves: the status above also
|
||||
// lists submodules at another commit or with changes inside, which a stash leaves in place.
|
||||
let Some(id) = stash_top(r).filter(|id| Some(id) != before.as_ref()) else { return Ok(()) };
|
||||
std::fs::write(marker, id)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Separates a failed switch from a failed restore after a successful switch.
|
||||
pub(crate) fn checkout(
|
||||
r: &Repo,
|
||||
message: &str,
|
||||
switch: impl FnOnce() -> IdeResult<()>,
|
||||
) -> IdeResult<IdeResult<Vec<String>>> {
|
||||
let _stash_lock = crate::write::lock_stashes(r)?;
|
||||
let saved = save_locked(r, message)?.ok_or_else(|| {
|
||||
IdeError::invalid(if r.git_dir.join(MARKER).exists() {
|
||||
"Local changes from an unfinished Git operation are still put aside. Finish or abort it first."
|
||||
} else {
|
||||
"could not save the local changes"
|
||||
})
|
||||
})?;
|
||||
let switched = switch();
|
||||
if switched.is_ok()
|
||||
&& matches!(&saved, Saved::Shelves(shelves) if shelves.batch.as_deref().is_some_and(crate::shelf::is_active_batch))
|
||||
{
|
||||
return Ok(Ok(Vec::new()));
|
||||
}
|
||||
let restored = restore_entry(r, saved, switched.is_ok());
|
||||
match (switched, restored) {
|
||||
(Ok(()), restored) => Ok(restored),
|
||||
(Err(switch), Err(restore)) => Err(IdeError::invalid(format!("{}\n{}", switch.message, restore.message))),
|
||||
(Err(error), Ok(_)) => Err(error),
|
||||
}
|
||||
}
|
||||
|
||||
// The caller holds the common stash lock until the new entry is identified.
|
||||
fn stash_local_changes(r: &Repo, message: &str) -> IdeResult<Option<Stash>> {
|
||||
let previous = r.stashes()?.into_iter().next();
|
||||
let output = run(r.root(), &["stash", "push", "-m", message], None)?.stdout_str();
|
||||
// A stash that succeeds without a new entry found nothing it saves: the status above also
|
||||
// lists submodules at another commit or with changes inside, which a stash leaves in place.
|
||||
if output.lines().any(|line| line == "No local changes to save") {
|
||||
return Ok(None);
|
||||
}
|
||||
crate::conflict_resolution::clear_restore_conflicts(r);
|
||||
let error = || IdeError::invalid("Could not identify the stash containing the saved local changes");
|
||||
let message = output
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix("Saved working directory and index state "))
|
||||
.ok_or_else(error)?;
|
||||
let mut matches = r
|
||||
.stashes()?
|
||||
.into_iter()
|
||||
.take_while(|stash| previous.as_ref().is_none_or(|prev| !prev.same_entry(stash)))
|
||||
.filter(|stash| stash.message == message);
|
||||
let stash = matches.next().ok_or_else(error)?;
|
||||
if matches.next().is_some() {
|
||||
return Err(error());
|
||||
}
|
||||
Ok(Some(stash))
|
||||
}
|
||||
|
||||
fn apply_snapshot(r: &Repo, snapshot: &str, allow_unstaged: bool) -> IdeResult<Vec<String>> {
|
||||
let with_index = ["stash", "apply", "-q", "--index", snapshot];
|
||||
let mut out = cli::run_raw(r.root(), &with_index, None)?;
|
||||
if out.code != Some(0) {
|
||||
let conflicts = unmerged_paths(r)?;
|
||||
if !conflicts.is_empty() {
|
||||
return Ok(conflicts);
|
||||
}
|
||||
if !allow_unstaged {
|
||||
return Err(cli::failure(&with_index, &out.stderr, &out.stdout, out.code));
|
||||
}
|
||||
let staged = merge_saved_index(r, snapshot).unwrap_or_else(|error| {
|
||||
tracing::debug!(%error, "cannot merge saved index");
|
||||
None
|
||||
});
|
||||
let args = ["stash", "apply", "-q", snapshot];
|
||||
out = cli::run_raw(r.root(), &args, None)?;
|
||||
if out.code != Some(0) {
|
||||
let conflicts = unmerged_paths(r)?;
|
||||
return if conflicts.is_empty() {
|
||||
Err(cli::failure(&args, &out.stderr, &out.stdout, out.code))
|
||||
} else {
|
||||
Ok(conflicts)
|
||||
};
|
||||
}
|
||||
if let Some((before, merged)) = staged {
|
||||
// Update only the index, keeping unrelated entries and the merged working copy.
|
||||
run(r.root(), &["read-tree", "-m", "-i", &before, &merged], None)?;
|
||||
}
|
||||
}
|
||||
Ok(Vec::new())
|
||||
}
|
||||
|
||||
/// `stash apply --index` applies a patch without a three-way fallback. The patch
|
||||
/// can fail on context even when both the staged and working changes merge cleanly.
|
||||
fn merge_saved_index(r: &Repo, snapshot: &str) -> IdeResult<Option<(String, String)>> {
|
||||
let base = format!("{snapshot}^1");
|
||||
let saved = format!("{snapshot}^2");
|
||||
let patch = crate::patch::shelf_tree_patch_with_prefix(r, &base, &saved, "")?;
|
||||
if patch.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let before = run(r.root(), &["write-tree"], None)?.stdout_str().trim().to_owned();
|
||||
let index = cli::TempIndex::new(r);
|
||||
let env = index.env();
|
||||
cli::run_env(r.root(), &["read-tree", &before], None, &env)?;
|
||||
cli::run_env(r.root(), &["apply", "--cached", "--3way", "--whitespace=nowarn", "-"], Some(patch.as_bytes()), &env)?;
|
||||
let merged = cli::run_env(r.root(), &["write-tree"], None, &env)?.stdout_str().trim().to_owned();
|
||||
Ok((before != merged).then_some((before, merged)))
|
||||
}
|
||||
|
||||
fn restore_entry(r: &Repo, saved: Saved, allow_unstaged: bool) -> IdeResult<Vec<String>> {
|
||||
std::fs::remove_file(r.git_dir.join(MARKER))?;
|
||||
match saved {
|
||||
Saved::Stash(stash) => {
|
||||
let conflicts = apply_snapshot(r, &stash.id, allow_unstaged)?;
|
||||
if conflicts.is_empty() {
|
||||
drop_restored_stash(r, &stash)?;
|
||||
}
|
||||
Ok(conflicts)
|
||||
}
|
||||
Saved::Shelf { directory, entry, snapshot } => {
|
||||
let restored = restore_shelf(r, &directory, &entry, &snapshot, allow_unstaged);
|
||||
if restored.as_ref().is_ok_and(|files| !files.is_empty()) {
|
||||
crate::conflict_resolution::record_conflicts(
|
||||
r,
|
||||
crate::conflict_resolution::RestoreConflict::AutomaticShelf,
|
||||
);
|
||||
}
|
||||
restored
|
||||
}
|
||||
Saved::Shelves(shelves) => {
|
||||
let restored = restore_shelves(r, &shelves, allow_unstaged);
|
||||
if restored.is_ok() {
|
||||
shelves.remove_archive();
|
||||
}
|
||||
if restored.as_ref().is_ok_and(|files| !files.is_empty()) {
|
||||
crate::conflict_resolution::record_conflicts(
|
||||
r,
|
||||
crate::conflict_resolution::RestoreConflict::AutomaticShelf,
|
||||
);
|
||||
}
|
||||
restored
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn restore_shelves(r: &Repo, shelves: &SavedShelves, allow_unstaged: bool) -> IdeResult<Vec<String>> {
|
||||
let pending = shelves.pending()?;
|
||||
if pending.is_empty() {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let owned: Vec<_> = pending.iter().map(|entry| crate::patch::parse_patch(&entry.patch)).collect();
|
||||
if owned.iter().any(Vec::is_empty) {
|
||||
return Err(IdeError::invalid("no file changes found in the patch"));
|
||||
}
|
||||
shelves.unpack(r)?;
|
||||
let conflicts = if pending.len() == shelves.entries.len() && pending.iter().all(|entry| entry.intact) {
|
||||
apply_snapshot(r, &shelves.snapshot, allow_unstaged)?
|
||||
} else {
|
||||
let patch: String = pending.iter().map(|entry| entry.patch.as_str()).collect();
|
||||
restore_selected(r, &shelves.snapshot, &patch, &shelves.prefix, allow_unstaged)?
|
||||
};
|
||||
let local = |file: &crate::PatchFile| file.path.strip_prefix(&shelves.prefix).unwrap_or(&file.path).to_owned();
|
||||
let owned: Vec<_> = owned.iter().map(|files| files.iter().map(local).collect::<Vec<_>>()).collect();
|
||||
// A rename conflict may have a path that does not appear in any original shelf.
|
||||
if conflicts.iter().all(|path| owned.iter().flatten().any(|file| file == path)) {
|
||||
for (entry, files) in pending.iter().zip(owned) {
|
||||
if files.iter().all(|file| !conflicts.contains(file)) {
|
||||
crate::shelf::delete(&shelves.directory, &entry.id)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(conflicts)
|
||||
}
|
||||
|
||||
/// Keep the index state of the remaining files when a shelf or some of its paths were removed.
|
||||
fn restore_selected(
|
||||
r: &Repo,
|
||||
snapshot: &str,
|
||||
patch: &str,
|
||||
prefix: &str,
|
||||
allow_unstaged: bool,
|
||||
) -> IdeResult<Vec<String>> {
|
||||
let base = format!("{snapshot}^1");
|
||||
let working = crate::patch::shelf_tree_patch_with_prefix(r, &base, snapshot, prefix)?;
|
||||
let staged = crate::patch::shelf_tree_patch_with_prefix(r, &base, &format!("{snapshot}^2"), prefix)?;
|
||||
let originals: HashMap<_, _> = crate::patch::sections(&staged)
|
||||
.into_iter()
|
||||
.chain(crate::patch::sections(&working))
|
||||
.map(|(section, file)| (file.path, section))
|
||||
.collect();
|
||||
let selected = crate::patch::sections(patch);
|
||||
if selected.iter().any(|(section, file)| originals.get(&file.path) != Some(section)) {
|
||||
return Ok(crate::patch::apply_with_prefix(r, patch, prefix)?.conflicts);
|
||||
}
|
||||
let paths: HashSet<_> = selected.into_iter().map(|(_, file)| file.path).collect();
|
||||
let select = |source: &str| -> String {
|
||||
crate::patch::sections(source)
|
||||
.into_iter()
|
||||
.filter(|(_, file)| paths.contains(&file.path))
|
||||
.map(|(section, _)| section)
|
||||
.collect()
|
||||
};
|
||||
let indexed = snapshot_tree(r, &base, &select(&staged), prefix)?;
|
||||
let worktree = snapshot_tree(r, &base, &select(&working), prefix)?;
|
||||
let commit = |tree: &str, parents: &[&str]| -> IdeResult<String> {
|
||||
let mut args = vec![
|
||||
"-c",
|
||||
"user.name=OpenIDEA",
|
||||
"-c",
|
||||
"user.email=openidea@localhost",
|
||||
"commit-tree",
|
||||
tree,
|
||||
"--no-gpg-sign",
|
||||
"-m",
|
||||
"Saved local changes",
|
||||
];
|
||||
for parent in parents {
|
||||
args.extend(["-p", parent]);
|
||||
}
|
||||
Ok(run(r.root(), &args, None)?.stdout_str().trim().to_owned())
|
||||
};
|
||||
let indexed = commit(&indexed, &[&base])?;
|
||||
let snapshot = commit(&worktree, &[&base, &indexed])?;
|
||||
apply_snapshot(r, &snapshot, allow_unstaged)
|
||||
}
|
||||
|
||||
fn snapshot_tree(r: &Repo, base: &str, patch: &str, prefix: &str) -> IdeResult<String> {
|
||||
let index = cli::TempIndex::new(r);
|
||||
let env = index.env();
|
||||
cli::run_env(r.root(), &["read-tree", base], None, &env)?;
|
||||
if !patch.is_empty() {
|
||||
let strip = crate::patch::strip_option(prefix);
|
||||
let mut args = vec!["apply", "--cached", "--binary", "--whitespace=nowarn"];
|
||||
args.extend(strip.as_deref());
|
||||
args.push("-");
|
||||
cli::run_env(r.root(), &args, Some(patch.as_bytes()), &env)?;
|
||||
}
|
||||
Ok(cli::run_env(r.root(), &["write-tree"], None, &env)?.stdout_str().trim().to_owned())
|
||||
}
|
||||
|
||||
fn restore_shelf(
|
||||
r: &Repo,
|
||||
directory: &std::path::Path,
|
||||
entry: &str,
|
||||
snapshot: &str,
|
||||
allow_unstaged: bool,
|
||||
) -> IdeResult<Vec<String>> {
|
||||
match crate::shelf::pending_snapshot(directory, entry, snapshot)? {
|
||||
None => Ok(Vec::new()),
|
||||
Some(false) => Ok(crate::shelf::unshelve(r, directory, entry, true)?.conflicts),
|
||||
Some(true) => {
|
||||
crate::shelf::materialize_snapshot(r, directory, entry)?;
|
||||
let conflicts = apply_snapshot(r, snapshot, allow_unstaged)?;
|
||||
if conflicts.is_empty() {
|
||||
crate::shelf::delete(directory, entry)?;
|
||||
}
|
||||
Ok(conflicts)
|
||||
}
|
||||
}
|
||||
fn stash_top(r: &Repo) -> Option<String> {
|
||||
run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).ok().map(|o| o.stdout_str().trim().to_owned())
|
||||
}
|
||||
|
||||
/// Brings the saved changes back once no operation is in progress. Fails when they come
|
||||
/// back with conflicts (they then also stay in the stash).
|
||||
pub(crate) fn restore(r: &Repo) -> IdeResult<()> {
|
||||
restore_locked(r, None)
|
||||
}
|
||||
|
||||
pub(crate) fn finish_batch(r: &Repo, batch: &str) -> IdeResult<()> {
|
||||
restore_locked(r, Some(batch))
|
||||
}
|
||||
|
||||
fn restore_locked(r: &Repo, batch: Option<&str>) -> IdeResult<()> {
|
||||
if !r.git_dir.join(MARKER).exists() {
|
||||
return Ok(());
|
||||
}
|
||||
let _stash_lock = crate::write::lock_stashes(r)?;
|
||||
restore_saved(r, batch)
|
||||
}
|
||||
|
||||
fn restore_saved(r: &Repo, batch: Option<&str>) -> IdeResult<()> {
|
||||
let marker = r.git_dir.join(MARKER);
|
||||
let saved = match std::fs::read_to_string(&marker) {
|
||||
Ok(saved) => saved,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(()),
|
||||
Err(error) => return Err(error.into()),
|
||||
};
|
||||
if r.operation()?.is_some() || !unmerged_paths(r)?.is_empty() {
|
||||
let Ok(saved) = std::fs::read_to_string(&marker) else { return Ok(()) };
|
||||
if r.branch_info()?.operation.is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
let _ = std::fs::remove_file(&marker);
|
||||
let saved = saved.trim();
|
||||
let parsed = if saved.starts_with('{') {
|
||||
Some(serde_json::from_str::<Saved>(saved).map_err(|e| IdeError::internal(e.to_string()))?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let saved_batch = match &parsed {
|
||||
Some(Saved::Shelves(shelves)) => shelves.batch.as_deref(),
|
||||
_ => None,
|
||||
};
|
||||
let restore = match batch {
|
||||
Some(batch) => saved_batch == Some(batch),
|
||||
None => !saved_batch.is_some_and(crate::shelf::is_active_batch),
|
||||
};
|
||||
if !restore {
|
||||
let stashes = run(r.root(), &["stash", "list", "--format=%H"], None)?.stdout_str();
|
||||
let Some(index) = stashes.lines().position(|id| id.trim() == saved) else { return Ok(()) };
|
||||
let entry = format!("stash@{{{index}}}");
|
||||
if cli::run_raw(r.root(), &["stash", "pop", "-q", "--index", &entry], None)?.code == Some(0) {
|
||||
return Ok(());
|
||||
}
|
||||
let saved = match parsed {
|
||||
Some(Saved::Stash(stash)) => selected_stash_index(r, &stash)?.map(|_| Saved::Stash(stash)),
|
||||
Some(shelf) => Some(shelf),
|
||||
None => {
|
||||
let mut matches = r.stashes()?.into_iter().filter(|stash| stash.id == saved);
|
||||
let stash = matches.next();
|
||||
if matches.next().is_some() {
|
||||
return Err(IdeError::invalid("Could not identify the stash containing the saved local changes"));
|
||||
}
|
||||
stash.map(Saved::Stash)
|
||||
}
|
||||
};
|
||||
let Some(saved) = saved else {
|
||||
std::fs::remove_file(marker)?;
|
||||
// The staged part no longer applies as it was: bring everything back unstaged.
|
||||
if unmerged_paths(r)?.is_empty() && cli::run_raw(r.root(), &["stash", "pop", "-q", &entry], None)?.code == Some(0) {
|
||||
return Ok(());
|
||||
};
|
||||
let message = match &saved {
|
||||
Saved::Stash(_) => "local changes were restored with conflicts; resolve them (a copy stays in the stash)",
|
||||
Saved::Shelf { .. } | Saved::Shelves(_) => {
|
||||
"Local changes were restored with conflicts. A copy stays on the Shelf."
|
||||
}
|
||||
};
|
||||
if !restore_entry(r, saved, true)?.is_empty() {
|
||||
return Err(IdeError::invalid(message));
|
||||
}
|
||||
Ok(())
|
||||
Err(IdeError::invalid("local changes were restored with conflicts; resolve them (a copy stays in the stash)"))
|
||||
}
|
||||
|
||||
/// Runs `op` with the local changes put aside, and brings them back if it finished.
|
||||
|
||||
@@ -1,489 +0,0 @@
|
||||
use gix::bstr::{BStr, ByteSlice};
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
|
||||
use crate::{
|
||||
OutgoingCommits, Repo, cli,
|
||||
ops::{remote_fetch_url, remote_push_urls},
|
||||
refs,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PushSelection {
|
||||
/// A local branch. A detached source has no branch and requires a commit ID.
|
||||
pub branch: Option<String>,
|
||||
pub revision: Option<String>,
|
||||
pub remote: String,
|
||||
pub target: String,
|
||||
/// A configured non-branch destination, for example a Gerrit review ref.
|
||||
#[serde(default)]
|
||||
pub special_ref: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DefaultPushTarget {
|
||||
pub selection: PushSelection,
|
||||
pub set_upstream: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
pub struct CommitPushTarget {
|
||||
pub branch: Option<String>,
|
||||
pub destination: Option<DefaultPushTarget>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
|
||||
pub struct PushTargetChoices {
|
||||
pub branch: Option<String>,
|
||||
pub destination: Option<DefaultPushTarget>,
|
||||
pub destinations: Vec<DefaultPushTarget>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PushInspection {
|
||||
pub state: PushTargetState,
|
||||
pub local_tip: String,
|
||||
/// An empty value expects the branch to be absent. Null means no tip was available.
|
||||
pub remote_tip: Option<String>,
|
||||
pub remote_commits: u32,
|
||||
pub remote_checked: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum PushTargetState {
|
||||
Ready,
|
||||
Diverged,
|
||||
FetchRequired,
|
||||
}
|
||||
|
||||
impl PushSelection {
|
||||
pub(crate) fn refs(&self, repo: &Repo, cancel: &CancellationToken) -> IdeResult<(Option<String>, String, String)> {
|
||||
let source = self.branch.as_ref().map(|branch| format!("refs/heads/{branch}"));
|
||||
let target = self.target_ref(repo, cancel)?;
|
||||
if let Some(source) = source.as_deref() {
|
||||
cli::run_cancellable(repo.root(), &["check-ref-format", source], cancel)?;
|
||||
}
|
||||
let rev = if let Some(source) = source.as_deref() {
|
||||
self.revision.as_deref().unwrap_or(source)
|
||||
} else {
|
||||
self.revision
|
||||
.as_deref()
|
||||
.filter(|rev| gix::ObjectId::from_hex(rev.as_bytes()).is_ok())
|
||||
.ok_or_else(|| IdeError::invalid("A detached push requires a commit ID."))?
|
||||
};
|
||||
let local_tip = commit_id(repo, rev, cancel)?;
|
||||
Ok((source, target, local_tip))
|
||||
}
|
||||
|
||||
fn target_ref(&self, repo: &Repo, cancel: &CancellationToken) -> IdeResult<String> {
|
||||
let target = if self.special_ref {
|
||||
if !self.target.starts_with("refs/") {
|
||||
return Err(IdeError::invalid("Invalid push destination"));
|
||||
}
|
||||
self.target.clone()
|
||||
} else {
|
||||
format!("refs/heads/{}", self.target)
|
||||
};
|
||||
cli::run_cancellable(repo.root(), &["check-ref-format", &target], cancel)?;
|
||||
Ok(target)
|
||||
}
|
||||
}
|
||||
|
||||
fn commit_id(repo: &Repo, rev: &str, cancel: &CancellationToken) -> IdeResult<String> {
|
||||
let rev = format!("{rev}^{{commit}}");
|
||||
let output = cli::run_cancellable(repo.root(), &["rev-parse", "--verify", "--end-of-options", &rev], cancel)?;
|
||||
Ok(output.stdout_str().trim().to_owned())
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
/// Prefer the checked-out branch if it contains the selected commit, then another
|
||||
/// containing local branch. A tag or remote branch alone is a detached source.
|
||||
pub fn commit_push_target(&self, revision: &str, cancel: &CancellationToken) -> IdeResult<CommitPushTarget> {
|
||||
let choices = self.resolve_push_targets(None, Some(revision), cancel, false)?;
|
||||
Ok(CommitPushTarget { branch: choices.branch, destination: choices.destination })
|
||||
}
|
||||
|
||||
/// The destination shown by Push and used by Commit and Push for a local source.
|
||||
pub fn default_push_target(&self, branch: Option<&str>) -> IdeResult<Option<DefaultPushTarget>> {
|
||||
self.resolve_push_targets(branch, None, &CancellationToken::new(), false).map(|choices| choices.destination)
|
||||
}
|
||||
|
||||
/// Resolve one source and its configured destination on every available remote.
|
||||
pub fn push_target_choices(
|
||||
&self,
|
||||
branch: Option<&str>,
|
||||
commit: Option<&str>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<PushTargetChoices> {
|
||||
self.resolve_push_targets(branch, commit, cancel, true)
|
||||
}
|
||||
|
||||
fn commit_push_source(&self, revision: &str, cancel: &CancellationToken) -> IdeResult<(Option<String>, String)> {
|
||||
let revision = commit_id(self, revision, cancel)?;
|
||||
let refs = cli::run_cancellable(
|
||||
self.root(),
|
||||
&[
|
||||
"for-each-ref",
|
||||
&format!("--contains={revision}"),
|
||||
"--sort=version:refname",
|
||||
"--format=%(HEAD)%(refname:lstrip=2)",
|
||||
"refs/heads/",
|
||||
],
|
||||
cancel,
|
||||
)?
|
||||
.stdout_str();
|
||||
let local = || refs.lines().filter_map(|line| line.strip_prefix(' '));
|
||||
let branch = refs
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix('*'))
|
||||
.or_else(|| local().find(|name| matches!(*name, "main" | "master")))
|
||||
.or_else(|| local().next());
|
||||
Ok((branch.map(str::to_owned), revision))
|
||||
}
|
||||
|
||||
fn resolve_push_targets(
|
||||
&self,
|
||||
branch: Option<&str>,
|
||||
commit: Option<&str>,
|
||||
cancel: &CancellationToken,
|
||||
alternatives: bool,
|
||||
) -> IdeResult<PushTargetChoices> {
|
||||
let repo = self.gix()?;
|
||||
let selected = commit.map(|commit| self.commit_push_source(commit, cancel)).transpose()?;
|
||||
let branch = selected.as_ref().map_or(branch, |(branch, _)| branch.as_deref());
|
||||
let head = repo.head_name().map_err(crate::repo::gx)?;
|
||||
let source = if let Some(branch) = branch {
|
||||
let reference =
|
||||
repo.try_find_reference(format!("refs/heads/{branch}").as_str()).map_err(crate::repo::gx)?;
|
||||
let Some(reference) = reference else { return Ok(PushTargetChoices::default()) };
|
||||
Some(reference.name().to_owned())
|
||||
} else if selected.is_none() {
|
||||
head.clone()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let revision = selected
|
||||
.map(|(_, revision)| revision)
|
||||
.or_else(|| if source.is_some() { None } else { repo.head_id().ok().map(|tip| tip.to_string()) });
|
||||
let branch = source.as_ref().map(|name| name.as_ref().shorten().to_str_lossy().into_owned());
|
||||
if source.is_none() && revision.is_none() {
|
||||
return Ok(PushTargetChoices::default());
|
||||
}
|
||||
let names = repo.remote_names();
|
||||
let remote = default_push_remote(&repo, &names, branch.as_deref());
|
||||
let make = |remote: &BStr| -> IdeResult<DefaultPushTarget> {
|
||||
if let Some(source) = &source {
|
||||
let remote = repo.find_remote(remote).map_err(crate::repo::gx)?;
|
||||
let mut target = branch_push_target(&repo, source.as_ref(), &remote)?;
|
||||
if let Some(revision) = &revision {
|
||||
target.selection.revision = Some(revision.clone());
|
||||
target.set_upstream = false;
|
||||
}
|
||||
return Ok(target);
|
||||
}
|
||||
detached_push_target(
|
||||
&repo,
|
||||
revision.as_deref().expect("a detached source has a revision"),
|
||||
remote,
|
||||
head.as_ref().map(|head| head.as_ref().shorten()),
|
||||
)
|
||||
};
|
||||
let destination = remote.map(make).transpose()?;
|
||||
let destinations =
|
||||
if alternatives { names.iter().filter_map(|name| make(name.as_bstr()).ok()).collect() } else { Vec::new() };
|
||||
Ok(PushTargetChoices { branch, destination, destinations })
|
||||
}
|
||||
}
|
||||
|
||||
fn default_push_remote<'names>(
|
||||
repo: &gix::Repository,
|
||||
names: &'names gix::remote::Names,
|
||||
branch: Option<&str>,
|
||||
) -> Option<&'names BStr> {
|
||||
let preferred = branch.and_then(|branch| repo.branch_remote_name(branch, gix::remote::Direction::Push));
|
||||
let remote = match preferred.as_ref().map(|name| name.as_bstr()) {
|
||||
Some(name) if name != "." => names.iter().find(|candidate| candidate.as_bstr() == name),
|
||||
_ => names.iter().find(|name| name.as_bstr() == "origin").or_else(|| names.iter().next()),
|
||||
};
|
||||
remote.map(|name| name.as_bstr())
|
||||
}
|
||||
|
||||
fn branch_push_target(
|
||||
repo: &gix::Repository,
|
||||
source: &gix::refs::FullNameRef,
|
||||
configured: &gix::Remote<'_>,
|
||||
) -> IdeResult<DefaultPushTarget> {
|
||||
let remote = configured.name().ok_or_else(|| IdeError::invalid("Unknown push remote"))?.as_bstr();
|
||||
let branch = source.shorten().to_str_lossy().into_owned();
|
||||
let upstream_remote = repo.branch_remote_name(branch.as_str(), gix::remote::Direction::Fetch);
|
||||
let upstream =
|
||||
repo.branch_remote_ref_name(source, gix::remote::Direction::Fetch).transpose().map_err(crate::repo::gx)?;
|
||||
let remote_name = remote.to_str_lossy().into_owned();
|
||||
let specs = configured.refspecs(gix::remote::Direction::Push);
|
||||
let target = configured_destination(repo, source, &branch, specs)
|
||||
.or_else(|| {
|
||||
(upstream_remote.as_ref().map(|upstream| upstream.as_bstr()) == Some(remote))
|
||||
.then_some(upstream.as_ref())
|
||||
.flatten()
|
||||
.map(|name| name.as_bstr().to_str_lossy().into_owned())
|
||||
})
|
||||
.unwrap_or_else(|| source.as_bstr().to_str_lossy().into_owned());
|
||||
let tracking_prefix = format!("refs/remotes/{remote_name}/");
|
||||
let (target, special_ref) =
|
||||
if let Some(short) = target.strip_prefix("refs/heads/").or_else(|| target.strip_prefix(&tracking_prefix)) {
|
||||
(short.to_owned(), false)
|
||||
} else {
|
||||
let special = target.starts_with("refs/");
|
||||
(target, special)
|
||||
};
|
||||
let tracking = format!("refs/remotes/{remote_name}/{target}");
|
||||
let set_upstream = !special_ref
|
||||
&& upstream.is_none()
|
||||
&& repo.try_find_reference(tracking.as_str()).map_err(crate::repo::gx)?.is_none();
|
||||
Ok(DefaultPushTarget {
|
||||
selection: PushSelection { branch: Some(branch), revision: None, remote: remote_name, target, special_ref },
|
||||
set_upstream,
|
||||
})
|
||||
}
|
||||
|
||||
fn push_tracking_tip(remote: &gix::Remote<'_>, target: &str) -> Option<(String, gix::ObjectId)> {
|
||||
use gix::remote::Direction::{Fetch, Push};
|
||||
let fetch_url = remote.url(Fetch)?;
|
||||
let mut push_urls = remote.urls(Push);
|
||||
if push_urls.next()? != fetch_url || push_urls.next().is_some() {
|
||||
return None;
|
||||
}
|
||||
let target_ref = format!("refs/heads/{target}");
|
||||
let null = remote.repo().object_hash().null();
|
||||
let group =
|
||||
gix::refspec::MatchGroup { specs: remote.refspecs(Fetch).iter().map(gix::refspec::RefSpec::to_ref).collect() };
|
||||
let matches = group.match_lhs(std::iter::once(gix::refspec::match_group::Item {
|
||||
full_ref_name: target_ref.as_str().into(),
|
||||
target: &null,
|
||||
object: None,
|
||||
}));
|
||||
let mut destinations = matches.mappings.iter().filter_map(|mapping| mapping.rhs.as_deref());
|
||||
let tracking = destinations.next()?;
|
||||
if destinations.any(|other| other != tracking) {
|
||||
return None;
|
||||
}
|
||||
let mut reference = remote.repo().try_find_reference(tracking).ok()??;
|
||||
let name = crate::repo::to_string(reference.name().as_bstr());
|
||||
let tip = reference.peel_to_id().ok()?.detach();
|
||||
Some((name, tip))
|
||||
}
|
||||
|
||||
pub(crate) fn outgoing_commits(
|
||||
repo: &gix::Repository,
|
||||
remotes: &gix::remote::Names,
|
||||
source: &gix::refs::FullNameRef,
|
||||
local: gix::ObjectId,
|
||||
counted_upstream: Option<(gix::ObjectId, u32)>,
|
||||
) -> Option<OutgoingCommits> {
|
||||
let name = source.shorten().to_str_lossy();
|
||||
let remote = repo.find_remote(default_push_remote(repo, remotes, Some(&name))?).ok()?;
|
||||
let target = branch_push_target(repo, source, &remote).ok()?.selection;
|
||||
if target.special_ref {
|
||||
return None;
|
||||
}
|
||||
let (reference, tip) = push_tracking_tip(&remote, &target.target)?;
|
||||
let count = if tip == local {
|
||||
0
|
||||
} else if let Some((_, count)) = counted_upstream.filter(|(upstream, _)| *upstream == tip) {
|
||||
count
|
||||
} else {
|
||||
crate::refs::count_commits(repo, local, tip).ok()?
|
||||
};
|
||||
Some(OutgoingCommits { remote: target.remote, branch: target.target, reference, count })
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
/// Compare the selected source with the destination actually used by Git push.
|
||||
pub fn inspect_push(
|
||||
&self,
|
||||
selection: &PushSelection,
|
||||
live: bool,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<PushInspection> {
|
||||
let _scope = self.execution_scope();
|
||||
let (source, target, local_tip) = selection.refs(self, cancel)?;
|
||||
let urls = remote_push_urls(self, &selection.remote, cancel)?;
|
||||
let mut result = PushInspection {
|
||||
state: PushTargetState::Ready,
|
||||
local_tip,
|
||||
remote_tip: None,
|
||||
remote_commits: 0,
|
||||
remote_checked: selection.special_ref,
|
||||
};
|
||||
if selection.special_ref {
|
||||
return Ok(result);
|
||||
}
|
||||
if urls.len() != 1 {
|
||||
return Ok(result);
|
||||
}
|
||||
|
||||
let mut advertised = None;
|
||||
if live {
|
||||
match cli::run_with_saved_credentials_raw(
|
||||
self.root(),
|
||||
&["ls-remote", "--exit-code", "--refs", "--", &urls[0], &target],
|
||||
cancel,
|
||||
) {
|
||||
Ok(output) if output.code == Some(2) => {
|
||||
result.remote_checked = true;
|
||||
result.remote_tip = Some(String::new());
|
||||
return Ok(result);
|
||||
}
|
||||
Ok(output) if output.code == Some(0) => {
|
||||
advertised = output
|
||||
.stdout_str()
|
||||
.lines()
|
||||
.filter_map(|line| line.split_once('\t'))
|
||||
.find(|(_, name)| *name == target)
|
||||
.and_then(|(id, _)| gix::ObjectId::from_hex(id.as_bytes()).ok())
|
||||
.map(|id| id.to_string());
|
||||
result.remote_checked = advertised.is_some();
|
||||
}
|
||||
Err(error) if error.kind == ErrorKind::Cancelled => return Err(error),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
// Neither a fetch ref nor its observation describes a separate push endpoint.
|
||||
let tip = advertised.or_else(|| {
|
||||
if remote_fetch_url(self, &selection.remote, cancel).ok()? != urls[0] {
|
||||
return None;
|
||||
}
|
||||
let repo = self.gix().ok()?;
|
||||
let remote = repo.find_remote(selection.remote.as_str()).ok()?;
|
||||
let (_, tracked) = push_tracking_tip(&remote, &selection.target)?;
|
||||
let tracked = tracked.to_string();
|
||||
let observed = source.as_deref().and_then(|source| {
|
||||
let reference = repo.find_reference(source).ok()?;
|
||||
let tracking = refs::configured_upstream(&repo, reference.name())?;
|
||||
if tracking.remote != selection.remote || tracking.branch != selection.target {
|
||||
return None;
|
||||
}
|
||||
self.observed_incoming_tip(selection.branch.as_deref()?, &tracking, &tracked, &urls[0])
|
||||
});
|
||||
Some(observed.unwrap_or(tracked))
|
||||
});
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let Some(tip) = tip else { return Ok(result) };
|
||||
if let Err(error) = commit_id(self, &tip, cancel) {
|
||||
if error.kind == ErrorKind::Cancelled {
|
||||
return Err(error);
|
||||
}
|
||||
result.state = PushTargetState::FetchRequired;
|
||||
result.remote_tip = Some(tip);
|
||||
return Ok(result);
|
||||
}
|
||||
let range = format!("{}...{tip}", result.local_tip);
|
||||
let counts = cli::run_cancellable(self.root(), &["rev-list", "--left-right", "--count", &range], cancel)?;
|
||||
let counts = counts.stdout_str();
|
||||
if let Some((ahead, behind)) = counts.trim().split_once('\t')
|
||||
&& ahead.parse::<u32>().is_ok_and(|ahead| ahead > 0)
|
||||
&& let Ok(behind) = behind.parse::<u32>()
|
||||
&& behind > 0
|
||||
{
|
||||
result.state = PushTargetState::Diverged;
|
||||
result.remote_commits = behind;
|
||||
}
|
||||
result.remote_tip = Some(tip);
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
pub fn fetch_push_target(
|
||||
&self,
|
||||
selection: &PushSelection,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let target = selection.target_ref(self, cancel)?;
|
||||
let urls = remote_push_urls(self, &selection.remote, cancel)?;
|
||||
let [url] = urls.as_slice() else {
|
||||
return Err(IdeError::invalid("The remote has multiple push URLs."));
|
||||
};
|
||||
if &remote_fetch_url(self, &selection.remote, cancel)? == url {
|
||||
// The configured fetch refspec maps this branch to its remote-tracking ref.
|
||||
cli::run_streaming(
|
||||
self.root(),
|
||||
&["fetch", "--progress", "--no-tags", "--no-write-fetch-head", "--", &selection.remote, &target],
|
||||
cancel,
|
||||
out,
|
||||
)
|
||||
} else {
|
||||
// A separate push endpoint must not change the fetch endpoint's tracking refs.
|
||||
cli::run_cancellable(
|
||||
self.root(),
|
||||
&["fetch", "--no-tags", "--no-write-fetch-head", "--", url, &target],
|
||||
cancel,
|
||||
)
|
||||
.map(|_| ())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn detached_push_target(
|
||||
repo: &gix::Repository,
|
||||
revision: &str,
|
||||
remote: &BStr,
|
||||
current_branch: Option<&BStr>,
|
||||
) -> IdeResult<DefaultPushTarget> {
|
||||
let remote = remote.to_str_lossy().into_owned();
|
||||
let mut target = current_branch.map_or_else(|| "detached".to_owned(), |branch| branch.to_str_lossy().into_owned());
|
||||
let mut suffix = 2;
|
||||
loop {
|
||||
let tracking = format!("refs/remotes/{remote}/{target}");
|
||||
if current_branch.is_some() || repo.try_find_reference(tracking.as_str()).map_err(crate::repo::gx)?.is_none() {
|
||||
return Ok(DefaultPushTarget {
|
||||
selection: PushSelection {
|
||||
branch: None,
|
||||
revision: Some(revision.to_owned()),
|
||||
remote,
|
||||
target,
|
||||
special_ref: false,
|
||||
},
|
||||
set_upstream: false,
|
||||
});
|
||||
}
|
||||
target = format!("detached{suffix}");
|
||||
suffix += 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn configured_destination(
|
||||
repo: &gix::Repository,
|
||||
source: &gix::refs::FullNameRef,
|
||||
branch: &str,
|
||||
specs: &[gix::refspec::RefSpec],
|
||||
) -> Option<String> {
|
||||
let mut wildcards = Vec::new();
|
||||
for spec in specs.iter().map(gix::refspec::RefSpec::to_ref) {
|
||||
let (Some(lhs), Some(rhs)) = (spec.source(), spec.destination()) else { continue };
|
||||
if lhs == "HEAD" || lhs == branch || lhs == source.as_bstr() {
|
||||
return Some(rhs.to_str_lossy().into_owned());
|
||||
}
|
||||
if lhs.contains(&b'*') {
|
||||
wildcards.push(spec);
|
||||
}
|
||||
}
|
||||
let null_id = repo.object_hash().null();
|
||||
gix::refspec::MatchGroup { specs: wildcards }
|
||||
.match_lhs(std::iter::once(gix::refspec::match_group::Item {
|
||||
full_ref_name: source.as_bstr(),
|
||||
target: &null_id,
|
||||
object: None,
|
||||
}))
|
||||
.mappings
|
||||
.into_iter()
|
||||
.find_map(|m| m.rhs.map(|rhs| rhs.to_str_lossy().into_owned()))
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
use crate::cli;
|
||||
use ide_core::error::{ErrorData, ErrorKind, PushRefResult, PushRefStatus, PushReport};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use std::path::Path;
|
||||
|
||||
pub(crate) fn run(
|
||||
report: &mut PushReport,
|
||||
root: &Path,
|
||||
args: &[&str],
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let mut refs = Vec::new();
|
||||
let result = cli::run_streaming_stdout(root, args, cancel, on_output, &mut |line| {
|
||||
if let Some(result) = parse_ref(line) {
|
||||
refs.push(result);
|
||||
}
|
||||
});
|
||||
report.refs.extend(refs.into_iter().map(|(reference, status, summary)| {
|
||||
let commits = (status == PushRefStatus::FastForward).then(|| count_commits(root, &summary, cancel)).flatten();
|
||||
PushRefResult { reference, status, commits }
|
||||
}));
|
||||
result.map_err(|error| with_partial_push(error, report))
|
||||
}
|
||||
|
||||
pub(crate) fn with_partial_push(mut error: IdeError, report: &PushReport) -> IdeError {
|
||||
if error.kind != ErrorKind::Cancelled && report.refs.iter().any(|update| update.status != PushRefStatus::UpToDate) {
|
||||
error.data = Some(ErrorData::PushPartiallyApplied { report: Box::new(report.clone()) });
|
||||
}
|
||||
error
|
||||
}
|
||||
|
||||
fn parse_ref(line: &str) -> Option<(String, PushRefStatus, String)> {
|
||||
let (flag, fields) = line.split_once('\t')?;
|
||||
let status = match flag {
|
||||
" " => PushRefStatus::FastForward,
|
||||
"+" => PushRefStatus::Forced,
|
||||
"*" => PushRefStatus::Created,
|
||||
"=" => PushRefStatus::UpToDate,
|
||||
"-" => PushRefStatus::Deleted,
|
||||
_ => return None,
|
||||
};
|
||||
let (refs, summary) = fields.split_once('\t')?;
|
||||
let (_, reference) = refs.split_once(':')?;
|
||||
if !reference.starts_with("refs/") || reference.bytes().any(|byte| byte.is_ascii_whitespace()) {
|
||||
return None;
|
||||
}
|
||||
Some((reference.to_owned(), status, summary.trim().to_owned()))
|
||||
}
|
||||
|
||||
fn count_commits(root: &Path, range: &str, cancel: &CancellationToken) -> Option<u32> {
|
||||
let (from, to) = range.split_once("..")?;
|
||||
let is_hex = |name: &str| (4..=64).contains(&name.len()) && name.bytes().all(|byte| byte.is_ascii_hexdigit());
|
||||
if !is_hex(from) || !is_hex(to) {
|
||||
return None;
|
||||
}
|
||||
cli::run_cancellable(root, &["rev-list", "--count", range, "--"], cancel).ok()?.stdout_str().trim().parse().ok()
|
||||
}
|
||||
@@ -1,408 +0,0 @@
|
||||
use crate::{RebaseAction, RebaseOptions, Repo, cli, log_index::subject, manage::rebase_args, ops, repo::resolve};
|
||||
use gix::bstr::ByteSlice;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::ffi::OsStr;
|
||||
use std::fs;
|
||||
|
||||
#[derive(Deserialize, Serialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum RebaseEditorOperation {
|
||||
Start { upstream: Option<String>, options: RebaseOptions },
|
||||
Continue { stage: bool },
|
||||
Skip,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum RebaseEditKind {
|
||||
Plan,
|
||||
Message,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Type)]
|
||||
pub struct RebaseEdit {
|
||||
pub kind: RebaseEditKind,
|
||||
pub text: String,
|
||||
pub plan: Option<Vec<RebaseTodoRow>>,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Type)]
|
||||
pub struct RebaseEditorReply {
|
||||
pub text: String,
|
||||
#[serde(default)]
|
||||
pub rewords: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl From<String> for RebaseEditorReply {
|
||||
fn from(text: String) -> Self {
|
||||
Self { text, rewords: BTreeMap::new() }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum RebaseFixupMessage {
|
||||
Replace,
|
||||
Edit,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum RebaseTodoRow {
|
||||
Commit {
|
||||
line: usize,
|
||||
action: RebaseAction,
|
||||
#[serde(rename = "fixupMessage", skip_serializing_if = "Option::is_none")]
|
||||
fixup_message: Option<RebaseFixupMessage>,
|
||||
id: String,
|
||||
revision: String,
|
||||
author: String,
|
||||
summary: String,
|
||||
message: String,
|
||||
},
|
||||
UpdateRef {
|
||||
line: usize,
|
||||
reference: String,
|
||||
},
|
||||
}
|
||||
|
||||
// Git removes the saved drafts when it removes its rebase state.
|
||||
const EDITOR_MARKER: &str = "rebase-merge/openidea-editor";
|
||||
const EDITOR_COMMENT: &str = "\u{1}";
|
||||
const EDITOR_COMMENT_CONFIG: &str = "core.commentChar=\u{1}";
|
||||
const SCISSORS: &str = "------------------------ >8 ------------------------";
|
||||
|
||||
#[derive(Deserialize, Serialize)]
|
||||
struct SavedEditor {
|
||||
rewords: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
// Blank lines keep the editor tied to the host's output pipe and are dropped by the reader.
|
||||
const EDITOR: &str = r#"set -e
|
||||
dir=$OPENIDEA_GIT_EDITOR_DIR
|
||||
cp -- "$2" "$dir/input"
|
||||
printf '\n%s:%s\n' "$OPENIDEA_GIT_EDITOR_SIGNAL" "$1"
|
||||
while [ -d "$dir" ] && [ ! -f "$dir/reply" ] && [ ! -f "$dir/cancel" ]; do
|
||||
sleep 0.1
|
||||
printf '\n'
|
||||
done
|
||||
[ ! -f "$dir/cancel" ] || exit 1
|
||||
cp -- "$dir/reply" "$2"
|
||||
rm -- "$dir/reply"
|
||||
"#;
|
||||
|
||||
impl Repo {
|
||||
pub fn rebase_editor_operation(
|
||||
&self,
|
||||
operation: RebaseEditorOperation,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
edit: &dyn Fn(RebaseEdit) -> Option<RebaseEditorReply>,
|
||||
) -> IdeResult<()> {
|
||||
if let RebaseEditorOperation::Start { upstream, options } = operation {
|
||||
return self.rebase_with_editor(upstream.as_deref(), &options, cancel, out, edit);
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let _scope = self.execution_scope();
|
||||
if self.operation()?.as_deref() != Some("rebase") {
|
||||
return Err(IdeError::invalid("No rebase in progress"));
|
||||
}
|
||||
let run = |args: &[&str]| {
|
||||
if self.git_dir.join(EDITOR_MARKER).is_file() {
|
||||
self.run_rebase_editor(args, false, cancel, out, edit)
|
||||
} else {
|
||||
cli::run_streaming(self.root(), args, cancel, out)
|
||||
}
|
||||
};
|
||||
match operation {
|
||||
RebaseEditorOperation::Start { .. } => unreachable!(),
|
||||
RebaseEditorOperation::Continue { stage } => ops::continue_op(self, stage, run),
|
||||
RebaseEditorOperation::Skip => ops::skip_op(self, run),
|
||||
}
|
||||
}
|
||||
|
||||
/// Lets Git generate and execute its own interactive plan, including merge instructions.
|
||||
pub fn rebase_with_editor(
|
||||
&self,
|
||||
upstream: Option<&str>,
|
||||
options: &RebaseOptions,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
edit: &dyn Fn(RebaseEdit) -> Option<RebaseEditorReply>,
|
||||
) -> IdeResult<()> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let _scope = self.execution_scope();
|
||||
let mut args = rebase_args(upstream, options)?;
|
||||
self.validate_rebase(options)?;
|
||||
args.insert(1, "--interactive".into());
|
||||
let args: Vec<_> = args.iter().map(String::as_str).collect();
|
||||
crate::preserve::around(self, "Local changes saved before rebase", || {
|
||||
self.run_rebase_editor(&args, true, cancel, out, edit)
|
||||
})
|
||||
}
|
||||
|
||||
fn run_rebase_editor(
|
||||
&self,
|
||||
args: &[&str],
|
||||
starting: bool,
|
||||
cancel: &CancellationToken,
|
||||
out: &dyn Fn(String),
|
||||
edit: &dyn Fn(RebaseEdit) -> Option<RebaseEditorReply>,
|
||||
) -> IdeResult<()> {
|
||||
let session = tempfile::Builder::new().prefix("openidea-git-editor-").tempdir()?;
|
||||
let dir = session.path();
|
||||
let script = dir.join("editor.sh");
|
||||
fs::write(&script, EDITOR)?;
|
||||
let sequence = format!("sh {} plan", ops::quote_for_shell(&script));
|
||||
let message = format!("sh {} message", ops::quote_for_shell(&script));
|
||||
let signal = dir.file_name().and_then(OsStr::to_str).unwrap_or("openidea-git-editor");
|
||||
let dir_env = dir.to_string_lossy().replace('\\', "/");
|
||||
let env = [
|
||||
("GIT_SEQUENCE_EDITOR", OsStr::new(&sequence)),
|
||||
("GIT_EDITOR", OsStr::new(&message)),
|
||||
("OPENIDEA_GIT_EDITOR_DIR", OsStr::new(&dir_env)),
|
||||
("OPENIDEA_GIT_EDITOR_SIGNAL", OsStr::new(signal)),
|
||||
];
|
||||
let declined = Cell::new(false);
|
||||
let pipe_failed = Cell::new(false);
|
||||
let editor_error = RefCell::new(None);
|
||||
let marker = self.git_dir.join(EDITOR_MARKER);
|
||||
let saved = fs::read(&marker).unwrap_or_default();
|
||||
let editor = serde_json::from_slice::<SavedEditor>(&saved).ok();
|
||||
// Older sessions used the repository's own comment convention in their saved state.
|
||||
let private_comments = starting || editor.is_some();
|
||||
let drafts = RefCell::new(
|
||||
editor.map(|editor| editor.rewords).or_else(|| serde_json::from_slice(&saved).ok()).unwrap_or_default(),
|
||||
);
|
||||
let comment = todo_comment(self);
|
||||
let mut command = Vec::with_capacity(args.len() + 2);
|
||||
if private_comments {
|
||||
command.extend(["-c", EDITOR_COMMENT_CONFIG]);
|
||||
}
|
||||
command.extend_from_slice(args);
|
||||
// Once the editor has declined, let Git handle the exit and clean up its rebase state.
|
||||
let should_cancel = || pipe_failed.get() || (!declined.get() && cancel.is_cancelled());
|
||||
let result = cli::run_streaming_env_until(self.root(), &command, &env, &should_cancel, &|line| {
|
||||
let prompt = line.strip_prefix(signal).and_then(|suffix| match suffix {
|
||||
":plan" => Some(RebaseEditKind::Plan),
|
||||
":message" => Some(RebaseEditKind::Message),
|
||||
_ => None,
|
||||
});
|
||||
let Some(kind) = prompt else {
|
||||
out(line);
|
||||
return;
|
||||
};
|
||||
let reply = (|| -> IdeResult<()> {
|
||||
let input = dir.join("input");
|
||||
let text = fs::read_to_string(&input)?;
|
||||
fs::remove_file(input)?;
|
||||
let is_plan = matches!(kind, RebaseEditKind::Plan);
|
||||
let plan_comment = if private_comments { EDITOR_COMMENT } else { &comment };
|
||||
let plan = if is_plan { simple_plan(self, &text, plan_comment, cancel) } else { None };
|
||||
let prepared = if is_plan { None } else { reword_for_git_step(self, &drafts.borrow()) };
|
||||
let answer = prepared.map(RebaseEditorReply::from).or_else(|| {
|
||||
let text = match (private_comments, is_plan) {
|
||||
(true, true) => display_todo_comments(&text, &comment),
|
||||
(true, false) => message_body(&text),
|
||||
_ => text,
|
||||
};
|
||||
edit(RebaseEdit { kind, text, plan })
|
||||
});
|
||||
if let Some(mut answer) = answer {
|
||||
let pending = dir.join("reply.tmp");
|
||||
if is_plan && private_comments {
|
||||
// Help and notes have no effect on the replay. The saved todo remains
|
||||
// readable by Git using the repository's own comment convention.
|
||||
answer.text = answer
|
||||
.text
|
||||
.split_inclusive('\n')
|
||||
.filter(|line| !todo_line(line).starts_with(&comment))
|
||||
.collect();
|
||||
}
|
||||
fs::write(&pending, &answer.text)?;
|
||||
if is_plan {
|
||||
let approved = approved_rewords(self, &answer.text, &answer.rewords);
|
||||
let editor = SavedEditor { rewords: approved };
|
||||
let bytes = serde_json::to_vec(&editor).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
fs::write(&marker, bytes)?;
|
||||
drafts.replace(editor.rewords);
|
||||
}
|
||||
fs::rename(&pending, dir.join("reply"))?;
|
||||
} else {
|
||||
declined.set(true);
|
||||
fs::write(dir.join("cancel"), [])?;
|
||||
}
|
||||
Ok(())
|
||||
})();
|
||||
if let Err(error) = reply {
|
||||
*editor_error.borrow_mut() = Some(error);
|
||||
if fs::write(dir.join("cancel"), []).is_err() {
|
||||
pipe_failed.set(true);
|
||||
}
|
||||
}
|
||||
});
|
||||
if let Some(error) = editor_error.into_inner() {
|
||||
return Err(error);
|
||||
}
|
||||
if declined.get() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
fn todo_line(line: &str) -> &str {
|
||||
line.trim_start_matches([' ', '\t'])
|
||||
}
|
||||
|
||||
fn todo_comment(r: &Repo) -> String {
|
||||
r.gix()
|
||||
.ok()
|
||||
.and_then(|repo| {
|
||||
let config = repo.config_snapshot();
|
||||
config
|
||||
.string("core.commentString")
|
||||
.or_else(|| config.string("core.commentChar"))
|
||||
.map(|comment| comment.to_str_lossy().into_owned())
|
||||
})
|
||||
.filter(|comment| !comment.is_empty() && comment != "auto" && !comment.starts_with(char::is_alphabetic))
|
||||
.unwrap_or_else(|| "#".into())
|
||||
}
|
||||
|
||||
fn display_todo_comments(text: &str, comment: &str) -> String {
|
||||
let mut display = String::with_capacity(text.len());
|
||||
for line in text.split_inclusive('\n') {
|
||||
let command = todo_line(line);
|
||||
if let Some(note) = command.strip_prefix(EDITOR_COMMENT) {
|
||||
display.push_str(&line[..line.len() - command.len()]);
|
||||
display.push_str(comment);
|
||||
display.push_str(note);
|
||||
} else {
|
||||
display.push_str(line);
|
||||
}
|
||||
}
|
||||
display
|
||||
}
|
||||
|
||||
fn message_body(text: &str) -> String {
|
||||
text.split_inclusive('\n')
|
||||
.take_while(|line| line.strip_prefix(EDITOR_COMMENT).is_none_or(|note| note.trim() != SCISSORS))
|
||||
.filter(|line| !line.starts_with(EDITOR_COMMENT))
|
||||
.collect()
|
||||
}
|
||||
|
||||
struct CommitCommand<'a> {
|
||||
action: RebaseAction,
|
||||
revision: &'a str,
|
||||
fixup_message: Option<RebaseFixupMessage>,
|
||||
}
|
||||
|
||||
fn commit_command(line: &str) -> Option<CommitCommand<'_>> {
|
||||
let mut words = line.split_ascii_whitespace();
|
||||
let action = match words.next()? {
|
||||
"p" | "pick" => RebaseAction::Pick,
|
||||
"r" | "reword" => RebaseAction::Reword,
|
||||
"e" | "edit" => RebaseAction::Edit,
|
||||
"s" | "squash" => RebaseAction::Squash,
|
||||
"f" | "fixup" => RebaseAction::Fixup,
|
||||
"d" | "drop" => RebaseAction::Drop,
|
||||
_ => return None,
|
||||
};
|
||||
let first = words.next()?;
|
||||
let fixup_message = match (action, first) {
|
||||
(RebaseAction::Fixup, "-C") => Some(RebaseFixupMessage::Replace),
|
||||
(RebaseAction::Fixup, "-c") => Some(RebaseFixupMessage::Edit),
|
||||
_ => None,
|
||||
};
|
||||
let revision = if fixup_message.is_some() { words.next()? } else { first };
|
||||
revision.bytes().all(|b| b.is_ascii_hexdigit()).then_some(CommitCommand { action, revision, fixup_message })
|
||||
}
|
||||
|
||||
fn approved_rewords(r: &Repo, text: &str, proposed: &BTreeMap<String, String>) -> BTreeMap<String, String> {
|
||||
let mut approved = BTreeMap::new();
|
||||
if proposed.is_empty() {
|
||||
return approved;
|
||||
}
|
||||
let Ok(repo) = r.gix() else { return approved };
|
||||
let mut seen = HashSet::new();
|
||||
for CommitCommand { action, revision, .. } in text.lines().filter_map(commit_command) {
|
||||
let Ok(id) = resolve(&repo, revision) else { continue };
|
||||
let key = id.to_string();
|
||||
let Some(message) = proposed.get(&key).filter(|message| !message.trim().is_empty()) else { continue };
|
||||
if !seen.insert(id) {
|
||||
approved.remove(&key);
|
||||
} else if action == RebaseAction::Reword {
|
||||
approved.insert(key, message.clone());
|
||||
}
|
||||
}
|
||||
approved
|
||||
}
|
||||
|
||||
fn reword_for_git_step(r: &Repo, drafts: &BTreeMap<String, String>) -> Option<String> {
|
||||
if drafts.is_empty() {
|
||||
return None;
|
||||
}
|
||||
// Git records the original object here even when HEAD already names the rewritten commit.
|
||||
let done = fs::read_to_string(r.git_dir.join("rebase-merge/done")).ok()?;
|
||||
let CommitCommand { action, revision, .. } =
|
||||
commit_command(done.lines().rev().find(|line| !line.trim().is_empty())?)?;
|
||||
if action != RebaseAction::Reword {
|
||||
return None;
|
||||
}
|
||||
drafts.get(revision).cloned().or_else(|| {
|
||||
let id = resolve(&r.gix().ok()?, revision).ok()?;
|
||||
drafts.get(&id.to_string()).cloned()
|
||||
})
|
||||
}
|
||||
|
||||
fn simple_plan(r: &Repo, text: &str, comment: &str, cancel: &CancellationToken) -> Option<Vec<RebaseTodoRow>> {
|
||||
let repo = r.gix().ok()?;
|
||||
let mut todo = Vec::new();
|
||||
let mut seen = HashSet::new();
|
||||
let mut seen_refs = HashSet::new();
|
||||
for (line, source) in text.lines().enumerate() {
|
||||
let source = todo_line(source);
|
||||
if source.is_empty() || source.starts_with(comment) {
|
||||
continue;
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
return None;
|
||||
}
|
||||
let mut words = source.split_ascii_whitespace();
|
||||
if matches!(words.next(), Some("update-ref" | "u")) {
|
||||
let reference = words.next().filter(|reference| reference.starts_with("refs/"))?;
|
||||
if words.next().is_some() || !seen_refs.insert(reference) {
|
||||
return None;
|
||||
}
|
||||
todo.push(RebaseTodoRow::UpdateRef { line, reference: reference.to_owned() });
|
||||
continue;
|
||||
}
|
||||
let CommitCommand { action, revision, fixup_message } = commit_command(source)?;
|
||||
let id = resolve(&repo, revision).ok()?;
|
||||
if !seen.insert(id) {
|
||||
return None;
|
||||
}
|
||||
let commit = repo.find_commit(id).ok()?;
|
||||
let raw = commit.message_raw_sloppy();
|
||||
let author = commit.author().ok()?.name.trim().to_str_lossy().into_owned();
|
||||
todo.push(RebaseTodoRow::Commit {
|
||||
line,
|
||||
action,
|
||||
fixup_message,
|
||||
id: id.to_string(),
|
||||
revision: revision.to_owned(),
|
||||
author,
|
||||
summary: subject(raw),
|
||||
message: raw.to_str_lossy().trim_end().to_owned(),
|
||||
});
|
||||
}
|
||||
(!todo.is_empty()).then_some(todo)
|
||||
}
|
||||
+20
-90
@@ -1,10 +1,8 @@
|
||||
//! HEAD, branches, upstream tracking and stashes via gitoxide.
|
||||
|
||||
use crate::repo::{gx, to_string};
|
||||
use crate::{Branch, BranchInfo, HistoryTip, RebaseState, Repo, Stash, TrackedTip, UpstreamTracking};
|
||||
use gix::bstr::ByteSlice;
|
||||
use crate::{Branch, BranchInfo, Repo, Stash};
|
||||
use ide_core::IdeResult;
|
||||
use std::io::{BufRead, BufReader};
|
||||
|
||||
// Filter symbolic refs before shortening; `refname:short` also strips remote `/HEAD` suffixes.
|
||||
pub(crate) const DIRECT_BRANCH_FORMAT: &str = "--format=%(if)%(symref)%(then)%(else)%(refname:lstrip=2)%(end)";
|
||||
@@ -14,54 +12,27 @@ pub(crate) fn branch_info(r: &Repo) -> IdeResult<BranchInfo> {
|
||||
let head_ref = repo.head_name().map_err(gx)?;
|
||||
let head = head_ref.as_ref().map(|n| to_string(n.as_ref().shorten()));
|
||||
let head_commit = repo.head_id().ok().map(|id| id.detach());
|
||||
let upstream_tracking = head_ref.as_ref().and_then(|name| configured_upstream(&repo, name.as_ref()));
|
||||
let mut info = BranchInfo {
|
||||
head,
|
||||
head_commit: head_commit.map(|id| id.to_string()),
|
||||
upstream: None,
|
||||
upstream_tracking,
|
||||
tracked_tip: None,
|
||||
ahead: 0,
|
||||
behind: 0,
|
||||
outgoing: None,
|
||||
operation: operation(&repo),
|
||||
rebase: None,
|
||||
};
|
||||
if info.operation.as_deref() == Some("rebase") {
|
||||
info.rebase = rebase_state(repo.path());
|
||||
}
|
||||
let mut counted_upstream = None;
|
||||
if let Some(name) = head_ref.as_ref()
|
||||
&& let Some((upstream_name, upstream_id)) = upstream_of(&repo, name.as_ref())
|
||||
{
|
||||
info.upstream = Some(upstream_name);
|
||||
info.tracked_tip =
|
||||
info.upstream_tracking.clone().map(|tracking| TrackedTip { tracking, commit: upstream_id.to_string() });
|
||||
if let Some(local) = head_commit {
|
||||
let (a, b) = ahead_behind(&repo, local, upstream_id)?;
|
||||
info.ahead = a;
|
||||
info.behind = b;
|
||||
counted_upstream = Some((upstream_id, a));
|
||||
}
|
||||
}
|
||||
if let (Some(name), Some(local)) = (head_ref.as_ref(), head_commit) {
|
||||
info.outgoing =
|
||||
crate::push_preview::outgoing_commits(&repo, &repo.remote_names(), name.as_ref(), local, counted_upstream);
|
||||
}
|
||||
Ok(info)
|
||||
}
|
||||
|
||||
pub(crate) fn rebase_dir(git_dir: &std::path::Path) -> Option<std::path::PathBuf> {
|
||||
["rebase-merge", "rebase-apply"].into_iter().map(|dir| git_dir.join(dir)).find(|dir| dir.is_dir())
|
||||
}
|
||||
|
||||
fn rebase_state(git_dir: &std::path::Path) -> Option<RebaseState> {
|
||||
let dir = rebase_dir(git_dir)?;
|
||||
let read = |name| std::fs::read_to_string(dir.join(name)).ok().map(|value| value.trim().to_owned());
|
||||
let branch = read("head-name")?.strip_prefix("refs/heads/").map(str::to_owned);
|
||||
Some(RebaseState { original: HistoryTip { branch, commit: read("orig-head")? }, onto: read("onto")? })
|
||||
}
|
||||
|
||||
pub(crate) fn head(repo: &gix::Repository) -> IdeResult<(Option<String>, Option<String>)> {
|
||||
let name = repo.head_name().map_err(gx)?.map(|n| to_string(n.as_ref().shorten()));
|
||||
Ok((name, repo.head_id().ok().map(|id| id.to_string())))
|
||||
@@ -69,48 +40,25 @@ pub(crate) fn head(repo: &gix::Repository) -> IdeResult<(Option<String>, Option<
|
||||
|
||||
pub(crate) fn operation(repo: &gix::Repository) -> Option<String> {
|
||||
use gix::state::InProgress::*;
|
||||
let op = match repo.state() {
|
||||
Some(ApplyMailbox | ApplyMailboxRebase) => "am",
|
||||
Some(Bisect) => "bisect",
|
||||
Some(CherryPick | CherryPickSequence) => "cherry-pick",
|
||||
Some(Merge) => "merge",
|
||||
Some(Rebase | RebaseInteractive) => "rebase",
|
||||
Some(Revert | RevertSequence) => "revert",
|
||||
None => {
|
||||
// Committing a resolved step can clear its HEAD marker while Git still has a todo.
|
||||
let path = repo.path().join("sequencer/todo");
|
||||
if !path.is_file() {
|
||||
return None;
|
||||
}
|
||||
let mut first = String::new();
|
||||
BufReader::new(std::fs::File::open(path).ok()?).read_line(&mut first).ok()?;
|
||||
match first.split_whitespace().next()? {
|
||||
"pick" => "cherry-pick",
|
||||
"revert" => "revert",
|
||||
_ => return None,
|
||||
}
|
||||
}
|
||||
let op = match repo.state()? {
|
||||
ApplyMailbox | ApplyMailboxRebase => "am",
|
||||
Bisect => "bisect",
|
||||
CherryPick | CherryPickSequence => "cherry-pick",
|
||||
Merge => "merge",
|
||||
Rebase | RebaseInteractive => "rebase",
|
||||
Revert | RevertSequence => "revert",
|
||||
};
|
||||
Some(op.to_string())
|
||||
}
|
||||
|
||||
/// Short upstream name (`origin/main`) and its commit. A branch whose tracking ref is gone (the
|
||||
/// remote branch was deleted and pruned) tracks nothing, as in IDEA.
|
||||
pub(crate) fn upstream_of(repo: &gix::Repository, branch: &gix::refs::FullNameRef) -> Option<(String, gix::ObjectId)> {
|
||||
fn upstream_of(repo: &gix::Repository, branch: &gix::refs::FullNameRef) -> Option<(String, gix::ObjectId)> {
|
||||
let tracking = repo.branch_remote_tracking_ref_name(branch, gix::remote::Direction::Fetch)?.ok()?;
|
||||
let id = repo.try_find_reference(tracking.as_ref()).ok()??.peel_to_id().ok()?.detach();
|
||||
Some((to_string(tracking.as_ref().shorten()), id))
|
||||
}
|
||||
|
||||
pub(crate) fn configured_upstream(repo: &gix::Repository, name: &gix::refs::FullNameRef) -> Option<UpstreamTracking> {
|
||||
let direction = gix::remote::Direction::Fetch;
|
||||
let remote = repo.branch_remote_name(name.shorten(), direction)?;
|
||||
let branch = repo.branch_remote_ref_name(name, direction)?.ok()?;
|
||||
let branch = branch.as_bstr().strip_prefix(b"refs/heads/")?.as_bstr();
|
||||
(remote.as_bstr() != ".")
|
||||
.then(|| UpstreamTracking { remote: to_string(remote.as_bstr()), branch: to_string(branch) })
|
||||
}
|
||||
|
||||
/// Commits in `local` not in `upstream`, and vice versa.
|
||||
pub(crate) fn ahead_behind(
|
||||
repo: &gix::Repository,
|
||||
@@ -120,17 +68,16 @@ pub(crate) fn ahead_behind(
|
||||
if local == upstream {
|
||||
return Ok((0, 0));
|
||||
}
|
||||
Ok((count_commits(repo, local, upstream)?, count_commits(repo, upstream, local)?))
|
||||
}
|
||||
|
||||
pub(crate) fn count_commits(repo: &gix::Repository, tip: gix::ObjectId, hide: gix::ObjectId) -> IdeResult<u32> {
|
||||
let walk = repo.rev_walk([tip]).with_hidden([hide]).all().map_err(gx)?;
|
||||
let mut n = 0u32;
|
||||
for info in walk {
|
||||
info.map_err(gx)?;
|
||||
n += 1;
|
||||
}
|
||||
Ok(n)
|
||||
let count = |tip: gix::ObjectId, hide: gix::ObjectId| -> IdeResult<u32> {
|
||||
let walk = repo.rev_walk([tip]).with_hidden([hide]).all().map_err(gx)?;
|
||||
let mut n = 0u32;
|
||||
for info in walk {
|
||||
info.map_err(gx)?;
|
||||
n += 1;
|
||||
}
|
||||
Ok(n)
|
||||
};
|
||||
Ok((count(local, upstream)?, count(upstream, local)?))
|
||||
}
|
||||
|
||||
fn commit_time_ms(repo: &gix::Repository, id: gix::ObjectId) -> f64 {
|
||||
@@ -141,7 +88,6 @@ pub(crate) fn branches(r: &Repo) -> IdeResult<Vec<Branch>> {
|
||||
let repo = r.gix()?;
|
||||
let head_name = repo.head_name().map_err(gx)?;
|
||||
let platform = repo.references().map_err(gx)?;
|
||||
let remotes = repo.remote_names();
|
||||
let mut out = Vec::new();
|
||||
|
||||
for reference in platform.local_branches().map_err(gx)? {
|
||||
@@ -157,24 +103,17 @@ pub(crate) fn branches(r: &Repo) -> IdeResult<Vec<Branch>> {
|
||||
remote: false,
|
||||
current,
|
||||
upstream: None,
|
||||
tracked_tip: None,
|
||||
ahead: 0,
|
||||
behind: 0,
|
||||
outgoing: None,
|
||||
last_commit_ms: commit_time_ms(&repo, id),
|
||||
commit: id.to_string(),
|
||||
};
|
||||
let mut counted_upstream = None;
|
||||
if let Some((up, up_id)) = upstream_of(&repo, full.as_ref()) {
|
||||
branch.upstream = Some(up);
|
||||
branch.tracked_tip = configured_upstream(&repo, full.as_ref())
|
||||
.map(|tracking| TrackedTip { tracking, commit: up_id.to_string() });
|
||||
let (a, b) = ahead_behind(&repo, id, up_id)?;
|
||||
branch.ahead = a;
|
||||
branch.behind = b;
|
||||
counted_upstream = Some((up_id, a));
|
||||
}
|
||||
branch.outgoing = crate::push_preview::outgoing_commits(&repo, &remotes, full.as_ref(), id, counted_upstream);
|
||||
out.push(branch);
|
||||
}
|
||||
for reference in platform.remote_branches().map_err(gx)? {
|
||||
@@ -190,10 +129,8 @@ pub(crate) fn branches(r: &Repo) -> IdeResult<Vec<Branch>> {
|
||||
remote: true,
|
||||
current: false,
|
||||
upstream: None,
|
||||
tracked_tip: None,
|
||||
ahead: 0,
|
||||
behind: 0,
|
||||
outgoing: None,
|
||||
last_commit_ms: commit_time_ms(&repo, id),
|
||||
commit: id.to_string(),
|
||||
});
|
||||
@@ -222,20 +159,13 @@ pub(crate) fn stashes(r: &Repo) -> IdeResult<Vec<Stash>> {
|
||||
let line = line.map_err(gx)?;
|
||||
let time_ms = line.signature.time.seconds as f64 * 1000.0;
|
||||
let id = line.new_oid.to_owned();
|
||||
let (base, untracked) = repo
|
||||
.find_commit(id)
|
||||
.map(|commit| {
|
||||
let mut parents = commit.parent_ids();
|
||||
(parents.next().map(|p| p.to_string()), parents.nth(1).map(|p| p.to_string()))
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let base = repo.find_commit(id).ok().and_then(|c| c.parent_ids().next().map(|p| p.to_string()));
|
||||
out.push(Stash {
|
||||
index: index as u32,
|
||||
message: to_string(line.message.as_ref()),
|
||||
time_ms,
|
||||
id: id.to_string(),
|
||||
base,
|
||||
untracked,
|
||||
});
|
||||
}
|
||||
Ok(out)
|
||||
|
||||
+10
-226
@@ -3,13 +3,9 @@
|
||||
|
||||
use crate::cli;
|
||||
use crate::{ChangedFile, Repo};
|
||||
use gix::bstr::ByteSlice;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::workflow_settings::FetchTagsMode;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashSet;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -22,27 +18,6 @@ pub struct Remote {
|
||||
pub resolved_url: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
pub struct FetchReport {
|
||||
pub remotes: Vec<FetchRemoteResult>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
pub struct FetchRemoteResult {
|
||||
pub remote: String,
|
||||
pub pruned: Vec<String>,
|
||||
pub error: Option<IdeError>,
|
||||
}
|
||||
|
||||
fn pruned_ref(line: &str) -> Option<&str> {
|
||||
// Git emits human-readable status in the C locale, including when submodule fetch is enabled.
|
||||
let deleted = line.trim_ascii_start().strip_prefix('-')?.trim_ascii_start().strip_prefix("[deleted]")?;
|
||||
let (from, to) = deleted.split_once("->")?;
|
||||
let to = to.trim_ascii();
|
||||
(from.trim_ascii() == "(none)" && !to.is_empty() && !to.bytes().any(|byte| byte.is_ascii_whitespace()))
|
||||
.then_some(to)
|
||||
}
|
||||
|
||||
fn check_rev(rev: &str) -> IdeResult<()> {
|
||||
if rev.trim().is_empty() || rev.starts_with('-') {
|
||||
Err(IdeError::invalid(format!("invalid revision `{rev}`")))
|
||||
@@ -55,9 +30,9 @@ fn check_rev(rev: &str) -> IdeResult<()> {
|
||||
pub(crate) fn parse_remotes(text: &str) -> Vec<Remote> {
|
||||
let mut out: Vec<Remote> = Vec::new();
|
||||
for line in text.lines() {
|
||||
let Some((name, url)) = line.split_once('\t') else { continue };
|
||||
let Some(url) = url.strip_suffix(" (fetch)") else { continue };
|
||||
if out.iter().any(|r| r.name == name) {
|
||||
let mut parts = line.split_whitespace();
|
||||
let (Some(name), Some(url), kind) = (parts.next(), parts.next(), parts.next()) else { continue };
|
||||
if kind.is_some_and(|k| k != "(fetch)") || out.iter().any(|r| r.name == name) {
|
||||
continue;
|
||||
}
|
||||
out.push(Remote { name: name.to_owned(), url: url.to_owned(), resolved_url: None });
|
||||
@@ -65,208 +40,17 @@ pub(crate) fn parse_remotes(text: &str) -> Vec<Remote> {
|
||||
out
|
||||
}
|
||||
|
||||
pub(crate) fn fetch_tag_args(mode: FetchTagsMode, prune: bool) -> Vec<&'static str> {
|
||||
let mut args = Vec::new();
|
||||
if prune || mode == FetchTagsMode::Sync {
|
||||
args.push("--prune");
|
||||
}
|
||||
args.extend(match mode {
|
||||
FetchTagsMode::Auto => &[][..],
|
||||
FetchTagsMode::Sync => &["--prune-tags"][..],
|
||||
FetchTagsMode::Always => &["--tags", "--no-prune-tags"][..],
|
||||
FetchTagsMode::Never => &["--no-tags", "--no-prune-tags"][..],
|
||||
});
|
||||
args
|
||||
}
|
||||
|
||||
/// Pull forwards --tags and --prune, but reads tag pruning from Git configuration.
|
||||
pub(crate) fn pull_tag_config(r: &Repo, mode: FetchTagsMode) -> IdeResult<Vec<String>> {
|
||||
let prune = match mode {
|
||||
FetchTagsMode::Auto => return Ok(Vec::new()),
|
||||
FetchTagsMode::Sync => "true",
|
||||
FetchTagsMode::Always | FetchTagsMode::Never => "false",
|
||||
};
|
||||
let mut config = vec![format!("fetch.pruneTags={prune}")];
|
||||
let repo = r.gix()?;
|
||||
if let Some(remote) = repo.head_name().map_err(crate::repo::gx)?.and_then(|head| {
|
||||
let branch = head.as_ref().shorten().to_str_lossy();
|
||||
repo.branch_remote_name(branch.as_ref(), gix::remote::Direction::Fetch)
|
||||
}) {
|
||||
config.push(format!("remote.{}.pruneTags={prune}", remote.as_bstr().to_str_lossy()));
|
||||
}
|
||||
Ok(config)
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
/// Whether any remotes are configured, even before their branches have been fetched.
|
||||
pub fn has_remotes(&self) -> IdeResult<bool> {
|
||||
Ok(!self.gix()?.remote_names().is_empty())
|
||||
}
|
||||
|
||||
/// Configured remotes with their fetch URLs.
|
||||
pub fn remotes(&self) -> IdeResult<Vec<Remote>> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let out = cli::run(self.root(), &["remote", "-v"], None)?;
|
||||
Ok(parse_remotes(&out.stdout_str()))
|
||||
}
|
||||
|
||||
/// Refreshes only the selected remote's tracking branches.
|
||||
pub fn fetch_remote(&self, remote: &str, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {
|
||||
self.fetch_with_tags(Some(remote), FetchTagsMode::Auto, cancel, on_output)
|
||||
}
|
||||
|
||||
/// Fetches the named remote, or all remotes, using the project's tag policy.
|
||||
pub fn fetch_with_tags(
|
||||
&self,
|
||||
remote: Option<&str>,
|
||||
mode: FetchTagsMode,
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let mut args = vec!["fetch", "--progress"];
|
||||
args.extend(fetch_tag_args(mode, true));
|
||||
if let Some(remote) = remote {
|
||||
if !self.gix()?.remote_names().iter().any(|name| name.as_bstr() == remote) {
|
||||
return Err(IdeError::invalid("Unknown remote"));
|
||||
}
|
||||
args.extend(["--", remote]);
|
||||
} else {
|
||||
args.push("--all");
|
||||
}
|
||||
cli::run_streaming(self.root(), &args, cancel, on_output)
|
||||
}
|
||||
|
||||
/// Interactive fetch. Each remote is attempted even if another fails, so the caller can
|
||||
/// report both the actual deletions and the failures for this repository.
|
||||
pub fn fetch_report(
|
||||
&self,
|
||||
remote: Option<&str>,
|
||||
mode: FetchTagsMode,
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<FetchReport> {
|
||||
self.fetch_remotes_report(remote, mode, None, cancel, on_output)
|
||||
}
|
||||
|
||||
/// Fetches the project's remotes without asking for new credentials.
|
||||
pub fn fetch_in_background(
|
||||
&self,
|
||||
skip: &[String],
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<FetchReport> {
|
||||
self.fetch_remotes_report(None, FetchTagsMode::Auto, Some(skip), cancel, on_output)
|
||||
}
|
||||
|
||||
fn fetch_remotes_report(
|
||||
&self,
|
||||
remote: Option<&str>,
|
||||
mode: FetchTagsMode,
|
||||
background_skip: Option<&[String]>,
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<FetchReport> {
|
||||
let _scope = self.execution_scope();
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let mut remotes = if let Some(remote) = remote {
|
||||
if !self.gix()?.remote_names().iter().any(|name| name.as_bstr() == remote) {
|
||||
return Err(IdeError::invalid("Unknown remote"));
|
||||
}
|
||||
vec![remote.to_owned()]
|
||||
} else {
|
||||
self.fetch_all_remotes()?
|
||||
};
|
||||
if let Some(skip) = background_skip {
|
||||
remotes.retain(|name| !skip.contains(name));
|
||||
}
|
||||
|
||||
let mut results = Vec::with_capacity(remotes.len());
|
||||
let mut base_args = vec!["fetch", "--progress"];
|
||||
base_args.extend(fetch_tag_args(mode, true));
|
||||
for (i, remote) in remotes.iter().enumerate() {
|
||||
let mut args = base_args.clone();
|
||||
if i > 0 {
|
||||
args.push("--append");
|
||||
}
|
||||
if remotes.len() > 1 {
|
||||
on_output(format!("Fetching {remote}"));
|
||||
}
|
||||
args.extend(["--", remote]);
|
||||
let mut pruned = Vec::new();
|
||||
let mut capture = |line: &str| {
|
||||
if let Some(reference) = pruned_ref(line) {
|
||||
pruned.push(reference.to_owned());
|
||||
}
|
||||
};
|
||||
let result = cli::run_streaming_stderr(
|
||||
self.root(),
|
||||
&args,
|
||||
cancel,
|
||||
on_output,
|
||||
&mut capture,
|
||||
background_skip.is_some(),
|
||||
);
|
||||
let error = result.err();
|
||||
if error.as_ref().is_some_and(|error| error.kind == ErrorKind::Cancelled) {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if error.is_some() && !pruned.is_empty() {
|
||||
// Git can print a deletion before discovering that the ref could not be removed.
|
||||
let repo = self.gix();
|
||||
pruned.retain(|name| {
|
||||
repo.as_ref().is_ok_and(|repo| repo.try_find_reference(name.as_str()).is_ok_and(|r| r.is_none()))
|
||||
});
|
||||
}
|
||||
results.push(FetchRemoteResult { remote: remote.clone(), pruned, error });
|
||||
}
|
||||
Ok(FetchReport { remotes: results })
|
||||
}
|
||||
|
||||
fn fetch_all_remotes(&self) -> IdeResult<Vec<String>> {
|
||||
// Keep Git's configuration order since multiple remotes can update the same tags.
|
||||
let args = ["config", "--null", "--get-regexp", r"^remote\..+\.[^.]+$"];
|
||||
let output = cli::run_raw(self.root(), &args, None)?;
|
||||
if output.code != Some(0) && !(output.code == Some(1) && output.stderr.is_empty()) {
|
||||
return Err(cli::failure(&args, &output.stderr, b"", output.code));
|
||||
}
|
||||
let config = output.stdout_str();
|
||||
let mut remotes = Vec::new();
|
||||
let mut seen = HashSet::new();
|
||||
let mut skipped = HashSet::new();
|
||||
for item in config.split('\0') {
|
||||
let (key, value) = item.split_once('\n').map_or((item, None), |(key, value)| (key, Some(value)));
|
||||
let Some((name, setting)) = key.strip_prefix("remote.").and_then(|key| key.rsplit_once('.')) else {
|
||||
continue;
|
||||
};
|
||||
if name.starts_with('/') {
|
||||
continue;
|
||||
}
|
||||
if seen.insert(name) {
|
||||
remotes.push(name);
|
||||
}
|
||||
if !matches!(setting, "skipfetchall" | "skipdefaultupdate") {
|
||||
continue;
|
||||
}
|
||||
let skip = value
|
||||
.map(gix::config::Boolean::try_from)
|
||||
.transpose()
|
||||
.map_err(|error| IdeError::invalid(format!("{key}: {error}")))?
|
||||
.is_none_or(gix::config::Boolean::is_true);
|
||||
if skip {
|
||||
skipped.insert(name);
|
||||
} else {
|
||||
skipped.remove(name);
|
||||
}
|
||||
}
|
||||
Ok(remotes.into_iter().filter(|name| !skipped.contains(name)).map(str::to_owned).collect())
|
||||
}
|
||||
|
||||
/// Whether `rev` names a commit present in the object database.
|
||||
pub fn has_commit(&self, rev: &str) -> bool {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
check_rev(rev).is_ok()
|
||||
&& cli::run_raw(self.root(), &["cat-file", "-e", &format!("{rev}^{{commit}}")], None)
|
||||
.is_ok_and(|o| o.code == Some(0))
|
||||
@@ -281,7 +65,7 @@ impl Repo {
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
check_rev(remote)?;
|
||||
for r in refspecs {
|
||||
check_rev(r)?;
|
||||
@@ -293,7 +77,7 @@ impl Repo {
|
||||
|
||||
/// The best common ancestor of two revisions, if any.
|
||||
pub fn merge_base(&self, a: &str, b: &str) -> IdeResult<Option<String>> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
check_rev(a)?;
|
||||
check_rev(b)?;
|
||||
let out = cli::run_raw(self.root(), &["merge-base", a, b], None)?;
|
||||
@@ -302,7 +86,7 @@ impl Repo {
|
||||
|
||||
/// Files changed between two revisions (renames detected).
|
||||
pub fn diff_files(&self, from: &str, to: &str) -> IdeResult<Vec<ChangedFile>> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
check_rev(from)?;
|
||||
check_rev(to)?;
|
||||
let out = cli::run(
|
||||
@@ -321,12 +105,12 @@ mod tests {
|
||||
#[test]
|
||||
fn remotes_take_fetch_urls_once() {
|
||||
let text = "origin\t[email protected]:me/app.git (fetch)\norigin\t[email protected]:me/app.git (push)\n\
|
||||
upstream/test\tC:/Git Remote/app.git (fetch)\nupstream/test\tno_push (push)\n";
|
||||
upstream\thttps://github.com/org/app (fetch)\nupstream\tno_push (push)\n";
|
||||
assert_eq!(
|
||||
parse_remotes(text),
|
||||
[
|
||||
Remote { name: "origin".into(), url: "[email protected]:me/app.git".into(), resolved_url: None },
|
||||
Remote { name: "upstream/test".into(), url: "C:/Git Remote/app.git".into(), resolved_url: None },
|
||||
Remote { name: "upstream".into(), url: "https://github.com/org/app".into(), resolved_url: None },
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
@@ -6,14 +6,6 @@ use ide_core::{IdeError, IdeResult};
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
use std::time::SystemTime;
|
||||
|
||||
#[derive(serde::Serialize, serde::Deserialize, specta::Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DiffEntry {
|
||||
pub mode: String,
|
||||
/// The recorded commit for a gitlink, independent of the parent's object database.
|
||||
pub gitlink: Option<String>,
|
||||
}
|
||||
|
||||
/// Converts any displayable gitoxide error into an [`IdeError`].
|
||||
pub(crate) fn gx(e: impl std::fmt::Display) -> IdeError {
|
||||
IdeError::internal(format!("git: {e}"))
|
||||
@@ -80,18 +72,13 @@ pub(crate) fn discover(path: &Path) -> IdeResult<Option<Repo>> {
|
||||
let cache = Cache { stamp: stamp(&files), files, repo: ts, pack_stamp: pack_stamp(&pack_dir), pack_dir };
|
||||
Ok(Some(Repo {
|
||||
execution_allowed: std::sync::atomic::AtomicBool::new(false),
|
||||
git_executable: std::sync::RwLock::new(crate::opening_git_executable()),
|
||||
root,
|
||||
git_dir,
|
||||
inner: std::sync::Mutex::new(cache),
|
||||
ignored: Default::default(),
|
||||
cli_status: Default::default(),
|
||||
automatic_shelf: Default::default(),
|
||||
log_index: Default::default(),
|
||||
log_signatures: Default::default(),
|
||||
conflict_mutation: Default::default(),
|
||||
amend_recovery: Default::default(),
|
||||
incoming_observations: Default::default(),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -115,7 +102,7 @@ impl Repo {
|
||||
/// A thread-local gitoxide handle; reopened when configuration or packed refs change.
|
||||
/// gitoxide's packed-ref snapshot only reloads for a newer mtime, which a replacement may preserve.
|
||||
pub(crate) fn gix(&self) -> IdeResult<gix::Repository> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
if !self.execution_allowed.load(std::sync::atomic::Ordering::Acquire) {
|
||||
return gix::open_opts(&self.git_dir, gix::open::Options::default().filter_config_section(|_| false))
|
||||
.map_err(gx);
|
||||
@@ -141,7 +128,7 @@ impl Repo {
|
||||
/// Repository-relative path with `/` separators. Accepts absolute paths inside the
|
||||
/// worktree or paths already relative to it.
|
||||
pub(crate) fn rel_path(&self, path: &Path) -> IdeResult<String> {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
Ok(self.index_spelling(self.given_rel_path(path)?))
|
||||
}
|
||||
|
||||
@@ -161,41 +148,6 @@ impl Repo {
|
||||
blob_at(&repo, &indexed, rev)
|
||||
}
|
||||
|
||||
pub fn diff_entry_at(&self, path: &Path, rev: &str) -> IdeResult<Option<DiffEntry>> {
|
||||
let _scope = self.execution_scope();
|
||||
let repo = self.gix()?;
|
||||
let given = self.given_rel_path(path)?;
|
||||
let indexed = self.index_spelling(given.clone());
|
||||
if rev == "WT" {
|
||||
if let Some(mode) = worktree_mode(self.root(), &indexed)? {
|
||||
return Ok(Some(DiffEntry { mode, gitlink: None }));
|
||||
}
|
||||
let at_index = entry_at(&repo, &indexed, ":0")?.is_some_and(|(mode, _)| mode.is_commit());
|
||||
let at_head =
|
||||
|| entry_at(&repo, &given, "HEAD").map(|entry| entry.is_some_and(|(mode, _)| mode.is_commit()));
|
||||
if !at_index && !at_head()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let gitlink = self
|
||||
.initialized_submodule(Path::new(&indexed))
|
||||
.and_then(|path| Self::discover(&path).ok().flatten().filter(|child| child.root() == path))
|
||||
.and_then(|child| child.head().ok()?.1);
|
||||
return Ok(Some(DiffEntry { mode: "160000".into(), gitlink }));
|
||||
}
|
||||
let entry = if !rev.starts_with(':') && indexed != given {
|
||||
match entry_at(&repo, &given, rev)? {
|
||||
Some(entry) => Some(entry),
|
||||
None => entry_at(&repo, &indexed, rev)?,
|
||||
}
|
||||
} else {
|
||||
entry_at(&repo, &indexed, rev)?
|
||||
};
|
||||
Ok(entry.map(|(mode, id)| DiffEntry {
|
||||
mode: format!("{:o}", mode.value()),
|
||||
gitlink: mode.is_commit().then(|| id.to_string()),
|
||||
}))
|
||||
}
|
||||
|
||||
/// `path` relative to the worktree, spelled as given.
|
||||
pub(crate) fn given_rel_path(&self, path: &Path) -> IdeResult<String> {
|
||||
let rel = if path.is_absolute() {
|
||||
@@ -265,7 +217,7 @@ impl Repo {
|
||||
|
||||
/// Absolute path for a repository-relative path.
|
||||
pub(crate) fn abs_path(&self, rel: &str) -> PathBuf {
|
||||
let _scope = self.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let mut p = self.root.clone();
|
||||
for part in rel.split('/').filter(|s| !s.is_empty()) {
|
||||
p.push(part);
|
||||
@@ -330,14 +282,6 @@ pub(crate) fn worktree_mode(root: &Path, rel: &str) -> IdeResult<Option<String>>
|
||||
/// The entry's mode of `rel` at `rev` as git prints it (`100644`, `100755`, `120000`,
|
||||
/// `160000`…), `None` when the path is absent there. Same `rev` rules as [`blob_at`].
|
||||
pub(crate) fn mode_at(repo: &gix::Repository, rel: &str, rev: &str) -> IdeResult<Option<String>> {
|
||||
Ok(entry_at(repo, rel, rev)?.map(|(mode, _)| format!("{:o}", mode.value())))
|
||||
}
|
||||
|
||||
fn entry_at(
|
||||
repo: &gix::Repository,
|
||||
rel: &str,
|
||||
rev: &str,
|
||||
) -> IdeResult<Option<(gix::objs::tree::EntryMode, gix::ObjectId)>> {
|
||||
if let Some(stage) = rev.strip_prefix(':') {
|
||||
let stage = match stage {
|
||||
"" | "0" => gix::index::entry::Stage::Unconflicted,
|
||||
@@ -350,16 +294,16 @@ fn entry_at(
|
||||
let Some(entry) = index.entry_by_path_and_stage(BStr::new(rel.as_bytes()), stage) else {
|
||||
return Ok(None);
|
||||
};
|
||||
return Ok(entry.mode.to_tree_entry_mode().map(|mode| (mode, entry.id)));
|
||||
return Ok(entry.mode.to_tree_entry_mode().map(|m| format!("{:o}", m.value())));
|
||||
}
|
||||
let Some(tree) = tree_of(repo, rev)? else { return Ok(None) };
|
||||
let Some(entry) = tree.lookup_entry_by_path(Path::new(rel)).map_err(gx)? else {
|
||||
return Ok(None);
|
||||
};
|
||||
if !entry.mode().is_blob_or_symlink() && !entry.mode().is_commit() {
|
||||
if !entry.mode().is_blob_or_symlink() {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some((entry.mode(), entry.oid().to_owned())))
|
||||
Ok(Some(format!("{:o}", entry.mode().value())))
|
||||
}
|
||||
|
||||
/// Blob content of `rel` at `rev`. `rev` is a revision (`HEAD`, a branch, an id) or
|
||||
@@ -398,7 +342,7 @@ pub(crate) fn blob_at(repo: &gix::Repository, rel: &str, rev: &str) -> IdeResult
|
||||
/// A blob's bytes. Partial clones (`--filter=blob:none`) lack blobs until git
|
||||
/// fetches them on demand, which gix doesn't do, so a missing one is read
|
||||
/// through the git CLI.
|
||||
pub(crate) fn blob_data(repo: &gix::Repository, id: gix::ObjectId) -> IdeResult<Vec<u8>> {
|
||||
fn blob_data(repo: &gix::Repository, id: gix::ObjectId) -> IdeResult<Vec<u8>> {
|
||||
match repo.find_object(id) {
|
||||
Ok(obj) => Ok(obj.detach().data),
|
||||
Err(e) => {
|
||||
|
||||
+14
-145
@@ -2,10 +2,7 @@
|
||||
//! root plus those nested below it (separate clones side by side, submodules).
|
||||
|
||||
use crate::{Backend, FileStatus, Repo};
|
||||
use ide_core::{IdeError, IdeResult, IpcPath};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use ide_core::IdeResult;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -22,14 +19,6 @@ pub struct Repos {
|
||||
primary: Option<usize>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ProjectUpdateTarget {
|
||||
pub root: IpcPath,
|
||||
pub parent: Option<IpcPath>,
|
||||
pub detached_submodule: bool,
|
||||
}
|
||||
|
||||
impl Repos {
|
||||
/// Discovers repositories in independent project folders of a workspace.
|
||||
pub fn discover_roots(roots: &[PathBuf], skip: &dyn Fn(&Path) -> bool) -> IdeResult<Self> {
|
||||
@@ -79,26 +68,6 @@ impl Repos {
|
||||
}
|
||||
}
|
||||
}
|
||||
// Declared submodules remain Git roots under ignored folders or beyond the
|
||||
// filesystem scan's depth. An uninitialized submodule has no Git worktree.
|
||||
let mut next = 0;
|
||||
while next < repos.len() {
|
||||
let parent = &repos[next];
|
||||
let children = parent.initialized_submodules().unwrap_or_else(|error| {
|
||||
tracing::debug!(root = %parent.root().display(), %error, "cannot list Git submodules");
|
||||
Vec::new()
|
||||
});
|
||||
for path in children {
|
||||
if path.starts_with(project_root)
|
||||
&& !repos.iter().any(|r| r.root() == path)
|
||||
&& let Ok(Some(repo)) = Repo::discover(&path)
|
||||
&& repo.root() == path
|
||||
{
|
||||
repos.push(repo);
|
||||
}
|
||||
}
|
||||
next += 1;
|
||||
}
|
||||
Ok(Self::new(repos, project_root))
|
||||
}
|
||||
|
||||
@@ -151,53 +120,6 @@ impl Repos {
|
||||
&self.repos
|
||||
}
|
||||
|
||||
/// Selects the roots that Update Project operates on. Detached children are
|
||||
/// included with their selected superproject and read its updated pointer.
|
||||
pub fn project_update_plan(&self, roots: &[Option<PathBuf>]) -> IdeResult<Vec<ProjectUpdateTarget>> {
|
||||
let selected: BTreeSet<&Path> = if roots.is_empty() {
|
||||
self.repos.iter().map(|repo| repo.root()).collect()
|
||||
} else {
|
||||
roots
|
||||
.iter()
|
||||
.map(|root| {
|
||||
match root {
|
||||
Some(root) => self.at_root(root),
|
||||
None => self.primary(),
|
||||
}
|
||||
.map(|repo| repo.root())
|
||||
.ok_or_else(|| IdeError::unavailable("The selected repository is no longer part of the project"))
|
||||
})
|
||||
.collect::<IdeResult<_>>()?
|
||||
};
|
||||
let mut parents = BTreeMap::new();
|
||||
for parent in &self.repos {
|
||||
for path in parent.initialized_submodules().unwrap_or_default() {
|
||||
parents.insert(path, parent.root());
|
||||
}
|
||||
}
|
||||
let mut included = BTreeSet::new();
|
||||
let mut targets = Vec::new();
|
||||
for repo in &self.repos {
|
||||
let root = repo.root();
|
||||
let parent = parents.get(root).copied();
|
||||
let is_selected = selected.contains(root);
|
||||
if !is_selected && !parent.is_some_and(|p| included.contains(p)) {
|
||||
continue;
|
||||
}
|
||||
let (branch, head) = repo.head()?;
|
||||
let detached_submodule = branch.is_none() && head.is_some() && parent.is_some();
|
||||
if is_selected || detached_submodule {
|
||||
included.insert(root);
|
||||
targets.push(ProjectUpdateTarget {
|
||||
root: root.into(),
|
||||
parent: parent.map(Into::into),
|
||||
detached_submodule,
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(targets)
|
||||
}
|
||||
|
||||
/// The repository of the project root, else the first one.
|
||||
pub fn primary(&self) -> Option<&Arc<Repo>> {
|
||||
self.primary.map(|i| &self.repos[i])
|
||||
@@ -247,32 +169,22 @@ impl Repos {
|
||||
/// The reads go through [`Backend`], the Changes-view surface — repositories of a
|
||||
/// future second backend slot in here once `Repos` learns to hold them.
|
||||
pub fn status(&self) -> IdeResult<Vec<FileStatus>> {
|
||||
self.read_status(self.all_status_groups(), |repo, _| (repo as &dyn Backend).status())
|
||||
}
|
||||
|
||||
/// Ignored entries for the staging tree. Commit and status consumers read the regular status.
|
||||
pub fn ignored_files(&self) -> IdeResult<Vec<FileStatus>> {
|
||||
self.read_status(self.all_status_groups(), |repo, _| repo.ignored_files())
|
||||
}
|
||||
|
||||
fn all_status_groups(&self) -> Vec<(Arc<Repo>, Vec<PathBuf>)> {
|
||||
self.repos.iter().map(|repo| (repo.clone(), Vec::new())).collect()
|
||||
let groups: Vec<(Arc<Repo>, Vec<PathBuf>)> = self.repos.iter().map(|repo| (repo.clone(), Vec::new())).collect();
|
||||
self.read_status(groups, false)
|
||||
}
|
||||
|
||||
/// [`status`](Self::status) for `paths` only: each path goes to its innermost repository,
|
||||
/// so a repository without one is not read at all and a nested repository keeps its own
|
||||
/// files (the enclosing one's "untracked folder" entry for them is dropped).
|
||||
pub fn status_paths(&self, paths: &[PathBuf]) -> IdeResult<Vec<FileStatus>> {
|
||||
self.read_status(self.group(paths), |repo, mine| (repo as &dyn Backend).status_paths(mine))
|
||||
self.read_status(self.group(paths), true)
|
||||
}
|
||||
|
||||
/// A nested repository reports its own files. When a repository cannot be read,
|
||||
/// the operation can still display the other repositories' results.
|
||||
fn read_status(
|
||||
&self,
|
||||
groups: Vec<(Arc<Repo>, Vec<PathBuf>)>,
|
||||
status: impl Fn(&Repo, &[PathBuf]) -> IdeResult<Vec<FileStatus>>,
|
||||
) -> IdeResult<Vec<FileStatus>> {
|
||||
/// Reads one status per repository: the whole working tree, or `scoped` the paths it was
|
||||
/// given. A nested repository reports its own files, so the enclosing one's "untracked
|
||||
/// folder" entry for it is dropped. A repository that cannot be read is left out; fails
|
||||
/// only when all fail.
|
||||
fn read_status(&self, groups: Vec<(Arc<Repo>, Vec<PathBuf>)>, scoped: bool) -> IdeResult<Vec<FileStatus>> {
|
||||
let mut out = Vec::new();
|
||||
let mut first_error = None;
|
||||
let mut read = 0;
|
||||
@@ -283,7 +195,8 @@ impl Repos {
|
||||
.map(|r| r.root())
|
||||
.filter(|r| *r != repo.root() && r.starts_with(repo.root()))
|
||||
.collect();
|
||||
let status = match status(&repo, &mine) {
|
||||
let backend = repo.as_ref() as &dyn Backend;
|
||||
let status = match if scoped { backend.status_paths(&mine) } else { backend.status() } {
|
||||
Ok(status) => {
|
||||
read += 1;
|
||||
status
|
||||
@@ -297,11 +210,10 @@ impl Repos {
|
||||
// A file belongs to its innermost repository: the nested one reports what lies
|
||||
// inside it, including files the enclosing one still tracks there (#4990).
|
||||
out.extend(status.into_iter().filter(|f| {
|
||||
let skipped_root =
|
||||
matches!(f.unstaged, Some(crate::ChangeKind::Untracked | crate::ChangeKind::Ignored))
|
||||
&& nested.iter().any(|n| f.path.0 == *n);
|
||||
let untracked_root =
|
||||
f.unstaged == Some(crate::ChangeKind::Untracked) && nested.iter().any(|n| f.path.0 == *n);
|
||||
let in_nested = nested.iter().any(|n| f.path.0 != *n && f.path.0.starts_with(n));
|
||||
!skipped_root && !in_nested
|
||||
!untracked_root && !in_nested
|
||||
}));
|
||||
}
|
||||
match first_error {
|
||||
@@ -336,49 +248,6 @@ mod tests {
|
||||
assert!(ok, "git init in {}", dir.display());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignored_files_use_git_rules_without_listing_other_repositories_twice() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let nested = root.join("nested");
|
||||
git_init(&root);
|
||||
git_init(&nested);
|
||||
std::fs::write(root.join(".gitignore"), "*.tmp\n!visible.tmp\ncache/\nnested/\n").unwrap();
|
||||
std::fs::write(root.join(".git/info/exclude"), "/private.txt\n").unwrap();
|
||||
std::fs::write(nested.join(".gitignore"), "/nested-private.txt\n").unwrap();
|
||||
std::fs::create_dir(root.join("cache")).unwrap();
|
||||
std::fs::create_dir(root.join("plain-folder")).unwrap();
|
||||
for path in [
|
||||
"space name.tmp",
|
||||
"visible.tmp",
|
||||
"tracked.tmp",
|
||||
"cache/child.txt",
|
||||
"plain-folder/child.tmp",
|
||||
"private.txt",
|
||||
"nested/nested-private.txt",
|
||||
] {
|
||||
std::fs::write(root.join(path), "fixture\n").unwrap();
|
||||
}
|
||||
assert!(
|
||||
Command::new("git").args(["add", "-f", "--", "tracked.tmp"]).current_dir(&root).status().unwrap().success()
|
||||
);
|
||||
let repos = Repos::discover(&root, &|_| false).unwrap();
|
||||
let files = repos.ignored_files().unwrap();
|
||||
assert!(files.iter().all(|file| file.unstaged == Some(crate::ChangeKind::Ignored) && file.staged.is_none()));
|
||||
let listed: BTreeSet<_> = files.iter().map(|file| (file.path.0.clone(), file.rel_path.as_str())).collect();
|
||||
assert_eq!(
|
||||
listed,
|
||||
BTreeSet::from([
|
||||
(root.join("cache"), "cache/"),
|
||||
(root.join("plain-folder/child.tmp"), "plain-folder/child.tmp"),
|
||||
(root.join("private.txt"), "private.txt"),
|
||||
(root.join("space name.tmp"), "space name.tmp"),
|
||||
(nested.join("nested-private.txt"), "nested-private.txt"),
|
||||
])
|
||||
);
|
||||
assert!(repos.status().unwrap().iter().all(|file| file.unstaged != Some(crate::ChangeKind::Ignored)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn directory_mappings_exclude_and_add_repositories() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
+82
-597
@@ -2,117 +2,14 @@
|
||||
//! `.idea/shelf`. Each shelved change list is `<shelf>/<id>/shelved.patch` plus
|
||||
//! `<shelf>/<id>/shelf.json` with its name, date and files.
|
||||
|
||||
use crate::cli::{run, run_env, run_paths};
|
||||
use crate::{ApplyOutcome, ChangeKind, ChangedFile, Repo, ShelvedChangeList, Stash};
|
||||
use crate::cli::{run_env, run_paths};
|
||||
use crate::{ApplyOutcome, ChangeKind, Repo, ShelvedChangeList};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::{BTreeMap, HashMap, HashSet};
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
const PATCH: &str = "shelved.patch";
|
||||
const INFO: &str = "shelf.json";
|
||||
const GROUPED: &str = "repositories";
|
||||
const SNAPSHOT: &str = "snapshot";
|
||||
const SNAPSHOT_PACK: &str = "snapshot.pack";
|
||||
|
||||
/// Correlates a single project-wide Git operation across its individual repository commands.
|
||||
#[derive(Clone)]
|
||||
pub struct ShelfBatch {
|
||||
id: String,
|
||||
base: PathBuf,
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
static SHELF_BATCH: std::cell::RefCell<Option<ShelfBatch>> = const { std::cell::RefCell::new(None) };
|
||||
}
|
||||
|
||||
impl ShelfBatch {
|
||||
pub fn new(id: String, base: PathBuf) -> Self {
|
||||
Self { id, base }
|
||||
}
|
||||
|
||||
pub fn run<T>(self, op: impl FnOnce() -> T) -> T {
|
||||
struct RestoreBatch(Option<ShelfBatch>);
|
||||
impl Drop for RestoreBatch {
|
||||
fn drop(&mut self) {
|
||||
SHELF_BATCH.with(|slot| slot.replace(self.0.take()));
|
||||
}
|
||||
}
|
||||
let _restore = RestoreBatch(SHELF_BATCH.with(|slot| slot.replace(Some(self))));
|
||||
op()
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_active_batch(id: &str) -> bool {
|
||||
SHELF_BATCH.with(|slot| slot.borrow().as_ref().is_some_and(|batch| batch.id == id))
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct AutomaticShelf {
|
||||
pub directory: PathBuf,
|
||||
pub changelist_root: Option<PathBuf>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub(crate) struct SavedShelves {
|
||||
pub directory: PathBuf,
|
||||
pub entries: Vec<String>,
|
||||
pub snapshot: String,
|
||||
archive: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub batch: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "String::is_empty")]
|
||||
pub prefix: String,
|
||||
}
|
||||
|
||||
pub(crate) struct PendingShelf {
|
||||
pub id: String,
|
||||
pub patch: String,
|
||||
pub intact: bool,
|
||||
}
|
||||
|
||||
impl SavedShelves {
|
||||
fn archive_path(&self) -> IdeResult<PathBuf> {
|
||||
if !self.archive.starts_with(".snapshot-") || self.archive.contains(['/', '\\']) {
|
||||
return Err(IdeError::invalid("Invalid automatic Shelf archive"));
|
||||
}
|
||||
Ok(self.directory.join(&self.archive))
|
||||
}
|
||||
|
||||
pub(crate) fn unpack(&self, r: &Repo) -> IdeResult<()> {
|
||||
let pack = std::fs::read(self.archive_path()?)?;
|
||||
run(r.root(), &["unpack-objects", "-q"], Some(&pack))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn pending(&self) -> IdeResult<Vec<PendingShelf>> {
|
||||
let mut pending = Vec::new();
|
||||
for id in &self.entries {
|
||||
if let Some((patch, intact)) = owned_patch(&self.directory, id, &self.archive)? {
|
||||
pending.push(PendingShelf { id: id.clone(), patch, intact });
|
||||
}
|
||||
}
|
||||
Ok(pending)
|
||||
}
|
||||
|
||||
fn clean_entries(&self) {
|
||||
for id in &self.entries {
|
||||
let _ = delete(&self.directory, id);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn discard(&self) {
|
||||
self.clean_entries();
|
||||
self.remove_archive();
|
||||
}
|
||||
|
||||
pub(crate) fn remove_archive(&self) {
|
||||
if let Ok(path) = self.archive_path() {
|
||||
let _ = std::fs::remove_file(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -124,184 +21,6 @@ struct Info {
|
||||
files: Vec<crate::ChangedFile>,
|
||||
#[serde(default)]
|
||||
repo: Option<ide_core::IpcPath>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
repositories: Vec<ShelfRepository>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
group: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct ShelfRepository {
|
||||
root: ide_core::IpcPath,
|
||||
prefix: String,
|
||||
paths: Vec<String>,
|
||||
}
|
||||
|
||||
/// A captured part of a mixed-repository shelf, ready to save before any files are reverted.
|
||||
pub struct ShelfCapture {
|
||||
repo: PathBuf,
|
||||
prefix: String,
|
||||
patch: String,
|
||||
files: Vec<ChangedFile>,
|
||||
}
|
||||
|
||||
impl ShelfCapture {
|
||||
pub fn capture(r: &Repo, base: &Path, paths: &[PathBuf]) -> IdeResult<Self> {
|
||||
let _scope = r.execution_scope();
|
||||
let repo = r.root().to_path_buf();
|
||||
let prefix = repository_prefix(&repo, base)?;
|
||||
let (patch, files) =
|
||||
crate::patch::working_patch_with_prefix(r, &r.rel_paths(paths)?, false, false, Some(&prefix))?;
|
||||
Ok(Self { repo, prefix, patch, files })
|
||||
}
|
||||
|
||||
pub fn repository(&self) -> &Path {
|
||||
&self.repo
|
||||
}
|
||||
|
||||
pub fn revert(&self, r: &Repo) -> IdeResult<()> {
|
||||
let _scope = r.execution_scope();
|
||||
if r.root() != self.repo {
|
||||
return Err(IdeError::invalid("The shelf repository has changed"));
|
||||
}
|
||||
if self.files.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let paths: Vec<_> = self.files.iter().map(|file| file.path.clone()).collect();
|
||||
let (current, _) = crate::patch::working_patch_with_prefix(r, &paths, false, false, Some(&self.prefix))?;
|
||||
if current != self.patch {
|
||||
return Err(IdeError::invalid("Files changed while shelving. The captured changes are on the Shelf."));
|
||||
}
|
||||
revert_files(r, &self.files)
|
||||
}
|
||||
}
|
||||
|
||||
fn repository_prefix(repo: &Path, base: &Path) -> IdeResult<String> {
|
||||
let relative =
|
||||
repo.strip_prefix(base).map_err(|_| IdeError::invalid("The shelf repositories have no common directory"))?;
|
||||
Ok(if relative.as_os_str().is_empty() {
|
||||
String::new()
|
||||
} else {
|
||||
format!("{}/", ide_core::ipc_path::to_ipc(relative))
|
||||
})
|
||||
}
|
||||
|
||||
pub fn save_combined(shelf: &Path, base: &Path, name: &str, captures: &[ShelfCapture]) -> IdeResult<ShelvedChangeList> {
|
||||
let name = name.trim();
|
||||
if name.is_empty() {
|
||||
return Err(IdeError::invalid("name must not be empty"));
|
||||
}
|
||||
let patch: String = captures.iter().map(|capture| capture.patch.as_str()).collect();
|
||||
let files = changed_files(&patch);
|
||||
if files.is_empty() {
|
||||
return Err(IdeError::invalid("no changes to shelve"));
|
||||
}
|
||||
if files.iter().map(|file| &file.path).collect::<HashSet<_>>().len() != files.len() {
|
||||
return Err(IdeError::invalid("A file belongs to more than one repository in this shelf"));
|
||||
}
|
||||
crate::changelists::ensure_ignored(shelf, &["*"])?;
|
||||
let repositories = captures
|
||||
.iter()
|
||||
.filter(|capture| !capture.files.is_empty())
|
||||
.map(|capture| ShelfRepository {
|
||||
root: capture.repo.as_path().into(),
|
||||
prefix: capture.prefix.clone(),
|
||||
paths: capture.files.iter().map(|file| format!("{}{}", capture.prefix, file.path)).collect(),
|
||||
})
|
||||
.collect();
|
||||
let info = Info {
|
||||
name: name.to_owned(),
|
||||
time_ms: now_ms(),
|
||||
branch: None,
|
||||
repo: Some(base.into()),
|
||||
files,
|
||||
repositories,
|
||||
group: None,
|
||||
};
|
||||
write_entry(shelf, info, &patch, None)
|
||||
}
|
||||
|
||||
/// A patch selection with its original repository and the common path prefix to strip when applying it.
|
||||
pub struct ShelfSelection {
|
||||
pub repo: Option<ide_core::IpcPath>,
|
||||
prefix: String,
|
||||
patch: String,
|
||||
}
|
||||
|
||||
impl ShelfSelection {
|
||||
pub fn apply(&self, r: &Repo) -> IdeResult<ApplyOutcome> {
|
||||
let _scope = r.execution_scope();
|
||||
let mut outcome = crate::patch::apply_with_prefix(r, &self.patch, &self.prefix)?;
|
||||
for path in outcome.applied.iter_mut().chain(outcome.conflicts.iter_mut()) {
|
||||
*path = format!("{}{path}", self.prefix);
|
||||
}
|
||||
Ok(outcome)
|
||||
}
|
||||
|
||||
pub fn diff_files(&self, r: &Repo) -> IdeResult<Vec<ShelfDiffFile>> {
|
||||
diff_from_patch(r, &self.patch, &self.prefix)
|
||||
}
|
||||
|
||||
pub fn export(&self, fallback_root: &Path, base: &Path) -> IdeResult<String> {
|
||||
let root = self.repo.as_deref().unwrap_or(fallback_root);
|
||||
crate::patch::rebase_patch(&self.patch, root, &self.prefix, base)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn selections(shelf: &Path, id: &str, path: Option<&str>) -> IdeResult<Vec<ShelfSelection>> {
|
||||
let mut selections = Vec::new();
|
||||
for member in members(shelf, id)? {
|
||||
let dir = entry_dir(shelf, &member)?;
|
||||
let patch = std::fs::read_to_string(dir.join(PATCH))?;
|
||||
let patch = match path {
|
||||
Some(path) => sections_for_path(&patch, path),
|
||||
None => patch,
|
||||
};
|
||||
if !patch.is_empty() {
|
||||
selections.extend(selections_in_entry(&dir, patch)?);
|
||||
}
|
||||
}
|
||||
if selections.is_empty() {
|
||||
return Err(IdeError::not_found("shelved file not found"));
|
||||
}
|
||||
Ok(selections)
|
||||
}
|
||||
|
||||
fn selections_in_entry(dir: &Path, patch: String) -> IdeResult<Vec<ShelfSelection>> {
|
||||
let info = read_info(dir);
|
||||
let Some(info) = info else {
|
||||
if dir.join(GROUPED).is_file() {
|
||||
return Err(IdeError::invalid("shelf metadata is missing"));
|
||||
}
|
||||
return Ok(vec![ShelfSelection { repo: None, prefix: String::new(), patch }]);
|
||||
};
|
||||
if info.repositories.is_empty() {
|
||||
if dir.join(GROUPED).is_file() {
|
||||
return Err(IdeError::invalid("shelf metadata is missing"));
|
||||
}
|
||||
return Ok(vec![ShelfSelection { repo: info.repo, prefix: String::new(), patch }]);
|
||||
}
|
||||
let mut owners = HashMap::new();
|
||||
for (index, repository) in info.repositories.iter().enumerate() {
|
||||
for path in &repository.paths {
|
||||
if owners.insert(path, index).is_some() {
|
||||
return Err(IdeError::invalid("A file belongs to more than one repository in this shelf"));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut patches = BTreeMap::<usize, String>::new();
|
||||
for (section, file) in crate::patch::sections(&patch) {
|
||||
let index =
|
||||
owners.get(&file.path).ok_or_else(|| IdeError::invalid("The shelved file has no owning repository"))?;
|
||||
patches.entry(*index).or_default().push_str(section);
|
||||
}
|
||||
Ok(patches
|
||||
.into_iter()
|
||||
.map(|(index, patch)| {
|
||||
let repository = &info.repositories[index];
|
||||
ShelfSelection { repo: Some(repository.root.clone()), prefix: repository.prefix.clone(), patch }
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
fn now_ms() -> f64 {
|
||||
@@ -332,42 +51,13 @@ fn entry_dir(shelf: &Path, id: &str) -> IdeResult<PathBuf> {
|
||||
Ok(dir)
|
||||
}
|
||||
|
||||
fn members(shelf: &Path, id: &str) -> IdeResult<Vec<String>> {
|
||||
if !id.starts_with("batch-") {
|
||||
entry_dir(shelf, id)?;
|
||||
return Ok(vec![id.to_owned()]);
|
||||
}
|
||||
let mut ids = Vec::new();
|
||||
if let Ok(entries) = std::fs::read_dir(shelf) {
|
||||
for entry in entries.flatten() {
|
||||
let dir = entry.path();
|
||||
if dir.join(PATCH).is_file() && read_info(&dir).is_some_and(|info| info.group.as_deref() == Some(id)) {
|
||||
ids.push(entry.file_name().to_string_lossy().into_owned());
|
||||
}
|
||||
}
|
||||
}
|
||||
if ids.is_empty() {
|
||||
return Err(IdeError::not_found(format!("shelved changes '{id}' not found")));
|
||||
}
|
||||
ids.sort();
|
||||
Ok(ids)
|
||||
}
|
||||
|
||||
fn read_info(dir: &Path) -> Option<Info> {
|
||||
serde_json::from_slice(&std::fs::read(dir.join(INFO)).ok()?).ok()
|
||||
}
|
||||
|
||||
fn changed_files(patch: &str) -> Vec<ChangedFile> {
|
||||
crate::patch::parse_patch(patch)
|
||||
.into_iter()
|
||||
.map(|file| ChangedFile { path: file.path, kind: file.kind, old_path: file.old_path, link: None })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Shelved change lists, newest first.
|
||||
pub fn list(shelf: &Path) -> IdeResult<Vec<ShelvedChangeList>> {
|
||||
let mut out = Vec::new();
|
||||
let mut groups = HashMap::<String, ShelvedChangeList>::new();
|
||||
let Ok(entries) = std::fs::read_dir(shelf) else { return Ok(out) };
|
||||
for e in entries.flatten() {
|
||||
let dir = e.path();
|
||||
@@ -380,8 +70,6 @@ pub fn list(shelf: &Path) -> IdeResult<Vec<ShelvedChangeList>> {
|
||||
time_ms: 0.0,
|
||||
branch: None,
|
||||
repo: None,
|
||||
repositories: Vec::new(),
|
||||
group: None,
|
||||
files: std::fs::read_to_string(dir.join(PATCH))
|
||||
.map(|p| {
|
||||
crate::patch::parse_patch(&p)
|
||||
@@ -391,8 +79,8 @@ pub fn list(shelf: &Path) -> IdeResult<Vec<ShelvedChangeList>> {
|
||||
})
|
||||
.unwrap_or_default(),
|
||||
});
|
||||
let entry = ShelvedChangeList {
|
||||
id: info.group.clone().unwrap_or(id),
|
||||
out.push(ShelvedChangeList {
|
||||
id,
|
||||
name: info.name,
|
||||
time_ms: info.time_ms,
|
||||
branch: info.branch,
|
||||
@@ -401,43 +89,24 @@ pub fn list(shelf: &Path) -> IdeResult<Vec<ShelvedChangeList>> {
|
||||
.into_iter()
|
||||
.map(|f| crate::ChangedFile { path: f.path, kind: f.kind, old_path: f.old_path, link: None })
|
||||
.collect(),
|
||||
};
|
||||
if let Some(group) = info.group {
|
||||
if let Some(existing) = groups.get_mut(&group) {
|
||||
existing.files.extend(entry.files);
|
||||
existing.time_ms = existing.time_ms.max(entry.time_ms);
|
||||
existing.branch = None;
|
||||
} else {
|
||||
groups.insert(group, entry);
|
||||
}
|
||||
} else {
|
||||
out.push(entry);
|
||||
}
|
||||
});
|
||||
}
|
||||
out.extend(groups.into_values());
|
||||
out.sort_by(|a, b| b.time_ms.total_cmp(&a.time_ms).then_with(|| a.name.cmp(&b.name)));
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The patch text of a shelved change list.
|
||||
pub fn patch_of(shelf: &Path, id: &str) -> IdeResult<String> {
|
||||
let patches = members(shelf, id)?
|
||||
.into_iter()
|
||||
.map(|id| Ok(std::fs::read_to_string(entry_dir(shelf, &id)?.join(PATCH))?))
|
||||
.collect::<IdeResult<Vec<_>>>()?;
|
||||
Ok(patches.concat())
|
||||
Ok(std::fs::read_to_string(entry_dir(shelf, id)?.join(PATCH))?)
|
||||
}
|
||||
|
||||
/// The repository captured when the shelf was made; legacy shelves used the primary repository.
|
||||
pub fn repository(shelf: &Path, id: &str) -> IdeResult<Option<PathBuf>> {
|
||||
let members = members(shelf, id)?;
|
||||
Ok(read_info(&entry_dir(shelf, &members[0])?).and_then(|info| info.repo).map(|repo| repo.into_path_buf()))
|
||||
Ok(read_info(&entry_dir(shelf, id)?).and_then(|info| info.repo).map(|repo| repo.into_path_buf()))
|
||||
}
|
||||
|
||||
pub fn delete(shelf: &Path, id: &str) -> IdeResult<()> {
|
||||
for member in members(shelf, id)? {
|
||||
std::fs::remove_dir_all(entry_dir(shelf, &member)?)?;
|
||||
}
|
||||
std::fs::remove_dir_all(entry_dir(shelf, id)?)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -446,20 +115,12 @@ pub fn rename(shelf: &Path, id: &str, name: &str) -> IdeResult<()> {
|
||||
if name.is_empty() {
|
||||
return Err(IdeError::invalid("name must not be empty"));
|
||||
}
|
||||
for member in members(shelf, id)? {
|
||||
rename_entry(&entry_dir(shelf, &member)?, name)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn rename_entry(dir: &Path, name: &str) -> IdeResult<()> {
|
||||
let mut info = read_info(dir).unwrap_or(Info {
|
||||
let dir = entry_dir(shelf, id)?;
|
||||
let mut info = read_info(&dir).unwrap_or(Info {
|
||||
name: String::new(),
|
||||
time_ms: now_ms(),
|
||||
branch: None,
|
||||
repo: None,
|
||||
repositories: Vec::new(),
|
||||
group: None,
|
||||
files: vec![],
|
||||
});
|
||||
info.name = name.to_string();
|
||||
@@ -477,220 +138,37 @@ pub(crate) fn shelve(r: &Repo, shelf: &Path, name: &str, rel_paths: &[String]) -
|
||||
if files.is_empty() || patch.trim().is_empty() {
|
||||
return Err(IdeError::invalid("no changes to shelve"));
|
||||
}
|
||||
let entry = save_patch(r, shelf, name, &patch, files, None)?;
|
||||
revert_files(r, &entry.files)?;
|
||||
Ok(entry)
|
||||
}
|
||||
|
||||
/// Creates one visible entry per affected change list and one native archive for restoration.
|
||||
pub(crate) fn capture_stash(r: &Repo, options: AutomaticShelf, name: &str, stash: &Stash) -> IdeResult<SavedShelves> {
|
||||
let base = stash.base.as_deref().ok_or_else(|| IdeError::invalid("The saved local changes have no base commit"))?;
|
||||
let batch = SHELF_BATCH.with(|slot| slot.borrow().clone());
|
||||
let prefix = batch.as_ref().map(|batch| repository_prefix(r.root(), &batch.base)).transpose()?.unwrap_or_default();
|
||||
let working = crate::patch::shelf_tree_patch_with_prefix(r, base, &stash.id, &prefix)?;
|
||||
let staged = crate::patch::shelf_tree_patch_with_prefix(r, base, &format!("{}^2", stash.id), &prefix)?;
|
||||
let groups = shelf_groups(r, base, stash, options.changelist_root.as_deref(), &working, &staged, &prefix)?;
|
||||
if groups.is_empty() {
|
||||
return Err(IdeError::invalid("Could not identify the stash containing the saved local changes"));
|
||||
std::fs::create_dir_all(shelf)?;
|
||||
let base = slug(name);
|
||||
let mut id = base.clone();
|
||||
let mut n = 1;
|
||||
while shelf.join(&id).exists() {
|
||||
n += 1;
|
||||
id = format!("{base}_{n}");
|
||||
}
|
||||
let branch = r.branch_info()?.head;
|
||||
crate::changelists::ensure_ignored(&options.directory, &["*"])?;
|
||||
let revisions = format!("{}\n^{base}\n", stash.id);
|
||||
let pack = run(r.root(), &["pack-objects", "--stdout", "--revs"], Some(revisions.as_bytes()))?.stdout;
|
||||
let mut archive = tempfile::Builder::new().prefix(".snapshot-").tempfile_in(&options.directory)?;
|
||||
archive.write_all(&pack)?;
|
||||
let filename = archive.path().file_name().unwrap().to_string_lossy().into_owned();
|
||||
let mut saved = SavedShelves {
|
||||
directory: options.directory,
|
||||
entries: Vec::new(),
|
||||
snapshot: stash.id.clone(),
|
||||
archive: filename,
|
||||
prefix,
|
||||
batch: batch.as_ref().map(|batch| batch.id.clone()),
|
||||
};
|
||||
for ((list, label), (patch, files)) in groups {
|
||||
let label = if list.is_empty() { name.to_owned() } else { format!("[{label}] {name}") };
|
||||
let mut info = Info {
|
||||
name: label,
|
||||
time_ms: now_ms(),
|
||||
branch: branch.clone(),
|
||||
repo: Some(r.root().into()),
|
||||
files,
|
||||
repositories: Vec::new(),
|
||||
group: None,
|
||||
};
|
||||
if let Some(batch) = &batch {
|
||||
let key = format!("{}\0{}\0{name}\0{list}", batch.id, ide_core::ipc_path::to_ipc(&batch.base));
|
||||
info.group = Some(format!("batch-{}", blake3::hash(key.as_bytes())));
|
||||
info.repo = Some(batch.base.as_path().into());
|
||||
info.repositories.push(ShelfRepository {
|
||||
root: r.root().into(),
|
||||
prefix: saved.prefix.clone(),
|
||||
paths: info.files.iter().map(|file| file.path.clone()).collect(),
|
||||
});
|
||||
}
|
||||
match write_entry(&saved.directory, info, &patch, Some(&saved.archive)) {
|
||||
Ok(entry) => saved.entries.push(entry.id),
|
||||
Err(error) => {
|
||||
saved.clean_entries();
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Err(error) = archive.keep() {
|
||||
saved.clean_entries();
|
||||
return Err(error.error.into());
|
||||
}
|
||||
Ok(saved)
|
||||
}
|
||||
|
||||
type ShelfPatch = (String, Vec<ChangedFile>);
|
||||
type ShelfGroups = BTreeMap<(String, String), ShelfPatch>;
|
||||
|
||||
fn shelf_groups(
|
||||
r: &Repo,
|
||||
base: &str,
|
||||
stash: &Stash,
|
||||
root: Option<&Path>,
|
||||
working: &str,
|
||||
staged: &str,
|
||||
prefix: &str,
|
||||
) -> IdeResult<ShelfGroups> {
|
||||
let mut groups = ShelfGroups::new();
|
||||
let state = root.map(|path| crate::changelists::load(&ide_core::project_dir::path(path, "changelists.json")));
|
||||
let mut renamed = HashMap::new();
|
||||
if root.is_some() {
|
||||
for tree in [format!("{}^2", stash.id), stash.id.clone()] {
|
||||
let status = run(r.root(), &["diff", "--name-status", "-z", "--find-renames", base, &tree, "--"], None)?;
|
||||
for file in crate::ops::parse_name_status(&status.stdout_str()) {
|
||||
if file.kind == ChangeKind::Renamed
|
||||
&& let Some(old) = file.old_path
|
||||
{
|
||||
renamed.insert(old, file.path);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let working = crate::patch::sections(working);
|
||||
let visible: HashSet<_> = working.iter().map(|(_, file)| file.path.clone()).collect();
|
||||
// Index-only edits also belong to the shelf preview.
|
||||
for (section, file) in working
|
||||
.into_iter()
|
||||
.chain(crate::patch::sections(staged).into_iter().filter(|(_, f)| !visible.contains(&f.path)))
|
||||
{
|
||||
let group = match (root, state.as_ref()) {
|
||||
(Some(root), Some(state)) => {
|
||||
let rel = file.path.strip_prefix(prefix).unwrap_or(&file.path);
|
||||
let path = r.abs_path(renamed.get(rel).map_or(rel, String::as_str));
|
||||
let key = ide_core::ipc_path::to_ipc(path.strip_prefix(root).unwrap_or(&path));
|
||||
let id = state.files.get(&key).unwrap_or(&state.active);
|
||||
let list = state.lists.iter().find(|list| &list.id == id).unwrap_or(&state.lists[0]);
|
||||
(list.id.clone(), list.name.clone())
|
||||
}
|
||||
_ => (String::new(), String::new()),
|
||||
};
|
||||
let (patch, files) = groups.entry(group).or_default();
|
||||
patch.push_str(section);
|
||||
files.push(ChangedFile { path: file.path, kind: file.kind, old_path: file.old_path, link: None });
|
||||
}
|
||||
Ok(groups)
|
||||
}
|
||||
|
||||
fn save_patch(
|
||||
r: &Repo,
|
||||
shelf: &Path,
|
||||
name: &str,
|
||||
patch: &str,
|
||||
files: Vec<crate::ChangedFile>,
|
||||
snapshot: Option<&str>,
|
||||
) -> IdeResult<ShelvedChangeList> {
|
||||
let dir = shelf.join(&id);
|
||||
std::fs::create_dir_all(&dir)?;
|
||||
let info = Info {
|
||||
name: name.to_string(),
|
||||
time_ms: now_ms(),
|
||||
branch: r.branch_info()?.head,
|
||||
files,
|
||||
files: files.clone(),
|
||||
repo: Some(r.root().to_path_buf().into()),
|
||||
repositories: Vec::new(),
|
||||
group: None,
|
||||
};
|
||||
write_entry(shelf, info, patch, snapshot)
|
||||
}
|
||||
|
||||
fn write_entry(shelf: &Path, info: Info, patch: &str, snapshot: Option<&str>) -> IdeResult<ShelvedChangeList> {
|
||||
std::fs::create_dir_all(shelf)?;
|
||||
let base = slug(&info.name);
|
||||
let mut id = base.clone();
|
||||
let mut n = 0;
|
||||
let dir = loop {
|
||||
let dir = shelf.join(&id);
|
||||
match std::fs::create_dir(&dir) {
|
||||
Ok(()) => break dir,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {}
|
||||
Err(error) => return Err(error.into()),
|
||||
}
|
||||
n += 1;
|
||||
id = format!("{base}_{n}");
|
||||
};
|
||||
let write = || -> IdeResult<()> {
|
||||
std::fs::write(dir.join(PATCH), patch.as_bytes())?;
|
||||
std::fs::write(
|
||||
dir.join(INFO),
|
||||
serde_json::to_vec_pretty(&info).map_err(|e| IdeError::internal(e.to_string()))?,
|
||||
)?;
|
||||
if !info.repositories.is_empty() {
|
||||
std::fs::write(dir.join(GROUPED), "")?;
|
||||
}
|
||||
if let Some(snapshot) = snapshot {
|
||||
let digest = blake3::hash(patch.as_bytes());
|
||||
std::fs::write(dir.join(SNAPSHOT), format!("{snapshot}\n{digest}"))?;
|
||||
}
|
||||
let mut file = tempfile::NamedTempFile::new_in(&dir)?;
|
||||
file.write_all(patch.as_bytes())?;
|
||||
file.persist(dir.join(PATCH)).map_err(|error| error.error)?;
|
||||
Ok(())
|
||||
};
|
||||
if let Err(e) = write() {
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
return Err(e);
|
||||
}
|
||||
Ok(ShelvedChangeList {
|
||||
id,
|
||||
name: info.name,
|
||||
time_ms: info.time_ms,
|
||||
branch: info.branch,
|
||||
repo: info.repo,
|
||||
files: info.files,
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether the pending shelf still exists and whether its snapshot still matches all of its files.
|
||||
pub(crate) fn pending_snapshot(shelf: &Path, id: &str, snapshot: &str) -> IdeResult<Option<bool>> {
|
||||
Ok(owned_patch(shelf, id, snapshot)?.map(|(_, intact)| intact))
|
||||
}
|
||||
|
||||
fn owned_patch(shelf: &Path, id: &str, snapshot: &str) -> IdeResult<Option<(String, bool)>> {
|
||||
let dir = shelf.join(id);
|
||||
if !dir.join(PATCH).is_file() {
|
||||
return Ok(None);
|
||||
}
|
||||
let dir = entry_dir(shelf, id)?;
|
||||
let saved = match std::fs::read_to_string(dir.join(SNAPSHOT)) {
|
||||
Ok(saved) => saved,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
|
||||
Err(error) => return Err(error.into()),
|
||||
};
|
||||
let Some((id, digest)) = saved.split_once('\n') else { return Ok(None) };
|
||||
if id != snapshot {
|
||||
return Ok(None);
|
||||
}
|
||||
let patch = std::fs::read_to_string(dir.join(PATCH))?;
|
||||
let intact = blake3::hash(patch.as_bytes()).to_hex().as_str() == digest;
|
||||
Ok(Some((patch, intact)))
|
||||
}
|
||||
|
||||
pub(crate) fn materialize_snapshot(r: &Repo, shelf: &Path, id: &str) -> IdeResult<()> {
|
||||
let pack = std::fs::read(entry_dir(shelf, id)?.join(SNAPSHOT_PACK))?;
|
||||
run(r.root(), &["unpack-objects", "-q"], Some(&pack))?;
|
||||
Ok(())
|
||||
revert_files(r, &files)?;
|
||||
Ok(ShelvedChangeList { id, name: info.name, time_ms: info.time_ms, branch: info.branch, repo: info.repo, files })
|
||||
}
|
||||
|
||||
/// Restores `files` to HEAD in both index and working tree; files absent from HEAD are removed.
|
||||
@@ -722,7 +200,7 @@ pub(crate) fn unshelve(r: &Repo, shelf: &Path, id: &str, remove: bool) -> IdeRes
|
||||
}
|
||||
|
||||
pub fn unshelve_path(r: &Repo, shelf: &Path, id: &str, remove: bool, path: Option<&str>) -> IdeResult<ApplyOutcome> {
|
||||
let _scope = r.execution_scope();
|
||||
let _scope = crate::ExecutionScope::enter(r.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let patch = selected_patch(shelf, id, path)?;
|
||||
let outcome = crate::patch::apply(r, &patch)?;
|
||||
if remove && outcome.conflicts.is_empty() {
|
||||
@@ -740,72 +218,84 @@ pub struct ShelfDiffFile {
|
||||
pub after: Option<String>,
|
||||
}
|
||||
|
||||
fn sections(patch: &str) -> Vec<(&str, crate::PatchFile)> {
|
||||
let mut starts: Vec<_> = patch
|
||||
.match_indices("diff --git ")
|
||||
.filter(|(i, _)| *i == 0 || patch.as_bytes()[i - 1] == b'\n')
|
||||
.map(|(i, _)| i)
|
||||
.collect();
|
||||
if starts.is_empty() {
|
||||
let (mut old, mut new) = (0u32, 0u32);
|
||||
let mut offset = 0;
|
||||
let mut lines = patch.split_inclusive('\n').peekable();
|
||||
while let Some(line) = lines.next() {
|
||||
if old > 0 || new > 0 {
|
||||
match line.as_bytes().first() {
|
||||
Some(b'-') => old = old.saturating_sub(1),
|
||||
Some(b'+') => new = new.saturating_sub(1),
|
||||
Some(b' ') => {
|
||||
old = old.saturating_sub(1);
|
||||
new = new.saturating_sub(1);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
} else if line.starts_with("--- ") && lines.peek().is_some_and(|l| l.starts_with("+++ ")) {
|
||||
starts.push(offset);
|
||||
}
|
||||
if let Some(range) = line.strip_prefix("@@ ") {
|
||||
let mut parts = range.split_whitespace();
|
||||
let count = |s: &str| s.split_once(',').map_or(1, |(_, n)| n.parse().unwrap_or(0));
|
||||
old = parts.next().map(count).unwrap_or(0);
|
||||
new = parts.next().map(count).unwrap_or(0);
|
||||
}
|
||||
offset += line.len();
|
||||
}
|
||||
}
|
||||
starts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(n, &start)| {
|
||||
let section = &patch[start..starts.get(n + 1).copied().unwrap_or(patch.len())];
|
||||
crate::patch::parse_patch(section).into_iter().next().map(|file| (section, file))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn selected_patch(shelf: &Path, id: &str, path: Option<&str>) -> IdeResult<String> {
|
||||
let patch = patch_of(shelf, id)?;
|
||||
let Some(path) = path else { return Ok(patch) };
|
||||
let selected = sections_for_path(&patch, path);
|
||||
let selected: String = sections(&patch).into_iter().filter(|(_, f)| f.path == path).map(|(p, _)| p).collect();
|
||||
if selected.is_empty() {
|
||||
return Err(IdeError::not_found("shelved file not found"));
|
||||
}
|
||||
Ok(selected)
|
||||
}
|
||||
|
||||
fn sections_for_path(patch: &str, path: &str) -> String {
|
||||
crate::patch::sections(patch).into_iter().filter(|(_, f)| f.path == path).map(|(p, _)| p).collect()
|
||||
}
|
||||
|
||||
pub fn delete_path(shelf: &Path, id: &str, path: Option<&str>) -> IdeResult<()> {
|
||||
let Some(path) = path else { return delete(shelf, id) };
|
||||
selected_patch(shelf, id, Some(path))?;
|
||||
delete_paths(shelf, id, &[path.to_owned()])
|
||||
}
|
||||
|
||||
pub fn delete_paths(shelf: &Path, id: &str, paths: &[String]) -> IdeResult<()> {
|
||||
if paths.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let paths: HashSet<_> = paths.iter().collect();
|
||||
for member in members(shelf, id)? {
|
||||
delete_paths_in_entry(shelf, &member, &paths)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn delete_paths_in_entry(shelf: &Path, id: &str, paths: &HashSet<&String>) -> IdeResult<()> {
|
||||
let dir = entry_dir(shelf, id)?;
|
||||
let patch = std::fs::read_to_string(dir.join(PATCH))?;
|
||||
let sections = crate::patch::sections(&patch);
|
||||
if !sections.iter().any(|(_, file)| paths.contains(&file.path)) {
|
||||
return Ok(());
|
||||
}
|
||||
let remaining: String = sections.into_iter().filter(|(_, f)| !paths.contains(&f.path)).map(|(p, _)| p).collect();
|
||||
let patch = patch_of(shelf, id)?;
|
||||
let remaining: String = sections(&patch).into_iter().filter(|(_, f)| f.path != path).map(|(p, _)| p).collect();
|
||||
if remaining.is_empty() {
|
||||
return delete(shelf, id);
|
||||
}
|
||||
if remaining == patch {
|
||||
return Ok(());
|
||||
}
|
||||
let dir = entry_dir(shelf, id)?;
|
||||
let mut info = read_info(&dir).ok_or_else(|| IdeError::invalid("shelf metadata is missing"))?;
|
||||
info.files = changed_files(&remaining);
|
||||
let mut file = tempfile::NamedTempFile::new_in(&dir)?;
|
||||
file.write_all(remaining.as_bytes())?;
|
||||
file.persist(dir.join(PATCH)).map_err(|error| error.error)?;
|
||||
info.files = crate::patch::parse_patch(&remaining)
|
||||
.into_iter()
|
||||
.map(|f| crate::ChangedFile { path: f.path, kind: f.kind, old_path: f.old_path, link: None })
|
||||
.collect();
|
||||
std::fs::write(dir.join(PATCH), remaining)?;
|
||||
std::fs::write(dir.join(INFO), serde_json::to_vec_pretty(&info).map_err(|e| IdeError::internal(e.to_string()))?)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Reconstruct each side in a throwaway index; neither HEAD nor the working files are used.
|
||||
pub fn diff_files(r: &Repo, shelf: &Path, id: &str) -> IdeResult<Vec<ShelfDiffFile>> {
|
||||
diff_from_patch(r, &patch_of(shelf, id)?, "")
|
||||
}
|
||||
|
||||
fn diff_from_patch(r: &Repo, patch: &str, prefix: &str) -> IdeResult<Vec<ShelfDiffFile>> {
|
||||
let _scope = r.execution_scope();
|
||||
let strip = crate::patch::strip_option(prefix);
|
||||
let mut apply = vec!["apply"];
|
||||
apply.extend(strip.as_deref());
|
||||
let _scope = crate::ExecutionScope::enter(r.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
let patch = patch_of(shelf, id)?;
|
||||
let mut out = Vec::new();
|
||||
for (section, file) in crate::patch::sections(patch) {
|
||||
for (section, file) in sections(&patch) {
|
||||
let mut item = ShelfDiffFile { path: file.path.clone(), patch: section.to_string(), before: None, after: None };
|
||||
if !file.binary {
|
||||
let reconstruct = || -> IdeResult<(String, String)> {
|
||||
@@ -814,14 +304,11 @@ fn diff_from_patch(r: &Repo, patch: &str, prefix: &str) -> IdeResult<Vec<ShelfDi
|
||||
let env = [("GIT_INDEX_FILE", index.as_os_str())];
|
||||
run_env(
|
||||
r.root(),
|
||||
&[apply.as_slice(), &[&format!("--build-fake-ancestor={}", index.display()), "-"]].concat(),
|
||||
&["apply", &format!("--build-fake-ancestor={}", index.display()), "-"],
|
||||
Some(section.as_bytes()),
|
||||
&env,
|
||||
)?;
|
||||
let read = |path: &str| -> IdeResult<String> {
|
||||
let path = path
|
||||
.strip_prefix(prefix)
|
||||
.ok_or_else(|| IdeError::invalid("The patch contains a path outside its repository"))?;
|
||||
let bytes = run_env(r.root(), &["show", &format!(":{path}")], None, &env)?.stdout;
|
||||
if bytes.contains(&0) {
|
||||
return Err(IdeError::invalid("binary file"));
|
||||
@@ -835,7 +322,7 @@ fn diff_from_patch(r: &Repo, patch: &str, prefix: &str) -> IdeResult<Vec<ShelfDi
|
||||
};
|
||||
run_env(
|
||||
r.root(),
|
||||
&[apply.as_slice(), &["--cached", "--binary", "--whitespace=nowarn", "-"]].concat(),
|
||||
&["apply", "--cached", "--binary", "--whitespace=nowarn", "-"],
|
||||
Some(section.as_bytes()),
|
||||
&env,
|
||||
)?;
|
||||
@@ -855,7 +342,7 @@ fn diff_from_patch(r: &Repo, patch: &str, prefix: &str) -> IdeResult<Vec<ShelfDi
|
||||
/// Import into the shelf without applying to the working tree.
|
||||
pub fn import_patch(shelf: &Path, name: &str, patch: &str, repo: Option<&Path>) -> IdeResult<()> {
|
||||
let files = crate::patch::parse_patch(patch);
|
||||
if files.is_empty() || crate::patch::sections(patch).len() != files.len() {
|
||||
if files.is_empty() || sections(patch).len() != files.len() {
|
||||
return Err(IdeError::invalid("no file changes found in the patch"));
|
||||
}
|
||||
std::fs::create_dir_all(shelf)?;
|
||||
@@ -870,8 +357,6 @@ pub fn import_patch(shelf: &Path, name: &str, patch: &str, repo: Option<&Path>)
|
||||
time_ms: now_ms(),
|
||||
branch: None,
|
||||
repo: repo.map(|r| r.to_path_buf().into()),
|
||||
repositories: Vec::new(),
|
||||
group: None,
|
||||
files: files
|
||||
.into_iter()
|
||||
.map(|f| crate::ChangedFile { path: f.path, kind: f.kind, old_path: f.old_path, link: None })
|
||||
|
||||
@@ -1,266 +0,0 @@
|
||||
use crate::{Repo, cli, execution_allowed};
|
||||
use gix::lock::{self, acquire::Fail};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::io;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct GitSigningConfig {
|
||||
pub format: String,
|
||||
pub enabled: bool,
|
||||
pub key: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct GpgSigningKey {
|
||||
pub fingerprint: String,
|
||||
pub user_id: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct GitSigningEdit {
|
||||
pub enabled: Option<bool>,
|
||||
pub key: Option<String>,
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
pub fn signing_config(&self) -> IdeResult<GitSigningConfig> {
|
||||
Ok(GitSigningConfig {
|
||||
format: self.config_get("gpg.format")?.unwrap_or_else(|| "openpgp".into()),
|
||||
enabled: self.config_get_bool("commit.gpgsign")?.unwrap_or_default(),
|
||||
key: self.config_get("user.signingkey")?.filter(|key| !key.is_empty()),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn gpg_signing_keys(&self, cancel: &CancellationToken) -> IdeResult<Vec<GpgSigningKey>> {
|
||||
let _scope = self.execution_scope();
|
||||
self.require_openpgp()?;
|
||||
let program = gpg_program(self.root(), cancel)?;
|
||||
let mut cmd = Command::new(&program);
|
||||
cmd.current_dir(self.root()).args(["--batch", "--no-tty", "--with-colons", "--list-secret-keys"]);
|
||||
ide_core::process::prepare(&mut cmd);
|
||||
let out = cli::capture_command(cmd, None, cancel, 4 << 20, "GnuPG")?;
|
||||
if out.code != Some(0) {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"Could not list OpenPGP signing keys ({}): {}",
|
||||
program.display(),
|
||||
String::from_utf8_lossy(&out.stderr).trim()
|
||||
)));
|
||||
}
|
||||
Ok(parse_keys(&out.stdout_str()))
|
||||
}
|
||||
|
||||
pub fn edit_signing(&self, edit: GitSigningEdit) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
self.require_openpgp()?;
|
||||
if edit.enabled.is_none() && edit.key.is_none() {
|
||||
return Ok(());
|
||||
}
|
||||
if edit.key.as_deref().is_some_and(|key| !valid_fingerprint(key)) {
|
||||
return Err(IdeError::invalid("invalid OpenPGP fingerprint"));
|
||||
}
|
||||
let config = self.metadata_dirs()?[1].join("config");
|
||||
let mut lock = lock::File::acquire(&config, Fail::Immediately, None, 0, Some(&lock::acquire::resolve_symlink))
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, error.to_string()))?;
|
||||
|
||||
// Let Git rewrite both values, holding its normal config lock until both edits succeed.
|
||||
let mut original = std::fs::File::open(&config)?;
|
||||
let mut staged = tempfile::NamedTempFile::new_in(config.parent().expect("repository config directory"))?;
|
||||
io::copy(&mut original, &mut staged)?;
|
||||
let enabled = edit.enabled.map(|enabled| if enabled { "true" } else { "false" });
|
||||
for (name, value) in [("commit.gpgsign", enabled), ("user.signingkey", edit.key.as_deref())] {
|
||||
if let Some(value) = value {
|
||||
cli::run(
|
||||
self.root(),
|
||||
&[
|
||||
"config",
|
||||
"--file",
|
||||
staged.path().to_str().ok_or_else(|| IdeError::invalid("non-UTF-8 Git config path"))?,
|
||||
"--replace-all",
|
||||
"--",
|
||||
name,
|
||||
value,
|
||||
],
|
||||
None,
|
||||
)?;
|
||||
}
|
||||
}
|
||||
// Git's config writer replaces the staging file, so reopen its final path.
|
||||
let mut updated = std::fs::File::open(staged.path())?;
|
||||
lock.with_mut(|file| {
|
||||
io::copy(&mut updated, file)?;
|
||||
file.set_permissions(original.metadata()?.permissions())
|
||||
})?;
|
||||
drop(original);
|
||||
lock.commit().map_err(|error| IdeError::new(ErrorKind::Io, error.to_string()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn require_openpgp(&self) -> IdeResult<()> {
|
||||
if !execution_allowed() {
|
||||
return Err(IdeError::unavailable("Git signing configuration requires a trusted project"));
|
||||
}
|
||||
if self.config_get("gpg.format")?.is_some_and(|format| format != "openpgp") {
|
||||
return Err(IdeError::invalid("the repository uses a signing format other than OpenPGP"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn gpg_program(root: &Path, cancel: &CancellationToken) -> IdeResult<PathBuf> {
|
||||
let args = ["config", "--null", "--get-regexp", r"^gpg\.(openpgp\.)?program$"];
|
||||
let out = cli::run_cancellable_raw(root, &args, cancel)?;
|
||||
let program = match out.code {
|
||||
Some(0) => {
|
||||
let config = out.stdout_str();
|
||||
let (_, program) = config
|
||||
.split_terminator('\0')
|
||||
.next_back()
|
||||
.and_then(|entry| entry.split_once('\n'))
|
||||
.filter(|(_, program)| !program.is_empty())
|
||||
.ok_or_else(|| IdeError::invalid("invalid OpenPGP signing program"))?;
|
||||
PathBuf::from(program)
|
||||
}
|
||||
Some(1) if out.stderr.is_empty() => PathBuf::from("gpg"),
|
||||
_ => return Err(cli::failure(&args, &out.stderr, &out.stdout, out.code)),
|
||||
};
|
||||
if cfg!(windows)
|
||||
&& (program.as_os_str().eq_ignore_ascii_case("gpg") || program.as_os_str().eq_ignore_ascii_case("gpg.exe"))
|
||||
{
|
||||
let exec_path = cli::run_cancellable(root, &["--exec-path"], cancel)?.stdout_str();
|
||||
let bundled = Path::new(exec_path.trim()).join("../../../usr/bin/gpg.exe");
|
||||
if let Ok(path) = dunce::canonicalize(bundled) {
|
||||
return Ok(path);
|
||||
}
|
||||
}
|
||||
Ok(if program.is_relative() && program.components().count() > 1 { root.join(program) } else { program })
|
||||
}
|
||||
|
||||
fn valid_fingerprint(value: &str) -> bool {
|
||||
matches!(value.len(), 40 | 64) && value.bytes().all(|byte| byte.is_ascii_hexdigit())
|
||||
}
|
||||
|
||||
fn parse_keys(output: &str) -> Vec<GpgSigningKey> {
|
||||
let mut keys = Vec::new();
|
||||
let mut pending = None;
|
||||
let mut follows_primary = false;
|
||||
for record in output.lines() {
|
||||
let fields: Vec<_> = record.split(':').collect();
|
||||
match fields.first().copied() {
|
||||
Some("sec") => {
|
||||
if let Some(key) = pending.take() {
|
||||
keys.push(key);
|
||||
}
|
||||
follows_primary = !matches!(fields.get(1), Some(&("r" | "e" | "i" | "d")))
|
||||
&& fields.get(11).is_some_and(|caps| caps.contains('S') && !caps.contains('D'));
|
||||
}
|
||||
Some("fpr") if follows_primary => {
|
||||
follows_primary = false;
|
||||
if let Some(fingerprint) = fields.get(9).filter(|value| valid_fingerprint(value)) {
|
||||
pending = Some(GpgSigningKey { fingerprint: fingerprint.to_string(), user_id: None });
|
||||
}
|
||||
}
|
||||
Some("uid") => {
|
||||
if let Some(key) = pending.as_mut().filter(|key| key.user_id.is_none()) {
|
||||
key.user_id = fields.get(9).map(|value| decode_user_id(value));
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
keys.extend(pending);
|
||||
keys
|
||||
}
|
||||
|
||||
fn decode_user_id(value: &str) -> String {
|
||||
let mut bytes = Vec::new();
|
||||
let mut rest = value.as_bytes();
|
||||
while let Some((&byte, tail)) = rest.split_first() {
|
||||
if let [b'\\', b'x', high, low, remaining @ ..] = rest
|
||||
&& let (Some(high), Some(low)) = (char::from(*high).to_digit(16), char::from(*low).to_digit(16))
|
||||
{
|
||||
bytes.push((high * 16 + low) as u8);
|
||||
rest = remaining;
|
||||
} else {
|
||||
bytes.push(byte);
|
||||
rest = tail;
|
||||
}
|
||||
}
|
||||
String::from_utf8_lossy(&bytes).into_owned()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::ExecutionScope;
|
||||
|
||||
const FINGERPRINT: &str = "1234567890123456789012345678901234567890";
|
||||
const SUBKEY: &str = "ABCDEFABCDEFABCDEFABCDEFABCDEFABCDEFABCD";
|
||||
|
||||
#[test]
|
||||
fn lists_signing_primary_fingerprints_and_decodes_user_ids() {
|
||||
let records = format!(
|
||||
"sec:u:255:22:67890:1:::u:::cSC:::+::ed25519:::0:\n\
|
||||
fpr:::::::::{FINGERPRINT}:\n\
|
||||
uid:u::::1::AA::Signing\\x3a Test <test@example.com>::::::::::0:\n\
|
||||
ssb:u:255:22:FFFF:1::::::s:::+::ed25519::\n\
|
||||
fpr:::::::::{SUBKEY}:\n\
|
||||
sec:e:255:22:1111:1:::u:::sS:::+::ed25519:::0:\n\
|
||||
fpr:::::::::{SUBKEY}:\n\
|
||||
sec:u:255:22:2222:1:::u:::eE:::+::ed25519:::0:\n\
|
||||
fpr:::::::::{SUBKEY}:\n"
|
||||
);
|
||||
assert_eq!(
|
||||
parse_keys(&records),
|
||||
vec![GpgSigningKey {
|
||||
fingerprint: FINGERPRINT.into(),
|
||||
user_id: Some("Signing: Test <[email protected]>".into()),
|
||||
}]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn edits_local_signing_config_with_git_lock_and_preserves_other_settings() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let git = |args: &[&str]| {
|
||||
let _scope = ExecutionScope::enter(true);
|
||||
cli::run(dir.path(), args, None).unwrap().stdout_str()
|
||||
};
|
||||
git(&["init"]);
|
||||
git(&["config", "--local", "gpg.format", "openpgp"]);
|
||||
git(&["config", "--local", "commit.gpgsign", "false"]);
|
||||
git(&["config", "--local", "user.signingkey", "old-key"]);
|
||||
git(&["config", "--local", "user.email", "[email protected]"]);
|
||||
let repo = Repo::discover(dir.path()).unwrap().unwrap();
|
||||
|
||||
let enable = || GitSigningEdit { enabled: Some(true), key: Some(FINGERPRINT.into()) };
|
||||
assert!(repo.edit_signing(enable()).is_err());
|
||||
assert!(repo.gpg_signing_keys(&CancellationToken::default()).is_err());
|
||||
repo.set_execution_allowed(true);
|
||||
let lock = dir.path().join(".git/config.lock");
|
||||
std::fs::write(&lock, b"another process owns this lock").unwrap();
|
||||
assert!(repo.edit_signing(enable()).is_err());
|
||||
assert_eq!(git(&["config", "--local", "--get", "user.signingkey"]).trim(), "old-key");
|
||||
std::fs::remove_file(lock).unwrap();
|
||||
|
||||
repo.edit_signing(enable()).unwrap();
|
||||
assert_eq!(git(&["config", "--local", "--get", "user.signingkey"]).trim(), FINGERPRINT);
|
||||
assert_eq!(git(&["config", "--local", "--get", "user.email"]).trim(), "[email protected]");
|
||||
assert!(repo.signing_config().unwrap().enabled);
|
||||
|
||||
repo.edit_signing(GitSigningEdit { enabled: Some(false), key: None }).unwrap();
|
||||
assert!(!repo.signing_config().unwrap().enabled);
|
||||
assert_eq!(git(&["config", "--local", "--get", "user.signingkey"]).trim(), FINGERPRINT);
|
||||
|
||||
git(&["config", "--local", "gpg.format", "ssh"]);
|
||||
assert!(repo.edit_signing(enable()).is_err());
|
||||
assert_eq!(repo.signing_config().unwrap().format, "ssh");
|
||||
assert!(!repo.signing_config().unwrap().enabled);
|
||||
}
|
||||
}
|
||||
@@ -1,253 +0,0 @@
|
||||
use std::collections::HashSet;
|
||||
use std::fs::{self, File};
|
||||
use std::path::Path;
|
||||
|
||||
use gix::bstr::BStr;
|
||||
use gix::index::entry::{Flags, Mode, Stage};
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, IpcPath};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
|
||||
use crate::cli::TempIndex;
|
||||
use crate::diff::{normalize_eol, replace_text};
|
||||
use crate::repo::{blob_data, gx};
|
||||
use crate::text_encoding::{TextEncoding, decode, encode, has_bom, is_binary};
|
||||
use crate::{ApplyCommitReview, HunkKind, Repo, write};
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
pub struct StagedText {
|
||||
pub text: String,
|
||||
/// Identifies the index entry, including its mode, when this text was read.
|
||||
pub version: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
pub struct StagedTextEdit {
|
||||
pub path: IpcPath,
|
||||
pub version: String,
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct StagingLineHunk {
|
||||
pub kind: HunkKind,
|
||||
pub start: u32,
|
||||
pub lines: u32,
|
||||
pub head_start: u32,
|
||||
pub head_lines: u32,
|
||||
pub head_text: String,
|
||||
pub index_start: u32,
|
||||
pub index_lines: u32,
|
||||
pub index_text: String,
|
||||
pub staged: bool,
|
||||
pub unstaged: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct StagingLineHunks {
|
||||
pub index_version: String,
|
||||
pub hunks: Vec<StagingLineHunk>,
|
||||
}
|
||||
|
||||
struct StagedEntry {
|
||||
mode: &'static str,
|
||||
id: gix::ObjectId,
|
||||
}
|
||||
|
||||
impl StagedEntry {
|
||||
fn version(&self) -> String {
|
||||
format!("{}:{}", self.mode, self.id)
|
||||
}
|
||||
}
|
||||
|
||||
fn staged_entry(repo: &gix::Repository, rel: &str) -> IdeResult<Option<StagedEntry>> {
|
||||
if !repo.index_path().is_file() {
|
||||
return Ok(None);
|
||||
}
|
||||
let index = repo.open_index().map_err(gx)?;
|
||||
Ok(staged_entry_at(&index, rel))
|
||||
}
|
||||
|
||||
fn staged_entry_at(index: &gix::index::State, rel: &str) -> Option<StagedEntry> {
|
||||
let entry = index.entry_by_path_and_stage(BStr::new(rel.as_bytes()), Stage::Unconflicted)?;
|
||||
if entry.flags.contains(Flags::INTENT_TO_ADD) {
|
||||
return None;
|
||||
}
|
||||
let mode = match entry.mode {
|
||||
Mode::FILE => "100644",
|
||||
Mode::FILE_EXECUTABLE => "100755",
|
||||
_ => return None,
|
||||
};
|
||||
Some(StagedEntry { mode, id: entry.id })
|
||||
}
|
||||
|
||||
fn stale() -> IdeError {
|
||||
IdeError::new(ErrorKind::OutOfSync, "The staged version changed on disk")
|
||||
}
|
||||
|
||||
fn updated_text(bytes: &[u8], text: &str, encoding: TextEncoding) -> IdeResult<Option<Vec<u8>>> {
|
||||
if is_binary(bytes, encoding) {
|
||||
return Err(IdeError::invalid("Binary files cannot be edited in the index"));
|
||||
}
|
||||
let old = decode(bytes, encoding);
|
||||
if normalize_eol(&old) == normalize_eol(text) {
|
||||
return Ok(None);
|
||||
}
|
||||
let updated = replace_text(&old, text);
|
||||
Ok(Some(encode(&updated, encoding, has_bom(bytes, encoding))?))
|
||||
}
|
||||
|
||||
fn publish_index(mut lock: gix::lock::File, path: &Path, scratch: &TempIndex) -> IdeResult<()> {
|
||||
let permissions = fs::metadata(path)?.permissions();
|
||||
let mut result = File::open(scratch.path())?;
|
||||
lock.with_mut(|out| {
|
||||
std::io::copy(&mut result, out)?;
|
||||
out.set_permissions(permissions)?;
|
||||
out.sync_all()
|
||||
})?;
|
||||
lock.commit().map_err(gx)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
pub fn staging_line_hunks(
|
||||
&self,
|
||||
path: &Path,
|
||||
head_path: Option<&Path>,
|
||||
working: &str,
|
||||
max_bytes: usize,
|
||||
encoding: impl Fn(&Path, &[u8]) -> TextEncoding,
|
||||
) -> IdeResult<Option<StagingLineHunks>> {
|
||||
if working.len() > max_bytes {
|
||||
return Ok(None);
|
||||
}
|
||||
let Some(index) = self.staged_text(path, max_bytes, |bytes| encoding(path, bytes))? else {
|
||||
return Ok(None);
|
||||
};
|
||||
let head_path = head_path.unwrap_or(path);
|
||||
let bytes = self.file_bytes_at(head_path, Some("HEAD"))?.unwrap_or_default();
|
||||
let encoding = encoding(head_path, &bytes);
|
||||
if bytes.len() > max_bytes || is_binary(&bytes, encoding) {
|
||||
return Ok(None);
|
||||
}
|
||||
let head = decode(&bytes, encoding);
|
||||
Ok(Some(StagingLineHunks {
|
||||
hunks: crate::diff::staging_line_hunks(&head, &index.text, working),
|
||||
index_version: index.version,
|
||||
}))
|
||||
}
|
||||
|
||||
pub fn staged_text(
|
||||
&self,
|
||||
path: &Path,
|
||||
max_bytes: usize,
|
||||
encoding: impl FnOnce(&[u8]) -> TextEncoding,
|
||||
) -> IdeResult<Option<StagedText>> {
|
||||
let _scope = self.execution_scope();
|
||||
let repo = self.gix()?;
|
||||
let rel = self.rel_path(path)?;
|
||||
let Some(entry) = staged_entry(&repo, &rel)? else {
|
||||
return Ok(None);
|
||||
};
|
||||
if repo.try_find_header(entry.id).map_err(gx)?.is_some_and(|header| header.size() > max_bytes as u64) {
|
||||
return Ok(None);
|
||||
}
|
||||
let bytes = blob_data(&repo, entry.id)?;
|
||||
if bytes.len() > max_bytes {
|
||||
return Ok(None);
|
||||
}
|
||||
let encoding = encoding(&bytes);
|
||||
if is_binary(&bytes, encoding) {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some(StagedText { text: normalize_eol(&decode(&bytes, encoding)).into_owned(), version: entry.version() }))
|
||||
}
|
||||
|
||||
/// Replaces one stage-zero blob if the editor still has its current version.
|
||||
pub fn save_staged_text(
|
||||
&self,
|
||||
path: &Path,
|
||||
version: &str,
|
||||
text: &str,
|
||||
encoding: impl FnOnce(&[u8]) -> TextEncoding,
|
||||
) -> IdeResult<String> {
|
||||
let _scope = self.execution_scope();
|
||||
let repo = self.gix()?;
|
||||
let path_to_index = repo.index_path();
|
||||
let lock =
|
||||
gix::lock::File::acquire_to_update_resource(&path_to_index, gix::lock::acquire::Fail::Immediately, None, 0)
|
||||
.map_err(gx)?;
|
||||
let rel = self.rel_path(path)?;
|
||||
let Some(entry) = staged_entry(&repo, &rel)? else {
|
||||
return Err(stale());
|
||||
};
|
||||
let current = entry.version();
|
||||
if version != current {
|
||||
return Err(stale());
|
||||
}
|
||||
let bytes = blob_data(&repo, entry.id)?;
|
||||
let encoding = encoding(&bytes);
|
||||
let Some(contents) = updated_text(&bytes, text, encoding)? else {
|
||||
return Ok(current);
|
||||
};
|
||||
|
||||
// Let Git update the complete index, including its extensions, while its usual
|
||||
// lock protects the input version and prevents a concurrent writer from losing edits.
|
||||
let scratch = TempIndex::new(self);
|
||||
fs::copy(&path_to_index, scratch.path())?;
|
||||
let id = write::write_index_blob(self, &rel, &contents, &scratch.env())?;
|
||||
publish_index(lock, &path_to_index, &scratch)?;
|
||||
Ok(format!("{}:{id}", entry.mode))
|
||||
}
|
||||
|
||||
/// Publishes formatter output against exactly the Git operation and index the user reviewed.
|
||||
pub fn format_reviewed_apply(
|
||||
&self,
|
||||
checkpoint: &str,
|
||||
edits: &[StagedTextEdit],
|
||||
cancel: &CancellationToken,
|
||||
encoding: impl Fn(&Path, &[u8]) -> TextEncoding,
|
||||
) -> IdeResult<ApplyCommitReview> {
|
||||
let _scope = self.execution_scope();
|
||||
let repo = self.gix()?;
|
||||
let index_path = repo.index_path();
|
||||
let lock =
|
||||
gix::lock::File::acquire_to_update_resource(&index_path, gix::lock::acquire::Fail::Immediately, None, 0)
|
||||
.map_err(gx)?;
|
||||
let review = self.require_apply_review(checkpoint, cancel)?;
|
||||
let mut paths = review.paths.iter().map(|path| self.rel_path(&path.0)).collect::<IdeResult<HashSet<_>>>()?;
|
||||
let index = repo.open_index().map_err(gx)?;
|
||||
let scratch = TempIndex::new(self);
|
||||
fs::copy(&index_path, scratch.path())?;
|
||||
for edit in edits {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let path = &edit.path.0;
|
||||
let rel = self.rel_path(path)?;
|
||||
if !paths.remove(&rel) {
|
||||
return Err(stale());
|
||||
}
|
||||
let entry =
|
||||
staged_entry_at(&index, &rel).filter(|entry| entry.version() == edit.version).ok_or_else(stale)?;
|
||||
let bytes = blob_data(&repo, entry.id)?;
|
||||
if let Some(contents) = updated_text(&bytes, &edit.text, encoding(path, &bytes))? {
|
||||
write::write_index_blob(self, &rel, &contents, &scratch.env())?;
|
||||
}
|
||||
}
|
||||
// Leave an existing non-empty resolution intact when formatting would make the step empty.
|
||||
let Some(formatted) = self.review_apply_index(cancel, &scratch.env())? else { return Ok(review) };
|
||||
if formatted.checkpoint == checkpoint {
|
||||
return Ok(review);
|
||||
}
|
||||
self.require_apply_review(checkpoint, cancel)?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
publish_index(lock, &index_path, &scratch)?;
|
||||
Ok(formatted)
|
||||
}
|
||||
}
|
||||
@@ -31,36 +31,6 @@ pub(crate) fn status(r: &Repo) -> IdeResult<Vec<FileStatus>> {
|
||||
Ok(collect(r, &ignored, map, conflicts))
|
||||
}
|
||||
|
||||
/// Git-ignored working-tree entries, with ignored directories reported as one entry each.
|
||||
pub(crate) fn ignored_files(r: &Repo) -> IdeResult<Vec<FileStatus>> {
|
||||
let ignored = r.ignored.read().unwrap_or_else(|p| p.into_inner()).clone();
|
||||
let overrides = crate::cli::filter_overrides(r.root(), &ide_core::CancellationToken::new())?;
|
||||
let mut args: Vec<&str> = overrides.iter().map(String::as_str).collect();
|
||||
args.extend([
|
||||
"status",
|
||||
"--porcelain=v2",
|
||||
"-z",
|
||||
"--untracked-files=normal",
|
||||
"--ignored=matching",
|
||||
"--no-renames",
|
||||
"--ignore-submodules=all",
|
||||
]);
|
||||
let output = crate::cli::run_env(r.root(), &args, None, &read_only())?;
|
||||
Ok(output
|
||||
.stdout
|
||||
.split(|b| *b == 0)
|
||||
.filter_map(|record| std::str::from_utf8(record.strip_prefix(b"! ")?).ok())
|
||||
.filter(|rel| !rel.is_empty() && !ignored.is_ignored_path(rel))
|
||||
.map(|rel| FileStatus {
|
||||
path: r.abs_path(rel).into(),
|
||||
rel_path: rel.into(),
|
||||
staged: None,
|
||||
unstaged: Some(ChangeKind::Ignored),
|
||||
renamed_from: None,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Status of `paths` only (repository-relative, `/`-separated): the dirty-scope refresh.
|
||||
///
|
||||
/// A watcher batch touches a few files, and the full status walks the whole tree; git's own
|
||||
@@ -240,11 +210,9 @@ fn gix_status(r: &Repo, ignored: &IgnoredNames) -> IdeResult<Entries> {
|
||||
}
|
||||
}
|
||||
}
|
||||
// Gitoxide's index writer omits resolve-undo data. Keep those saved conflicts.
|
||||
// Serialize write-back and identity capture with watcher queries.
|
||||
if let Some(mut outcome) = iter.into_outcome()
|
||||
&& outcome.has_changes()
|
||||
&& outcome.worktree_index.resolve_undo().is_none()
|
||||
{
|
||||
let mut writes = crate::index_writes::lock();
|
||||
// Another process rewrote the index while this status run was reading it
|
||||
|
||||
@@ -1,182 +0,0 @@
|
||||
//! Operations on the commits recorded for submodules.
|
||||
|
||||
use crate::{Repo, cli, preserve, repo::gx};
|
||||
use gix::bstr::{BStr, ByteSlice};
|
||||
use gix::index::entry::Stage;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, specta::Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum SubmoduleRollbackSource {
|
||||
Head,
|
||||
Index,
|
||||
}
|
||||
|
||||
impl Repo {
|
||||
pub(crate) fn submodule_links(&self) -> IdeResult<Vec<(PathBuf, gix::ObjectId)>> {
|
||||
let repo = self.gix()?;
|
||||
let Some(modules) = repo.submodules().map_err(gx)? else { return Ok(Vec::new()) };
|
||||
let index = repo.index_or_empty().map_err(gx)?;
|
||||
let mut links = Vec::new();
|
||||
for module in modules {
|
||||
let raw = module.path().map_err(gx)?;
|
||||
let Ok(name) = raw.to_str() else { continue };
|
||||
let path = Path::new(name);
|
||||
if name.is_empty() || !path.components().all(|part| matches!(part, Component::Normal(_))) {
|
||||
continue;
|
||||
}
|
||||
if let Some(entry) = index.entry_by_path_and_stage(BStr::new(name.as_bytes()), Stage::Unconflicted)
|
||||
&& entry.mode.is_submodule()
|
||||
{
|
||||
links.push((path.to_path_buf(), entry.id));
|
||||
}
|
||||
}
|
||||
Ok(links)
|
||||
}
|
||||
|
||||
pub(crate) fn initialized_submodule(&self, rel: &Path) -> Option<PathBuf> {
|
||||
let path = self.root().join(rel);
|
||||
if !path.join(".git").exists() {
|
||||
return None;
|
||||
}
|
||||
let root = dunce::canonicalize(self.root()).ok()?;
|
||||
(dunce::canonicalize(&path).ok()?.strip_prefix(root).ok()? == rel).then_some(path)
|
||||
}
|
||||
|
||||
pub(crate) fn initialized_submodules(&self) -> IdeResult<Vec<PathBuf>> {
|
||||
Ok(self.submodule_links()?.into_iter().filter_map(|(rel, _)| self.initialized_submodule(&rel)).collect())
|
||||
}
|
||||
|
||||
/// Restores the parent index, an initialized checkout, or a missing submodule directory.
|
||||
pub fn rollback_submodule(
|
||||
&self,
|
||||
path: &Path,
|
||||
source: SubmoduleRollbackSource,
|
||||
restore_checkout: bool,
|
||||
) -> IdeResult<()> {
|
||||
let _scope = self.execution_scope();
|
||||
if !crate::execution_allowed() {
|
||||
return Err(IdeError::invalid("Submodule rollback requires a trusted project"));
|
||||
}
|
||||
let rel = self.rel_path(path)?;
|
||||
let index = self.diff_entry_at(path, ":0")?;
|
||||
let head = if source == SubmoduleRollbackSource::Head { self.head()?.1 } else { None };
|
||||
let recorded = head.as_deref().map(|rev| self.diff_entry_at(path, rev)).transpose()?.flatten();
|
||||
let index_commit = index.as_ref().and_then(|entry| entry.gitlink.as_deref());
|
||||
let target = match source {
|
||||
SubmoduleRollbackSource::Head => recorded.as_ref().and_then(|entry| entry.gitlink.as_deref()),
|
||||
SubmoduleRollbackSource::Index => index_commit,
|
||||
};
|
||||
if target.is_none() && (source != SubmoduleRollbackSource::Head || index_commit.is_none()) {
|
||||
return Err(IdeError::invalid(format!("{rel} is no longer a submodule change")));
|
||||
}
|
||||
let reset_index = source == SubmoduleRollbackSource::Head && target != index_commit;
|
||||
if restore_checkout && let Some(target) = target {
|
||||
let checkout = self.root().join(&rel);
|
||||
let child = self
|
||||
.initialized_submodule(Path::new(&rel))
|
||||
.and_then(|root| Self::discover(&root).ok().flatten().filter(|repo| repo.root() == root));
|
||||
if let Some(child) = child {
|
||||
child.set_execution_allowed(true);
|
||||
if child.head()?.1.as_deref() != Some(target) {
|
||||
if child.operation()?.is_some() || !crate::write::unmerged_paths(&child)?.is_empty() {
|
||||
return Err(IdeError::invalid(
|
||||
"Finish the Git operation in the submodule before rolling it back",
|
||||
));
|
||||
}
|
||||
// A normal checkout lets Git carry edits across or refuse an overwrite. Nested
|
||||
// submodules are separate changes in the parent Commit tree.
|
||||
cli::run(child.root(), &["checkout", "--no-recurse-submodules", "--detach", target, "--"], None)?;
|
||||
}
|
||||
} else if std::fs::symlink_metadata(checkout)
|
||||
.is_err_and(|error| error.kind() == std::io::ErrorKind::NotFound)
|
||||
{
|
||||
let mut args = vec!["--literal-pathspecs", "restore", "--worktree", "--no-recurse-submodules"];
|
||||
if let Some(rev) = head.as_deref() {
|
||||
args.extend(["--source", rev]);
|
||||
}
|
||||
args.extend(["--", &rel]);
|
||||
cli::run(self.root(), &args, None)?;
|
||||
} else if !reset_index {
|
||||
return Err(IdeError::invalid(format!("Submodule checkout is unavailable for {rel}")));
|
||||
}
|
||||
}
|
||||
if reset_index {
|
||||
if let Some(head) = head {
|
||||
cli::run(
|
||||
self.root(),
|
||||
&[
|
||||
"--literal-pathspecs",
|
||||
"restore",
|
||||
"--staged",
|
||||
"--no-recurse-submodules",
|
||||
"--source",
|
||||
&head,
|
||||
"--",
|
||||
&rel,
|
||||
],
|
||||
None,
|
||||
)?;
|
||||
} else {
|
||||
crate::write::unstage(self, std::slice::from_ref(&path.to_path_buf()))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Updates a single detached checkout. The caller visits every child in parent-first order
|
||||
/// so Git does not switch checked-out branches or bypass protection in nested worktrees.
|
||||
pub fn update_from_superproject(
|
||||
&self,
|
||||
parent: &Repo,
|
||||
cancel: &CancellationToken,
|
||||
on_output: &dyn Fn(String),
|
||||
) -> IdeResult<()> {
|
||||
// The superproject's git runs it; the submodule can only restrict what it may do.
|
||||
let _parent = parent.execution_scope();
|
||||
let _scope = self.execution_scope();
|
||||
if !crate::execution_allowed() {
|
||||
return Err(IdeError::invalid("Submodule update requires a trusted project"));
|
||||
}
|
||||
let relative = self
|
||||
.root()
|
||||
.strip_prefix(parent.root())
|
||||
.map_err(|_| IdeError::invalid("The submodule is outside its parent repository"))?;
|
||||
let Some((_, target)) = parent.submodule_links()?.into_iter().find(|(path, _)| path == relative) else {
|
||||
return Ok(());
|
||||
};
|
||||
if !parent.initialized_submodules()?.iter().any(|path| path == self.root()) {
|
||||
return Err(IdeError::invalid("The submodule worktree is no longer available"));
|
||||
}
|
||||
let (branch, head) = self.head()?;
|
||||
if branch.is_some() {
|
||||
return Err(IdeError::invalid("The submodule is now on a branch. Update it again to use its upstream."));
|
||||
}
|
||||
if head.as_deref() == Some(target.to_string().as_str()) {
|
||||
return Ok(());
|
||||
}
|
||||
if parent.operation()?.is_some() || !crate::write::unmerged_paths(parent)?.is_empty() {
|
||||
return Err(IdeError::invalid(
|
||||
"Finish the Git operation in the parent repository before updating its submodule",
|
||||
));
|
||||
}
|
||||
if self.operation()?.is_some() || !crate::write::unmerged_paths(self)?.is_empty() {
|
||||
return Err(IdeError::invalid("Finish the Git operation in the submodule before updating it"));
|
||||
}
|
||||
let path = ide_core::ipc_path::to_ipc(relative);
|
||||
preserve::around(self, "Local changes saved before update", || {
|
||||
if self.head()?.0.is_some() {
|
||||
return Err(IdeError::invalid(
|
||||
"The submodule is now on a branch. Update it again to use its upstream.",
|
||||
));
|
||||
}
|
||||
cli::run_streaming(
|
||||
parent.root(),
|
||||
&["-c", "submodule.recurse=false", "--literal-pathspecs", "submodule", "update", "--", &path],
|
||||
cancel,
|
||||
on_output,
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
use crate::Repo;
|
||||
use crate::cli::run;
|
||||
use crate::ignore::is_link;
|
||||
use crate::repo::{gx, tree_of};
|
||||
use gix::bstr::BStr;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::fs;
|
||||
use std::io::{self, ErrorKind};
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
const INCLUDE: &str = ".worktreeinclude";
|
||||
|
||||
impl Repo {
|
||||
/// The worktree's include file path and whether it is a regular file on disk.
|
||||
pub fn worktree_include(&self) -> IdeResult<(PathBuf, bool)> {
|
||||
let path = self.root().join(INCLUDE);
|
||||
match fs::symlink_metadata(&path) {
|
||||
Ok(meta) if meta.is_file() && !is_link(&meta) => Ok((path, true)),
|
||||
Ok(_) => Err(IdeError::invalid(".worktreeinclude is not a regular file")),
|
||||
Err(error) if error.kind() == ErrorKind::NotFound => Ok((path, false)),
|
||||
Err(error) => Err(error.into()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Copies local files listed in the source worktree's .worktreeinclude after checkout.
|
||||
pub fn copy_worktree_config(&self, target: &Path) -> IdeResult<()> {
|
||||
if !self.worktree_include()?.1 {
|
||||
return Ok(());
|
||||
}
|
||||
let root = self.root();
|
||||
let _scope = self.execution_scope();
|
||||
let matches = run(
|
||||
root,
|
||||
&["ls-files", "-z", "--cached", "--others", "--ignored", "--exclude-from=.worktreeinclude"],
|
||||
None,
|
||||
)?;
|
||||
let repo = self.gix()?;
|
||||
let head = tree_of(&repo, "HEAD")?;
|
||||
let target = root.join(target);
|
||||
let meta = fs::symlink_metadata(&target)?;
|
||||
if !meta.is_dir() || is_link(&meta) {
|
||||
return Err(IdeError::invalid("worktree location is not a regular directory"));
|
||||
}
|
||||
let mut failures = Vec::new();
|
||||
for raw in matches.stdout.split(|&byte| byte == 0).filter(|path| !path.is_empty()) {
|
||||
let rel = gix::path::from_bstr(BStr::new(raw)).map_err(gx)?;
|
||||
if rel
|
||||
.components()
|
||||
.any(|part| !matches!(part, Component::Normal(name) if !name.eq_ignore_ascii_case(".git")))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if let Some(tree) = &head
|
||||
&& tree.lookup_entry_by_path(&rel).map_err(gx)?.is_some()
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if let Err(error) = copy_local_file(root, &target, &rel) {
|
||||
failures.push(format!("{}: {error}", rel.display()));
|
||||
}
|
||||
}
|
||||
if failures.is_empty() { Ok(()) } else { Err(IdeError::invalid(failures.join("\n"))) }
|
||||
}
|
||||
}
|
||||
|
||||
fn ordinary_directories(root: &Path, relative: &Path, create: bool) -> io::Result<PathBuf> {
|
||||
let mut path = root.to_path_buf();
|
||||
for part in relative.components() {
|
||||
path.push(part);
|
||||
match fs::symlink_metadata(&path) {
|
||||
Ok(meta) if meta.is_dir() && !is_link(&meta) => {}
|
||||
Ok(_) => return Err(io::Error::new(ErrorKind::AlreadyExists, "path is not a regular directory")),
|
||||
Err(error) if create && error.kind() == ErrorKind::NotFound => fs::create_dir(&path)?,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
fn copy_local_file(source: &Path, target: &Path, relative: &Path) -> io::Result<()> {
|
||||
let source_file = source.join(relative);
|
||||
let meta = match fs::symlink_metadata(&source_file) {
|
||||
Ok(meta) if meta.is_file() && !is_link(&meta) => meta,
|
||||
Ok(_) => return Ok(()),
|
||||
Err(error) if error.kind() == ErrorKind::NotFound => return Ok(()),
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let dir = relative.parent().unwrap_or(Path::new(""));
|
||||
ordinary_directories(source, dir, false)?;
|
||||
let destination = target.join(relative);
|
||||
match fs::symlink_metadata(&destination) {
|
||||
Ok(_) => return Ok(()),
|
||||
Err(error) if error.kind() == ErrorKind::NotFound => {}
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
let mut temporary = tempfile::NamedTempFile::new_in(ordinary_directories(target, dir, true)?)?;
|
||||
io::copy(&mut fs::File::open(source_file)?, &mut temporary)?;
|
||||
temporary.as_file().set_permissions(meta.permissions())?;
|
||||
match temporary.persist_noclobber(destination) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(error) if error.error.kind() == ErrorKind::AlreadyExists => Ok(()),
|
||||
Err(error) => Err(error.error),
|
||||
}
|
||||
}
|
||||
+334
-1320
File diff suppressed because it is too large.
Load diff
@@ -1,6 +1,5 @@
|
||||
//! Git Annotate handles ignored commits and attribution options.
|
||||
//! Annotate skips the commits listed in `blame.ignoreRevsFile`.
|
||||
|
||||
use ide_core::workflow_settings::{GitAnnotateMovement, GitAnnotateSettings};
|
||||
use ide_vcs::Repo;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
@@ -130,50 +129,3 @@ fn ignoring_a_commit_adds_it_to_the_configured_list() {
|
||||
let blamed = commits(&fx.repo(), &fx.path("file.txt"));
|
||||
assert_ne!(blamed[1], second);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn annotate_tracks_whitespace_and_line_movement() {
|
||||
let fx = Fixture::new();
|
||||
let source = "original café.txt";
|
||||
let within = "Move this existing line below a larger block of unchanged lines";
|
||||
let across = "Move this line into a different file within the same repository";
|
||||
let anchors = "retain line 1\nretain line 2\nretain line 3\nretain line 4\nretain line 5\nretain line 6\n";
|
||||
fx.write("spaces.txt", "this line is only indented later\n");
|
||||
fx.write("target.txt", &format!("{within}\n{anchors}"));
|
||||
fx.write(source, &format!("{across}\nretain source line\n"));
|
||||
let first = fx.commit_all("original files");
|
||||
fx.write("spaces.txt", " this line is only indented later\n");
|
||||
fx.write("target.txt", &format!("{anchors}{within}\n{across}\n"));
|
||||
fx.write(source, "retain source line\n");
|
||||
let second = fx.commit_all("move and indent lines");
|
||||
|
||||
for repo in [fx.repo(), fx.restricted()] {
|
||||
let blame = |path: &str, text: Option<&str>, ignore_whitespace, movement| {
|
||||
repo.blame_with_options(
|
||||
&fx.path(path),
|
||||
text,
|
||||
None,
|
||||
encoding_rs::UTF_8.into(),
|
||||
GitAnnotateSettings { ignore_whitespace, movement },
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
use GitAnnotateMovement::{AcrossFiles, WithinFile};
|
||||
assert_eq!(blame("spaces.txt", None, true, GitAnnotateMovement::None)[0].commit, first);
|
||||
assert_eq!(blame("spaces.txt", None, false, GitAnnotateMovement::None)[0].commit, second);
|
||||
assert_eq!(
|
||||
blame("spaces.txt", Some("\tthis line is only indented later\n"), true, GitAnnotateMovement::None)[0]
|
||||
.commit,
|
||||
first
|
||||
);
|
||||
let unchanged = blame("target.txt", None, true, GitAnnotateMovement::None);
|
||||
let moved = blame("target.txt", None, true, WithinFile);
|
||||
let copied = blame("target.txt", None, true, AcrossFiles);
|
||||
let commits = |lines: &[ide_vcs::BlameLine]| [lines[6].commit.clone(), lines[7].commit.clone()];
|
||||
assert_eq!(commits(&unchanged), [second.clone(), second.clone()]);
|
||||
assert_eq!(commits(&moved), [first.clone(), second.clone()]);
|
||||
assert_eq!(commits(&copied), [first.clone(), first.clone()]);
|
||||
assert!(copied[6].origin_path.is_none());
|
||||
assert!(copied[7].origin_path.as_ref().unwrap().0.ends_with(source));
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
Loaded 100 of 620 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user