use std::collections::BTreeSet;
use std::io::{Read, Seek, SeekFrom};
use std::path::{Path, PathBuf};
pub const REFLOG_WINDOW: u64 = 64 * 1024;
pub const MAX_BRANCHES: usize = 1000;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Head {
Branch(String),
Detached,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ReflogLine {
pub message: String,
}
impl ReflogLine {
pub fn checkout(&self) -> Option<(String, String)> {
let rest = self.message.strip_prefix("checkout: moving from ")?;
let (from, to) = rest.rsplit_once(" to ")?;
Some((from.to_owned(), to.to_owned()))
}
pub fn merged_branch(&self) -> Option<String> {
let rest = self.message.strip_prefix("merge ")?;
let (name, how) = rest.rsplit_once(": ")?;
let how = how.trim();
if how == "Fast-forward" || how.starts_with("Merge made by") {
Some(name.to_owned())
} else {
None
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ReflogRead {
pub lines: Vec<ReflogLine>,
pub cursor: u64,
pub reset: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Repo {
pub gitdir: PathBuf,
pub commondir: PathBuf,
}
impl Repo {
pub fn open(root: &Path) -> Option<Repo> {
let dot_git = root.join(".git");
let gitdir = if dot_git.is_dir() {
dot_git
} else {
let text = std::fs::read_to_string(&dot_git).ok()?;
let target = text.trim().strip_prefix("gitdir:")?.trim();
let path = Path::new(target);
if path.is_absolute() {
path.to_path_buf()
} else {
root.join(path)
}
};
if !gitdir.is_dir() {
return None;
}
let commondir = match std::fs::read_to_string(gitdir.join("commondir")) {
Ok(text) => {
let path = Path::new(text.trim());
if path.is_absolute() {
path.to_path_buf()
} else {
gitdir.join(path)
}
}
Err(_) => gitdir.clone(),
};
Some(Repo { gitdir, commondir })
}
pub fn key(&self) -> String {
let canonical = self
.commondir
.canonicalize()
.unwrap_or_else(|_| self.commondir.clone());
canonical.display().to_string().replace('\\', "/")
}
pub fn worktree_key(&self) -> String {
let canonical = self
.gitdir
.canonicalize()
.unwrap_or_else(|_| self.gitdir.clone());
canonical.display().to_string().replace('\\', "/")
}
pub fn head(&self) -> Head {
let Ok(text) = std::fs::read_to_string(self.gitdir.join("HEAD")) else {
return Head::Unknown;
};
let text = text.trim();
if let Some(reference) = text.strip_prefix("ref:") {
return match reference.trim().strip_prefix("refs/heads/") {
Some(name) if !name.is_empty() => Head::Branch(name.to_owned()),
_ => Head::Unknown,
};
}
if looks_like_commit(text) {
return Head::Detached;
}
Head::Unknown
}
pub fn reflog_since(&self, cursor: Option<u64>) -> ReflogRead {
let path = self.gitdir.join("logs").join("HEAD");
let Ok(mut file) = std::fs::File::open(&path) else {
return ReflogRead::default();
};
let len = file.metadata().map(|m| m.len()).unwrap_or(0);
let at_end = |reset| ReflogRead {
lines: Vec::new(),
cursor: len,
reset,
};
let Some(cursor) = cursor else {
return at_end(false);
};
if cursor > len {
return at_end(true);
}
if cursor == len {
return at_end(false);
}
let start = cursor.max(len.saturating_sub(REFLOG_WINDOW));
let mut bytes = Vec::new();
let read = file
.seek(SeekFrom::Start(start))
.and_then(|_| file.take(len - start).read_to_end(&mut bytes));
if read.is_err() {
return at_end(false);
}
let text = String::from_utf8_lossy(&bytes);
let text = if start > cursor {
text.split_once('\n').map_or("", |(_, rest)| rest)
} else {
&text
};
let lines = text
.lines()
.filter_map(parse_reflog_line)
.collect::<Vec<_>>();
ReflogRead {
lines,
cursor: len,
reset: false,
}
}
pub fn came_from(&self, to: &str) -> Option<String> {
let read = self.reflog_since(Some(0));
read.lines
.iter()
.rev()
.find_map(ReflogLine::checkout)
.filter(|(_, moved_to)| moved_to == to)
.map(|(from, _)| from)
.filter(|from| !looks_like_commit(from))
}
pub fn branches(&self) -> BTreeSet<String> {
let mut out = BTreeSet::new();
let heads = self.commondir.join("refs").join("heads");
walk(&heads, &heads, &mut out);
if let Ok(packed) = std::fs::read_to_string(self.commondir.join("packed-refs")) {
for line in packed.lines() {
if line.starts_with('#') || line.starts_with('^') {
continue;
}
if let Some((_, name)) = line.split_once(' ') {
if let Some(short) = name.trim().strip_prefix("refs/heads/") {
if out.len() < MAX_BRANCHES {
out.insert(short.to_owned());
}
}
}
}
}
out
}
}
fn walk(base: &Path, dir: &Path, out: &mut BTreeSet<String>) {
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
let mut entries: Vec<PathBuf> = entries.flatten().map(|e| e.path()).collect();
entries.sort();
for path in entries {
if out.len() >= MAX_BRANCHES {
return;
}
if path.is_dir() {
walk(base, &path, out);
} else if let Ok(rel) = path.strip_prefix(base) {
let name = rel
.components()
.map(|c| c.as_os_str().to_string_lossy().into_owned())
.collect::<Vec<_>>()
.join("/");
if !name.is_empty() && !name.ends_with(".lock") {
out.insert(name);
}
}
}
}
fn parse_reflog_line(line: &str) -> Option<ReflogLine> {
let (_, message) = line.split_once('\t')?;
Some(ReflogLine {
message: message.trim_end().to_owned(),
})
}
fn looks_like_commit(name: &str) -> bool {
name.len() >= 40 && name.bytes().all(|b| b.is_ascii_hexdigit())
}
#[cfg(test)]
mod tests {
use super::*;
const SHA: &str = "3c0a724c98faa8a0e4eb04ac68a48d45dea5c5e2";
fn line(message: &str) -> String {
format!("{SHA} {SHA} t <t@t> 1790098567 +0530\t{message}\n")
}
fn repo(dir: &Path) -> Repo {
let git = dir.join(".git");
std::fs::create_dir_all(git.join("logs")).unwrap();
std::fs::create_dir_all(git.join("refs").join("heads").join("feature")).unwrap();
std::fs::write(git.join("HEAD"), "ref: refs/heads/main\n").unwrap();
std::fs::write(git.join("refs").join("heads").join("main"), SHA).unwrap();
std::fs::write(
git.join("refs").join("heads").join("feature").join("x"),
SHA,
)
.unwrap();
std::fs::write(
git.join("packed-refs"),
format!(
"# pack-refs with: peeled\n{SHA} refs/heads/packed\n{SHA} refs/tags/v1\n^{SHA}\n"
),
)
.unwrap();
std::fs::write(
git.join("logs").join("HEAD"),
line("commit (initial): one") + &line("checkout: moving from main to feature/x"),
)
.unwrap();
Repo::open(dir).unwrap()
}
#[test]
fn head_is_a_branch_a_commit_or_unknown() {
let dir = tempfile::tempdir().unwrap();
let repo = repo(dir.path());
assert_eq!(repo.head(), Head::Branch("main".to_owned()));
std::fs::write(repo.gitdir.join("HEAD"), "ref: refs/heads/feature/x\n").unwrap();
assert_eq!(repo.head(), Head::Branch("feature/x".to_owned()));
std::fs::write(repo.gitdir.join("HEAD"), format!("{SHA}\n")).unwrap();
assert_eq!(repo.head(), Head::Detached);
std::fs::write(repo.gitdir.join("HEAD"), "ref: refs/remotes/origin/main\n").unwrap();
assert_eq!(repo.head(), Head::Unknown);
std::fs::remove_file(repo.gitdir.join("HEAD")).unwrap();
assert_eq!(repo.head(), Head::Unknown);
}
#[test]
fn branches_come_from_loose_refs_and_packed_refs_and_nothing_else() {
let dir = tempfile::tempdir().unwrap();
let repo = repo(dir.path());
let names: Vec<String> = repo.branches().into_iter().collect();
assert_eq!(names, ["feature/x", "main", "packed"]);
}
#[test]
fn the_reflog_is_read_from_a_cursor_and_the_cursor_moves_to_the_end() {
let dir = tempfile::tempdir().unwrap();
let repo = repo(dir.path());
let log = repo.gitdir.join("logs").join("HEAD");
let len = std::fs::metadata(&log).unwrap().len();
let first = repo.reflog_since(None);
assert!(first.lines.is_empty());
assert_eq!(first.cursor, len);
let same = repo.reflog_since(Some(len));
assert!(same.lines.is_empty() && !same.reset);
let mut text = std::fs::read_to_string(&log).unwrap();
text.push_str(&line("merge feature/x: Fast-forward"));
text.push_str(&line("merge other: Merge made by the 'ort' strategy."));
text.push_str(&line("pull: Fast-forward"));
text.push_str(&line("rebase (finish): returning to refs/heads/main"));
std::fs::write(&log, &text).unwrap();
let read = repo.reflog_since(Some(len));
let merged: Vec<String> = read
.lines
.iter()
.filter_map(ReflogLine::merged_branch)
.collect();
assert_eq!(merged, ["feature/x", "other"]);
assert_eq!(read.cursor, text.len() as u64);
assert_eq!(repo.reflog_since(Some(0)).lines.len(), 6);
std::fs::write(&log, line("commit: fresh")).unwrap();
let reset = repo.reflog_since(Some(len));
assert!(reset.reset && reset.lines.is_empty());
assert_eq!(reset.cursor, line("commit: fresh").len() as u64);
}
#[test]
fn only_the_last_window_of_a_long_reflog_is_read() {
let dir = tempfile::tempdir().unwrap();
let repo = repo(dir.path());
let log = repo.gitdir.join("logs").join("HEAD");
let mut text = String::new();
for n in 0..2000 {
text.push_str(&line(&format!("commit: number {n}")));
}
text.push_str(&line("merge late: Fast-forward"));
std::fs::write(&log, &text).unwrap();
assert!(text.len() as u64 > REFLOG_WINDOW);
let read = repo.reflog_since(Some(0));
assert!(read.lines.len() < 2001, "the whole file was read");
assert!(read.lines.iter().any(|l| l.merged_branch().is_some()));
assert!(read
.lines
.first()
.is_some_and(|l| l.message.starts_with("commit: number ")));
}
#[test]
fn where_head_came_from_is_the_newest_checkout_line() {
let dir = tempfile::tempdir().unwrap();
let repo = repo(dir.path());
assert_eq!(repo.came_from("feature/x"), Some("main".to_owned()));
assert_eq!(repo.came_from("main"), None);
let log = repo.gitdir.join("logs").join("HEAD");
let mut text = std::fs::read_to_string(&log).unwrap();
text.push_str(&line(&format!("checkout: moving from {SHA} to main")));
std::fs::write(&log, text).unwrap();
assert_eq!(repo.came_from("main"), None);
}
#[test]
fn a_worktree_has_its_own_head_and_reflog_and_shares_the_refs() {
let dir = tempfile::tempdir().unwrap();
let main = repo(&dir.path().join("main"));
let wt_dir = main.gitdir.join("worktrees").join("wt");
std::fs::create_dir_all(wt_dir.join("logs")).unwrap();
std::fs::write(wt_dir.join("HEAD"), "ref: refs/heads/feature/x\n").unwrap();
std::fs::write(wt_dir.join("commondir"), "../..\n").unwrap();
std::fs::write(
wt_dir.join("logs").join("HEAD"),
line("checkout: moving from main to feature/x"),
)
.unwrap();
let checkout = dir.path().join("wt");
std::fs::create_dir_all(&checkout).unwrap();
std::fs::write(
checkout.join(".git"),
format!("gitdir: {}\n", wt_dir.display()),
)
.unwrap();
let wt = Repo::open(&checkout).unwrap();
assert_eq!(wt.head(), Head::Branch("feature/x".to_owned()));
assert_eq!(main.head(), Head::Branch("main".to_owned()));
assert_eq!(wt.branches(), main.branches());
assert_eq!(wt.key(), main.key());
assert_ne!(wt.worktree_key(), main.worktree_key());
assert_eq!(wt.reflog_since(Some(0)).lines.len(), 1);
}
#[test]
fn a_directory_without_git_is_not_a_repository() {
let dir = tempfile::tempdir().unwrap();
assert!(Repo::open(dir.path()).is_none());
std::fs::write(dir.path().join(".git"), "not a pointer").unwrap();
assert!(Repo::open(dir.path()).is_none());
}
}