use crate::git::{self, Opts};
use anyhow::{bail, Result};
use serde::Serialize;
const PREFIX: &str = "refs/gct/backup/";
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct Backup {
pub refname: String,
pub oid: String,
pub label: String,
pub when: String,
}
pub fn sanitize_label(label: &str) -> String {
let mut out = String::new();
for ch in label.chars().flat_map(char::to_lowercase) {
if ch.is_ascii_lowercase() || ch.is_ascii_digit() {
out.push(ch);
} else if !out.is_empty() && !out.ends_with('-') {
out.push('-');
}
}
out.truncate(40);
let trimmed = out.trim_matches('-');
if trimmed.is_empty() {
"backup".into()
} else {
trimmed.into()
}
}
pub fn backup(label: &str, rev: &str) -> Result<String> {
let oid = git::git_ok(&["rev-parse", "--verify", "--quiet", rev], &Opts::default())
.ok()
.filter(|oid| !oid.is_empty());
let Some(oid) = oid else {
bail!("cannot back up '{rev}': no such revision");
};
let clean = sanitize_label(label);
let stamp = chrono::Local::now().format("%Y%m%d-%H%M%S");
let message = format!("gct backup: {label}");
let base = format!("{PREFIX}{stamp}-{clean}");
for attempt in 1..=100 {
let refname = if attempt == 1 {
base.clone()
} else {
format!("{base}-{attempt}")
};
let out = git::git_raw(
&["update-ref", "-m", &message, &refname, &oid, ""],
&Opts::default(),
)?;
if out.ok() {
return Ok(refname);
}
let exists = git::git_raw(
&["rev-parse", "--verify", "--quiet", &refname],
&Opts::default(),
)?
.ok();
if !exists {
bail!("could not create backup {refname}: {}", out.stderr.trim());
}
}
bail!("could not find a free backup name for {base}")
}
pub fn backups() -> Result<Vec<Backup>> {
let text = git::git_ok(
&[
"for-each-ref",
"--sort=-refname",
"--format=%(refname)%1f%(objectname)",
"refs/gct/backup/",
],
&Opts::default(),
)?;
Ok(text
.lines()
.filter_map(|line| {
let (refname, oid) = line.split_once('\u{1f}')?;
let name = refname.strip_prefix(PREFIX)?;
let (when, label) = split_stamp(name);
Some(Backup {
refname: refname.into(),
oid: oid.into(),
label,
when,
})
})
.collect())
}
fn split_stamp(name: &str) -> (String, String) {
let stamp_ok = name.len() >= 15
&& name.is_char_boundary(15)
&& name[..8].bytes().all(|b| b.is_ascii_digit())
&& name.as_bytes()[8] == b'-'
&& name[9..15].bytes().all(|b| b.is_ascii_digit());
if !stamp_ok {
return (String::new(), name.into());
}
let n = &name[..15];
let when = format!(
"{}-{}-{} {}:{}:{}",
&n[0..4],
&n[4..6],
&n[6..8],
&n[9..11],
&n[11..13],
&n[13..15]
);
let label = name[15..].trim_start_matches('-').to_string();
(when, label)
}
pub fn delete_backup(refname: &str) -> Result<()> {
if !refname.starts_with(PREFIX) || refname.len() == PREFIX.len() || refname.contains("..") {
bail!("{refname} is not a gct backup");
}
git::git_ok(&["update-ref", "-d", refname], &Opts::default())?;
Ok(())
}
pub fn is_published(rev: &str) -> Result<bool> {
let remotes = git::git_ok(&["remote"], &Opts::default())?;
if remotes.trim().is_empty() {
return Ok(false);
}
let unpushed = git::git_ok(
&["rev-list", "-n1", rev, "--not", "--remotes"],
&Opts::default(),
)?;
Ok(unpushed.is_empty())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testutil::TempRepo;
#[test]
fn sanitizes_labels() {
let (long, x40) = ("x".repeat(60), "x".repeat(40));
let (cut, y39) = (format!("{}-tail", "y".repeat(39)), "y".repeat(39));
let cases = [
("Before Reset --hard!", "before-reset-hard"),
(" ", "backup"),
("ÜBER/main", "ber-main"),
("a__b", "a-b"),
(long.as_str(), x40.as_str()),
(cut.as_str(), y39.as_str()),
];
for (input, expected) in cases {
assert_eq!(sanitize_label(input), expected, "{input}");
}
}
#[test]
fn splits_stamps() {
assert_eq!(
split_stamp("20260102-150405-before-reset-2"),
("2026-01-02 15:04:05".into(), "before-reset-2".into())
);
assert_eq!(split_stamp("odd"), (String::new(), "odd".into()));
}
#[test]
fn backup_list_delete() {
let repo = TempRepo::new(2);
repo.run(|| {
let head = git::run(&["rev-parse", "HEAD"]).unwrap();
let first = backup("Before reset", "HEAD").unwrap();
let second = backup("Before reset", "HEAD~1").unwrap();
assert!(first.starts_with("refs/gct/backup/") && first.ends_with("-before-reset"));
assert_ne!(first, second);
let list = backups().unwrap();
assert_eq!(list.len(), 2);
assert!(list.iter().any(|b| b.refname == first && b.oid == head));
assert!(list
.iter()
.all(|b| b.label.starts_with("before-reset") && b.when.len() == 19));
assert!(list[0].refname >= list[1].refname);
assert!(backup("x", "no-such-rev").is_err());
assert!(delete_backup("refs/heads/main").is_err());
assert!(delete_backup("refs/gct/backup/").is_err());
delete_backup(&first).unwrap();
delete_backup(&second).unwrap();
assert!(backups().unwrap().is_empty());
});
}
#[test]
fn published_needs_a_remote() {
let repo = TempRepo::new(1);
assert!(!repo.run(|| is_published("HEAD")).unwrap());
let repo = repo.with_remote();
assert!(repo.run(|| is_published("HEAD")).unwrap());
repo.write("new.txt", "n\n");
repo.git(&["add", "."]);
repo.git(&["commit", "-q", "-m", "local"]);
assert!(!repo.run(|| is_published("HEAD")).unwrap());
assert!(repo.run(|| is_published("HEAD~1")).unwrap());
}
}