git-custom-cli 2.4.0

Fast, keyboard-driven terminal UI for dated Git commits
//! Commit log parsing shared by the log, files and compare modes.
//!
//! Run `git log --format=<LOG_FORMAT> ...` (any `git log`/`rev-list --format` call) and feed
//! stdout to `parse_log`. Fields are separated by 0x1f and records end with 0x1e, so subjects
//! with spaces, tabs or unicode survive.

use serde::Serialize;

/// Pass as `--format=` (or `--pretty=format:`).
pub const LOG_FORMAT: &str = "%H%x1f%h%x1f%P%x1f%an%x1f%ae%x1f%aI%x1f%cI%x1f%D%x1f%s%x1e";

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct LogEntry {
    pub oid: String,
    pub short: String,
    /// Empty for a root commit, two or more for a merge.
    pub parents: Vec<String>,
    pub author: String,
    pub email: String,
    /// ISO 8601 (strict), e.g. 2024-01-01T12:01:00+00:00.
    pub author_date: String,
    pub committer_date: String,
    /// Decorations as `%D` prints them, e.g. "HEAD -> main, origin/main, tag: v1".
    pub refs: String,
    pub subject: String,
}

/// Parses output produced with `LOG_FORMAT`. Leading newlines/whitespace between records are
/// ignored; malformed records are skipped; empty input gives an empty list.
pub fn parse_log(text: &str) -> Vec<LogEntry> {
    text.split('\u{1e}')
        .filter_map(|record| {
            // git puts a newline after each record; only strip whitespace before the hash.
            let record = record.trim_start_matches(['\n', '\r', ' ']);
            if record.is_empty() {
                return None;
            }
            let fields: Vec<&str> = record.split('\u{1f}').collect();
            let [oid, short, parents, author, email, author_date, committer_date, refs, subject] =
                fields[..]
            else {
                return None;
            };
            Some(LogEntry {
                oid: oid.trim().into(),
                short: short.into(),
                parents: parents.split_whitespace().map(String::from).collect(),
                author: author.into(),
                email: email.into(),
                author_date: author_date.into(),
                committer_date: committer_date.into(),
                refs: refs.into(),
                subject: subject.into(),
            })
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::testutil::TempRepo;

    fn record(fields: [&str; 9]) -> String {
        format!("{}\u{1e}\n", fields.join("\u{1f}"))
    }

    #[test]
    fn parses_records() {
        let merge = record([
            "a".repeat(40).as_str(),
            "aaaaaaa",
            "b1 c2",
            "Ann",
            "ann@x.io",
            "2024-01-01T12:00:00+00:00",
            "2024-01-02T12:00:00+00:00",
            "HEAD -> main, tag: v1",
            "Merge branch 'dev'",
        ]);
        let root = record(["r", "r", "", "Bob", "b@x", "d1", "d2", "", ""]);
        let unicode = record([
            "u",
            "u",
            "p",
            "Zoë",
            "z@x",
            "d",
            "d",
            "",
            "  fix: ünïcode  spaces \t",
        ]);
        let text = format!("\n\n{merge}{root}{unicode}");
        let entries = parse_log(&text);
        assert_eq!(entries.len(), 3);
        assert_eq!(entries[0].parents, ["b1", "c2"]);
        assert_eq!(entries[0].refs, "HEAD -> main, tag: v1");
        assert_eq!(entries[0].subject, "Merge branch 'dev'");
        assert_eq!(entries[0].author_date, "2024-01-01T12:00:00+00:00");
        assert!(entries[1].parents.is_empty());
        assert_eq!(entries[1].subject, "");
        assert_eq!(entries[2].author, "Zoë");
        assert_eq!(entries[2].subject, "  fix: ünïcode  spaces \t");
        assert!(parse_log("").is_empty());
        assert!(parse_log("\n").is_empty());
        assert!(parse_log("garbage\u{1e}").is_empty());
    }

    #[test]
    fn parses_real_git_log() {
        let repo = TempRepo::new(2);
        let text = repo.git(&["log", &format!("--format={LOG_FORMAT}")]);
        let entries = parse_log(&text);
        assert_eq!(entries.len(), 2);
        assert_eq!(entries[0].subject, "commit 2");
        assert_eq!(entries[0].parents, [entries[1].oid.clone()]);
        assert!(entries[1].parents.is_empty());
        assert!(entries[0].refs.contains("main"));
        assert_eq!(entries[0].email, "test@example.com");
    }
}