159a1eb
use std::path::{Path, PathBuf};
use crate::command::cmd::Cmd;
use crate::command::env::Env;
use crate::command::error::CmdError;
use crate::commit::types::{
CommitInfo, CommitShortStat, CommitStats, ListCommitsOptions, Signature, TreeEntry,
TreeEntryMode,
};
use crate::error::BabyError;
use crate::share;
pub const LOG_FORMAT: &str = "%H%x00%T%x00%P%x00%an%x00%ae%x00%at%x00%cn%x00%ce%x00%ct%x00%s%x00%b";
pub const CALLER: &str = "gitbaby::commit";
pub struct StderrCtx<'a> {
pub revision: &'a str,
pub path: Option<&'a Path>,
}
pub fn validate_revision(rev: &str) -> Result<(), BabyError> {
share::validate_revision(rev)
}
pub fn validate_path_local_no_escape(path: &Path) -> Result<(), BabyError> {
share::validate_local_no_escape(path)
}
pub fn validate_list_commits_options(opts: &ListCommitsOptions) -> Result<(), BabyError> {
validate_revision(&opts.revision)?;
if let Some(p) = opts.path.as_deref() {
validate_path_local_no_escape(p)?;
}
Ok(())
}
pub fn build_env(alternates: &[PathBuf]) -> Env {
share::build_env_safe(alternates)
}
pub fn build_get_commit_cmd(dir: &Path, env: Env, rev: &str) -> Cmd {
let args = vec!["cat-file".to_string(), "-p".to_string(), rev.to_string()];
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_rev_parse_cmd(dir: &Path, env: Env, rev: &str) -> Cmd {
let args = vec![
"rev-parse".to_string(),
"--verify".to_string(),
"--end-of-options".to_string(),
format!("{}^{{commit}}", rev),
];
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_is_ancestor_cmd(dir: &Path, env: Env, ancestor: &str, descendant: &str) -> Cmd {
let args = vec![
"merge-base".to_string(),
"--is-ancestor".to_string(),
ancestor.to_string(),
descendant.to_string(),
];
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_list_commits_cmd(dir: &Path, env: Env, opts: &ListCommitsOptions) -> Cmd {
let mut args: Vec<String> = Vec::with_capacity(8);
args.push("-c".to_string());
args.push("core.quotepath=off".to_string());
args.push("log".to_string());
args.push("-z".to_string());
args.push(format!("--format={}", LOG_FORMAT));
if let Some(n) = opts.max_count {
args.push(format!("-n{}", n));
}
if let Some(n) = opts.skip {
args.push(format!("--skip={}", n));
}
if let Some(s) = opts.since.as_deref() {
args.push(format!("--since={}", s));
}
if let Some(u) = opts.until.as_deref() {
args.push(format!("--until={}", u));
}
if opts.first_parent {
args.push("--first-parent".to_string());
}
if !opts.revision.is_empty() {
args.push(opts.revision.clone());
}
if let Some(p) = opts.path.as_deref() {
args.push("--".to_string());
args.push(p.to_string_lossy().into_owned());
}
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_count_commits_cmd(dir: &Path, env: Env, opts: &ListCommitsOptions) -> Cmd {
let mut args: Vec<String> = Vec::with_capacity(8);
args.push("rev-list".to_string());
args.push("--count".to_string());
if let Some(s) = opts.since.as_deref() {
args.push(format!("--since={}", s));
}
if let Some(u) = opts.until.as_deref() {
args.push(format!("--until={}", u));
}
if opts.first_parent {
args.push("--first-parent".to_string());
}
if !opts.revision.is_empty() {
args.push(opts.revision.clone());
}
if let Some(p) = opts.path.as_deref() {
args.push("--".to_string());
args.push(p.to_string_lossy().into_owned());
}
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_commit_stats_cmd(dir: &Path, env: Env, rev: &str, path: Option<&Path>) -> Cmd {
let mut args: Vec<String> = Vec::with_capacity(4);
args.push("diff".to_string());
args.push("--shortstat".to_string());
args.push(format!("{}^!", rev));
if let Some(p) = path {
args.push("--".to_string());
args.push(p.to_string_lossy().into_owned());
}
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_commit_short_stats_cmd(dir: &Path, env: Env, rev: &str) -> Cmd {
let args = vec![
"-c".to_string(),
"core.quotepath=off".to_string(),
"log".to_string(),
"--shortstat".to_string(),
"--format=__GDCOMMIT__%H%x00%an%x00%ae%x00".to_string(),
rev.to_string(),
];
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_tree_entries_cmd(dir: &Path, env: Env, rev: &str, path: &Path) -> Cmd {
let mut args = vec!["ls-tree".to_string(), "-l".to_string(), rev.to_string()];
let path_str = path.to_string_lossy();
if !path_str.is_empty() && path_str != "." {
args.push("--".to_string());
args.push(format!("{}/", path_str.trim_end_matches('/')));
}
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn build_last_commit_for_path_cmd(dir: &Path, env: Env, rev: &str, path: &Path) -> Cmd {
let args = vec![
"-c".to_string(),
"core.quotepath=off".to_string(),
"log".to_string(),
"-1".to_string(),
format!("--format={}", LOG_FORMAT),
rev.to_string(),
"--".to_string(),
path.to_string_lossy().into_owned(),
];
share::git_cmd(CALLER, dir, env, None, args)
}
pub fn classify_stderr(stderr: &str, ctx: &StderrCtx<'_>) -> BabyError {
let trimmed = stderr.trim();
if let Some(rest) = trimmed.strip_prefix("fatal: ambiguous argument '")
&& let Some(needle) =
rest.strip_suffix("': unknown revision or path not in the working tree.")
{
return BabyError::RevisionNotFound(needle.to_string());
}
if trimmed.contains("Needed a single revision") {
return BabyError::RevisionNotFound(ctx.revision.to_string());
}
if let Some(rest) = trimmed.strip_prefix("fatal: Not a tree: ") {
return BabyError::NotATree {
revision: rest.trim().to_string(),
path: ctx.path.map_or(PathBuf::new(), |p| p.to_path_buf()),
};
}
if trimmed.contains("bad revision") || trimmed.contains("unknown revision") {
let mut iter = trimmed
.split_whitespace()
.filter(|w| !w.starts_with("fatal:"));
let rev = match iter.next() {
Some(w) => w.trim_matches('\'').to_string(),
None => String::new(),
};
if rev.is_empty() {
return BabyError::RevisionNotFound(ctx.revision.to_string());
}
return BabyError::RevisionNotFound(rev);
}
if let Some(rest) = trimmed.strip_prefix("fatal: not a tree object ") {
return BabyError::NotATree {
revision: rest.trim().to_string(),
path: ctx.path.map_or(PathBuf::new(), |p| p.to_path_buf()),
};
}
if let Some(rest) = trimmed.strip_prefix("fatal: not a commit: ") {
return BabyError::RevisionInvalid(rest.trim().to_string());
}
BabyError::Spawn {
prog: "git".to_string(),
source: std::io::Error::other("git non-zero exit"),
stderr: trimmed.to_string(),
}
}
pub fn classify_cmd_error(err: CmdError, ctx: &StderrCtx<'_>) -> BabyError {
match err {
CmdError::NonZeroExit { stderr, .. } => classify_stderr(&stderr, ctx),
CmdError::Spawn { prog, source } => share::classify_spawn_error(prog, source),
other => BabyError::from(other),
}
}
pub fn facade_error<E: std::error::Error + Send + Sync + 'static>(e: E) -> BabyError {
share::facade_error(e)
}
pub fn parse_signature_line(line: &str) -> Result<Signature, BabyError> {
let lt_idx = line.rfind(" <").ok_or_else(|| BabyError::CommitParse {
line_number: 0,
message: format!("missing `<` in signature: {}", line),
})?;
let gt_idx = line.rfind('>').ok_or_else(|| BabyError::CommitParse {
line_number: 0,
message: format!("missing `>` in signature: {}", line),
})?;
if gt_idx <= lt_idx {
return Err(BabyError::CommitParse {
line_number: 0,
message: format!("malformed signature delimiters: {}", line),
});
}
let name_raw = line[..lt_idx].trim().to_string();
let name = if let Some(stripped) = name_raw.strip_prefix('"').and_then(|s| s.strip_suffix('"'))
{
unescape_quoted_name(stripped)
} else {
name_raw
};
let email = line[lt_idx + 2..gt_idx].trim().to_string();
let tail = line[gt_idx + 1..].trim();
let mut parts = tail.split_whitespace();
let ts_str = parts.next().ok_or_else(|| BabyError::CommitParse {
line_number: 0,
message: format!("missing timestamp in signature: {}", line),
})?;
let tz_str = parts.next().ok_or_else(|| BabyError::CommitParse {
line_number: 0,
message: format!("missing timezone in signature: {}", line),
})?;
let unix: i64 = ts_str
.parse()
.map_err(|_| BabyError::InvalidTimestamp(ts_str.to_string()))?;
let offset = parse_offset(tz_str)?;
let time = time::OffsetDateTime::from_unix_timestamp(unix)
.map_err(|_| BabyError::InvalidTimestamp(ts_str.to_string()))?
.to_offset(offset);
Ok(Signature { name, email, time })
}
fn unescape_quoted_name(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut chars = s.chars();
while let Some(c) = chars.next() {
if c == '\\' {
if let Some(next) = chars.next() {
match next {
'n' => out.push('\n'),
't' => out.push('\t'),
'\\' => out.push('\\'),
'"' => out.push('"'),
other => {
out.push('\\');
out.push(other);
}
}
} else {
out.push('\\');
}
} else {
out.push(c);
}
}
out
}
fn parse_offset(s: &str) -> Result<time::UtcOffset, BabyError> {
let bytes = s.as_bytes();
if bytes.len() != 5 || (bytes[0] != b'+' && bytes[0] != b'-') {
return Err(BabyError::InvalidTimestamp(format!("offset {}", s)));
}
let sign = if bytes[0] == b'-' { -1 } else { 1 };
let hours: i32 = std::str::from_utf8(&bytes[1..3])
.map_err(|_| BabyError::InvalidTimestamp(s.to_string()))?
.parse()
.map_err(|_| BabyError::InvalidTimestamp(s.to_string()))?;
let mins: i32 = std::str::from_utf8(&bytes[3..5])
.map_err(|_| BabyError::InvalidTimestamp(s.to_string()))?
.parse()
.map_err(|_| BabyError::InvalidTimestamp(s.to_string()))?;
let total_seconds = sign * (hours * 3600 + mins * 60);
time::UtcOffset::from_whole_seconds(total_seconds)
.map_err(|_| BabyError::InvalidTimestamp(s.to_string()))
}
pub fn parse_commit_porcelain(id: gix::ObjectId, bytes: &[u8]) -> Result<CommitInfo, BabyError> {
let text = std::str::from_utf8(bytes).map_err(|source| BabyError::CommitParse {
line_number: 0,
message: format!("commit porcelain is not utf-8: {}", source),
})?;
let mut tree_id: Option<gix::ObjectId> = None;
let mut parents: Vec<gix::ObjectId> = Vec::new();
let mut author: Option<Signature> = None;
let mut committer: Option<Signature> = None;
let mut gpg_signature: Option<String> = None;
let mut message_lines: Vec<String> = Vec::new();
let mut in_message = false;
for (idx, line) in text.lines().enumerate() {
let line_no = idx as u64 + 1;
if in_message {
message_lines.push(line.to_string());
continue;
}
if line.is_empty() {
in_message = true;
continue;
}
if let Some(rest) = line.strip_prefix("tree ") {
tree_id = Some(parse_object_id_field(rest, line_no, "tree")?);
continue;
}
if let Some(rest) = line.strip_prefix("parent ") {
parents.push(parse_object_id_field(rest, line_no, "parent")?);
continue;
}
if let Some(rest) = line.strip_prefix("author ") {
author = Some(
parse_signature_line(rest).map_err(|_| BabyError::CommitParse {
line_number: line_no,
message: format!("bad author: {}", rest),
})?,
);
continue;
}
if let Some(rest) = line.strip_prefix("committer ") {
committer = Some(
parse_signature_line(rest).map_err(|_| BabyError::CommitParse {
line_number: line_no,
message: format!("bad committer: {}", rest),
})?,
);
continue;
}
if let Some(rest) = line.strip_prefix("gpgsig ") {
gpg_signature = Some(rest.trim_start().trim_end_matches('\r').to_string());
continue;
}
if line.starts_with(' ') && gpg_signature.is_some() {
if let Some(sig) = gpg_signature.as_mut() {
sig.push('\n');
sig.push_str(line.trim_start());
}
continue;
}
return Err(BabyError::CommitParse {
line_number: line_no,
message: format!("unexpected header line: {}", line),
});
}
let tree_id = tree_id.ok_or_else(|| BabyError::CommitParse {
line_number: 0,
message: "commit porcelain missing tree".into(),
})?;
let author = author.ok_or_else(|| BabyError::CommitParse {
line_number: 0,
message: "commit porcelain missing author".into(),
})?;
let committer = committer.ok_or_else(|| BabyError::CommitParse {
line_number: 0,
message: "commit porcelain missing committer".into(),
})?;
let message = if message_lines.is_empty() {
String::new()
} else {
let trimmed_start = message_lines
.iter()
.position(|l| !l.is_empty())
.unwrap_or(message_lines.len());
let mut lines = message_lines[trimmed_start..].to_vec();
while lines.last().is_some_and(|l| l.is_empty()) {
lines.pop();
}
lines.join("\n")
};
Ok(CommitInfo {
id,
tree_id,
parents,
author,
committer,
message,
gpg_signature,
})
}
fn parse_object_id_field(s: &str, line_no: u64, field: &str) -> Result<gix::ObjectId, BabyError> {
let hex = s.trim();
gix::ObjectId::from_hex(hex.as_bytes()).map_err(|source| BabyError::CommitParse {
line_number: line_no,
message: format!("bad {} oid `{}`: {}", field, hex, source),
})
}
pub fn parse_log_porcelain(bytes: &[u8]) -> Result<Vec<CommitInfo>, BabyError> {
let mut chunks: Vec<&[u8]> = bytes.split(|b| *b == 0).collect();
if chunks.last().is_some_and(|c| c.is_empty()) {
chunks.pop();
}
fn parse_field<'a>(f: &'a [u8], what: &str) -> Result<&'a str, BabyError> {
std::str::from_utf8(f).map_err(|source| BabyError::CommitParse {
line_number: 0,
message: format!("{} not utf-8: {}", what, source),
})
}
fn parse_unix(s: &str) -> Result<time::OffsetDateTime, BabyError> {
let unix: i64 = s
.parse()
.map_err(|_| BabyError::InvalidTimestamp(s.to_string()))?;
time::OffsetDateTime::from_unix_timestamp(unix)
.map(|t| t.to_offset(time::UtcOffset::UTC))
.map_err(|_| BabyError::InvalidTimestamp(s.to_string()))
}
let mut commits = Vec::with_capacity(chunks.len() / 11);
for fields in chunks.as_chunks::<11>().0 {
let id = gix::ObjectId::from_hex(fields[0]).map_err(|source| BabyError::CommitParse {
line_number: 0,
message: format!("bad id: {}", source),
})?;
let tree_id =
gix::ObjectId::from_hex(fields[1]).map_err(|source| BabyError::CommitParse {
line_number: 0,
message: format!("bad tree: {}", source),
})?;
let mut parents = Vec::new();
if !fields[2].is_empty() {
for hex in fields[2].split(|b| *b == b' ') {
if hex.is_empty() {
continue;
}
let p = gix::ObjectId::from_hex(hex).map_err(|source| BabyError::CommitParse {
line_number: 0,
message: format!("bad parent: {}", source),
})?;
parents.push(p);
}
}
let author = Signature {
name: parse_field(fields[3], "author name")?.to_string(),
email: parse_field(fields[4], "author email")?.to_string(),
time: parse_unix(parse_field(fields[5], "author time")?)?,
};
let committer = Signature {
name: parse_field(fields[6], "committer name")?.to_string(),
email: parse_field(fields[7], "committer email")?.to_string(),
time: parse_unix(parse_field(fields[8], "committer time")?)?,
};
let subject = parse_field(fields[9], "subject")?.to_string();
let body = parse_field(fields[10], "body")?
.trim_end_matches('\n')
.to_string();
let message = if body.is_empty() {
subject
} else {
format!("{}\n\n{}", subject, body)
};
commits.push(CommitInfo {
id,
tree_id,
parents,
author,
committer,
message,
gpg_signature: None,
});
}
Ok(commits)
}
pub fn parse_tree_entries(bytes: &[u8]) -> Result<Vec<TreeEntry>, BabyError> {
let mut out = Vec::new();
for (idx, line) in bytes.split(|b| *b == b'\n').enumerate() {
if line.is_empty() {
continue;
}
let line_str = std::str::from_utf8(line).map_err(|source| BabyError::CommitParse {
line_number: idx as u64 + 1,
message: format!("tree entry not utf-8: {}", source),
})?;
let mut parts = line_str.splitn(3, ' ');
let mode_str = parts.next().ok_or_else(|| BabyError::CommitParse {
line_number: idx as u64 + 1,
message: format!("tree entry missing mode: {}", line_str),
})?;
let mode =
TreeEntryMode::from_octal_str(mode_str).ok_or_else(|| BabyError::CommitParse {
line_number: idx as u64 + 1,
message: format!("unknown tree mode: {}", mode_str),
})?;
parts.next();
let tail = parts.next().ok_or_else(|| BabyError::CommitParse {
line_number: idx as u64 + 1,
message: format!("tree entry missing tail: {}", line_str),
})?;
let (head, name_field) = tail
.split_once('\t')
.ok_or_else(|| BabyError::CommitParse {
line_number: idx as u64 + 1,
message: format!("tree entry missing name: {}", line_str),
})?;
let oid_hex = head.split_whitespace().next().unwrap_or("");
let oid = gix::ObjectId::from_hex(oid_hex.as_bytes()).map_err(|source| {
BabyError::CommitParse {
line_number: idx as u64 + 1,
message: format!("bad tree oid `{}`: {}", oid_hex, source),
}
})?;
let size = head
.split_whitespace()
.nth(1)
.and_then(|s| s.parse::<u64>().ok());
out.push(TreeEntry {
oid,
name: name_field.to_string(),
mode,
size,
});
}
Ok(out)
}
pub fn parse_shortstat(bytes: &[u8]) -> Result<CommitStats, BabyError> {
let text = std::str::from_utf8(bytes).map_err(|source| BabyError::CommitParse {
line_number: 0,
message: format!("shortstat not utf-8: {}", source),
})?;
let mut stats = CommitStats::default();
for part in text.split_whitespace() {
if let Some(rest) = part.strip_suffix(')') {
if rest.contains("(+)") {
let n: u64 = rest.trim_end_matches("(+)").parse().map_err(|source| {
BabyError::CommitParse {
line_number: 0,
message: format!("bad additions number `{}`: {}", part, source),
}
})?;
stats.additions = n;
continue;
}
if rest.contains("(-)") {
let n: u64 = rest.trim_end_matches("(-)").parse().map_err(|source| {
BabyError::CommitParse {
line_number: 0,
message: format!("bad deletions number `{}`: {}", part, source),
}
})?;
stats.deletions = n;
continue;
}
}
}
Ok(stats)
}
pub fn parse_commit_short_stats(bytes: &[u8]) -> Result<Vec<CommitShortStat>, BabyError> {
let text = std::str::from_utf8(bytes).map_err(|source| BabyError::CommitParse {
line_number: 0,
message: format!("commit shortstat stream not utf-8: {}", source),
})?;
let mut out = Vec::new();
for record in text.split("__GDCOMMIT__").skip(1) {
let mut fields = record.splitn(4, '\0');
let Some(oid_hex) = fields.next() else {
continue;
};
let Some(name) = fields.next() else { continue };
let Some(email) = fields.next() else { continue };
let rest = fields.next().unwrap_or("");
let oid = gix::ObjectId::from_hex(oid_hex.as_bytes()).map_err(|source| {
BabyError::CommitParse {
line_number: 0,
message: format!("bad commit oid `{}`: {}", oid_hex, source),
}
})?;
let (additions, deletions) = shortstat_numbers(rest);
out.push(CommitShortStat {
oid,
author_name: name.to_string(),
author_email: email.to_string(),
additions,
deletions,
});
}
Ok(out)
}
fn shortstat_numbers(rest: &str) -> (u64, u64) {
let mut additions = 0u64;
let mut deletions = 0u64;
let mut prev_num: Option<u64> = None;
for part in rest.split_whitespace() {
if let Ok(n) = part.trim_end_matches(',').parse::<u64>() {
prev_num = Some(n);
continue;
}
let word = part
.trim_end_matches(',')
.trim_end_matches(')')
.trim_end_matches("(+")
.trim_end_matches("(-");
if word == "insertion" || word == "insertions" {
additions = prev_num.unwrap_or(0);
} else if word == "deletion" || word == "deletions" {
deletions = prev_num.unwrap_or(0);
}
}
(additions, deletions)
}