git-custom-cli 2.4.0

Fast, keyboard-driven terminal UI for dated Git commits
//! Safety net for destructive operations: backup refs under `refs/gct/backup/` and a check
//! for whether a commit is already on a remote.
//!
//! Call `backup(label, "HEAD")` (or the branch/stash about to be lost) BEFORE any reset --hard,
//! branch -D, stash drop, rebase or amend. Backups are plain refs, so `git log <refname>` and
//! `git reset --hard <refname>` restore them, and they keep the commits alive for gc.

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 {
    /// Full ref name, e.g. refs/gct/backup/20260102-150405-before-reset.
    pub refname: String,
    pub oid: String,
    /// The sanitized label from the ref name.
    pub label: String,
    /// "YYYY-MM-DD HH:MM:SS" (local time the backup was made).
    pub when: String,
}

/// Lowercase, only [a-z0-9-], runs of other characters collapse to one '-', no leading or
/// trailing '-', at most 40 characters; "backup" when nothing is left.
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()
    }
}

/// Saves `rev` as `refs/gct/backup/<YYYYMMDD-HHMMSS>-<label>` (adding -2, -3, ... when that
/// name exists) and returns the ref name.
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}")
        };
        // An empty old value makes update-ref fail if the ref already exists (atomic check).
        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}")
}

/// Every backup, newest first.
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())
}

/// "20260102-150405-before-reset" -> ("2026-01-02 15:04:05", "before-reset").
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)
}

/// Deletes one backup ref. Refuses anything outside refs/gct/backup/.
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(())
}

/// True when `rev` is reachable from some remote-tracking branch (already pushed). With no
/// remotes at all nothing is published, so false.
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));
            // Newest first: the -2 suffix sorts after the plain name within one second.
            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());
    }
}