Something went wrong. Try again.
atproto git client
Something went wrong. Try again.
Rust
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308//! The marks a stack is cut at: where one pull request ends and the next//! begins.//!//! A mark is an ordinary local branch pointing at a commit inside//! `base..HEAD`, and it is *recorded* — `atgc stack mark part1 HEAD~3` writes//! the name into the checkout's git config, and only recorded names are read//! back. That indirection is the whole point of this module.//!//! Recorded rather than inferred, because inferring it is wrong in a working//! repository: `git branch backup` before a risky rebase lands in the range//! too, and a stack that silently re-cut itself around it would say nothing.//! `gh stack` reaches the same shape from the other direction — a stack is//! `init`ed and layers `add`ed, never guessed at.//!//! The record is per-branch and multivalued: `branch.<branch>.atgcMark`, in//! the same namespace git keeps `branch.<name>.description` in. It lives in//! `.git/config`, so it is shared with every linked worktree of the repo,//! which is the same rule the identity written by `repo configure` follows.
use crate::clients::git::run as git;use anyhow::{Result, bail};use std::path::Path;
/// The config key holding one stacked branch's marks.fn key(branch: &str) -> String { format!("branch.{branch}.atgcMark")}
/// Every mark recorded for `branch`, in the order they were recorded. Names/// only: whether each still points into the range is the caller's question,/// and a stale one is not an error here.pub(crate) fn recorded(branch: &str) -> Vec<String> { git::git_in( Path::new("."), &["config", "--local", "--get-all", &key(branch)], ) .map(|out| { out.lines() .map(str::trim) .filter(|l| !l.is_empty()) .map(str::to_string) .collect() }) .unwrap_or_default()}
/// Record `mark` as a cut of `branch`, if it is not recorded already.pub(crate) fn record(branch: &str, mark: &str) -> Result<()> { if recorded(branch).iter().any(|m| m == mark) { return Ok(()); } git::git_in( Path::new("."), &["config", "--local", "--add", &key(branch), mark], )?; Ok(())}
/// Forget `mark`, leaving the branch itself alone. Deleting the branch is/// git's to do and somebody else's decision: a mark that is forgotten but/// still exists is exactly the state somebody wants when they are reshaping a/// stack and want the sha kept.pub(crate) fn forget(branch: &str, mark: &str) -> Result<()> { if !recorded(branch).iter().any(|m| m == mark) { bail!("{mark} is not a mark of {branch}; `atgc stack mark` lists the ones that are"); } git::git_in( Path::new("."), &[ "config", "--local", "--unset-all", &key(branch), &format!("^{}$", regex_quote(mark)), ], )?; Ok(())}
/// git's `--unset-all` takes a value *pattern*, so a mark whose name contains/// regex punctuation would unset the wrong thing — or nothing. Only a few/// characters are legal in a branch name to begin with; escaping them all is/// still cheaper than reasoning about which.fn regex_quote(value: &str) -> String { value .chars() .flat_map(|c| { let escape = matches!( c, '.' | '^' | '$' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' ); escape.then_some('\\').into_iter().chain(std::iter::once(c)) }) .collect()}
/// The recorded marks that actually sit in `commits`, as (index, name),/// bottom first — the cut, ready to be turned into members.////// A recorded mark whose branch is gone, or whose tip is outside the range,/// is skipped rather than refused: that is the ordinary state after the/// bottom of a stack merges, and a reconcile that failed there would fail/// exactly when it is most needed.pub(crate) fn positions(branch: &str, commits: &[String]) -> Vec<(usize, String)> { positions_and_stranded(branch, commits).0}
/// The same, and the marks that cut nothing.////// **A mark outside the range is silently not a cut**, and silence there/// changes what a command does without saying so: a stack recorded as two/// grouped members reconciles as one pull request per commit, because the/// mark that grouped them is sitting on a commit the branch no longer has./// `stack mark` reports it when asked; the commands that *act* on the cut/// said nothing, so the shape somebody asked for quietly became a different/// one. A plain `git rebase` without `--update-refs` is the usual cause,/// which is exactly when nobody is thinking about marks.pub(crate) fn positions_and_stranded( branch: &str, commits: &[String],) -> (Vec<(usize, String)>, Vec<String>) { let mut stranded = Vec::new(); for mark in recorded(branch) { let sha = git::git_in( Path::new("."), &[ "rev-parse", "--verify", "--quiet", &format!("refs/heads/{mark}^{{commit}}"), ], ) .ok() .map(|sha| sha.trim().to_string()) .unwrap_or_default(); if sha.is_empty() || !commits.contains(&sha) { stranded.push(mark); } } (positions_inner(branch, commits), stranded)}
fn positions_inner(branch: &str, commits: &[String]) -> Vec<(usize, String)> { let mut found: Vec<(usize, String)> = recorded(branch) .into_iter() .filter_map(|mark| { let sha = git::git_in( Path::new("."), &[ "rev-parse", "--verify", "--quiet", &format!("refs/heads/{mark}^{{commit}}"), ], ) .ok()?; let sha = sha.trim().to_string(); let at = commits.iter().position(|c| *c == sha)?; Some((at, mark)) }) .collect(); found.sort(); found.dedup_by(|a, b| a.0 == b.0); found}
/// Point `mark` at `rev`, creating the branch or moving it, and record it.////// Moving an existing branch is deliberate and is what re-cutting a stack/// looks like — the equivalent of `gh stack modify`'s fold and reorder — so/// it is allowed, and reported, rather than refused.pub(crate) fn place(branch: &str, mark: &str, rev: &str, base: &str) -> Result<Placed> { // The branch being stacked already ends the top member, and git refuses // to force-update a checked-out branch anyway — but it refuses with a // sentence about worktrees that says nothing about stacks, and the // recovery is not obvious from it. if mark == branch { bail!( "{branch} is the branch you are on, and it already ends the top pull request\n\ mark a cut below it with another name: `atgc stack mark part1 HEAD~1`" ); } let target = git::git_in( Path::new("."), &["rev-parse", "--verify", &format!("{rev}^{{commit}}")], )?; let target = target.trim().to_string();
// **A mark cuts the range, so it has to be in it.** `stack mark x // origin/main` was accepted and recorded, and then cut nothing: the cut // is decided by where a mark's commit sits among `base..HEAD`, and a // commit that is not among them has no position. The stack that came out // was the unmarked one, silently, with a branch left behind claiming // otherwise. // // The base is the mark's own branch's upstream — the same `<remote>/<target>` // `stack create` cuts against — so this is checked against the commits // that will actually be planned rather than against `HEAD` alone. if let Ok(range) = git::git_in(Path::new("."), &["rev-list", &format!("{base}..{branch}")]) && !range.lines().any(|sha| sha.trim() == target) { return Err(crate::exit::fail( crate::exit::Exit::Usage, format!( "{rev} is not among the commits {branch} has over {base}, so a mark there \ would cut nothing\n\ a mark takes a revision inside the range being stacked; \ `git log --oneline {base}..{branch}` lists them" ), )); }
// Two marks on one commit end two pull requests at the same place, which // makes one of them empty. Named rather than left to produce a member // with no commits in it. for other in recorded(branch) { if other == mark { continue; } if let Ok(sha) = git::git_in( Path::new("."), &[ "rev-parse", "--verify", "--quiet", &format!("refs/heads/{other}^{{commit}}"), ], ) && sha.trim() == target { return Err(crate::exit::fail( crate::exit::Exit::Usage, format!( "{other} already marks that commit, and two cuts there would leave one \ pull request with no commits in it\n\ `atgc stack mark --forget {other}` drops it, or mark a different commit" ), )); } } let existing = git::git_in( Path::new("."), &[ "rev-parse", "--verify", "--quiet", &format!("refs/heads/{mark}^{{commit}}"), ], ) .ok() .map(|sha| sha.trim().to_string()) .filter(|sha| !sha.is_empty());
let placed = match &existing { Some(sha) if *sha == target => Placed::Kept, Some(sha) => { git::git_in(Path::new("."), &["branch", "--force", mark, &target])?; Placed::Moved { from: sha.clone() } } None => { git::git_in(Path::new("."), &["branch", mark, &target])?; Placed::Created } }; record(branch, mark)?; Ok(placed)}
/// What [`place`] did to the branch behind a mark.#[derive(Debug, PartialEq, Eq)]pub(crate) enum Placed { Created, Moved { from: String }, Kept,}
/// Every branch that records `mark` as one of its cuts.////// The reverse of [`recorded`], and the lookup the navigation verbs need:/// standing on a mark, the stacked branch it belongs to is not derivable/// from the commits — two branches can hold the same commit — so it is read/// back out of the config that recorded it.pub(crate) fn owners_of(mark: &str) -> Vec<String> { git::git_in( Path::new("."), // Lowercase: git normalises the variable half of a key, so this is // the spelling `--get-regexp` both matches and prints, whatever // `record` wrote. &[ "config", "--local", "--get-regexp", r"^branch\..*\.atgcmark$", ], ) .map(|out| { out.lines() .filter_map(|line| line.split_once(' ')) .filter(|(_, value)| value.trim() == mark) .filter_map(|(key, _)| { key.strip_prefix("branch.") .and_then(|rest| rest.strip_suffix(".atgcmark")) }) .map(str::to_string) .collect::<Vec<_>>() }) .unwrap_or_default()}