use crate::compress::generic::{dedup_consecutive, middle_truncate, GenericCompressor};
use crate::compress::{CompressionResult, Compressor};
const STATUS_SHORT_LIMIT: usize = 1024;
const STATUS_KEEP_PER_SECTION: usize = 10;
const DIFF_MAX_FILES: usize = 5;
const DIFF_MAX_HUNKS: usize = 20;
const HUNK_KEEP_LINES: usize = 30;
const LOG_SHORT_HASH_LEN: usize = 12;
const BLAME_KEEP_LINES: usize = 50;
const GIT_WRITE_KEEP_LINES: usize = 50;
const GIT_ADD_KEEP_PATHS: usize = 5;
const GIT_STASH_STATUS_KEEP_LINES: usize = 20;
pub struct GitCompressor;
impl Compressor for GitCompressor {
fn matches(&self, command: &str) -> bool {
command_head(command).is_some_and(|head| head == "git")
}
fn compress_with_exit_code(
&self,
command: &str,
output: &str,
exit_code: Option<i32>,
) -> CompressionResult {
let compressed = match git_subcommand(command).as_deref() {
Some("add") => compress_add(output),
Some("status") => compress_status(output),
Some("diff") => compress_diff(output, false),
Some("log") => compress_log(output),
Some("show") => compress_diff(output, true),
Some("branch") => trim_trailing_lines(&dedup_consecutive(output)),
Some("blame") => compress_blame(output),
Some("commit") => compress_commit(output),
Some("push") => compress_push(output),
Some("pull") => compress_pull(output),
Some("fetch") => compress_fetch(output),
Some("stash") => compress_stash(command, output),
_ => GenericCompressor::compress_output(output),
};
if matches!(exit_code, Some(code) if code != 0)
&& looks_like_git_success_summary(&compressed)
{
GenericCompressor::compress_output(output).into()
} else {
compressed.into()
}
}
}
fn looks_like_git_success_summary(text: &str) -> bool {
let trimmed = text.trim();
matches!(
trimmed,
"git: ok" | "git fetch: ok" | "Everything up-to-date" | "Already up to date."
) || trimmed.contains("working tree clean")
}
fn command_head(command: &str) -> Option<&str> {
command.split_whitespace().next()
}
fn git_subcommand(command: &str) -> Option<String> {
let mut seen_git = false;
for token in command.split_whitespace() {
if !seen_git {
if token == "git" {
seen_git = true;
}
continue;
}
if token.starts_with('-') || token.contains('=') {
continue;
}
if crate::compress::is_shell_boundary(token) {
return None;
}
return Some(token.to_string());
}
None
}
fn git_subcommand_after(command: &str, subcommand: &str) -> Option<String> {
let mut seen_git = false;
let mut seen_subcommand = false;
for token in command.split_whitespace() {
if !seen_git {
if token == "git" {
seen_git = true;
}
continue;
}
if !seen_subcommand {
if token.starts_with('-') || token.contains('=') {
continue;
}
seen_subcommand = token == subcommand;
continue;
}
if token.starts_with('-') || token.contains('=') {
continue;
}
return Some(token.to_string());
}
None
}
fn compress_add(output: &str) -> String {
if output.trim().is_empty() {
return "git: ok".to_string();
}
if looks_like_git_error(output) {
return trim_trailing_lines(output);
}
let lines: Vec<&str> = output
.lines()
.filter(|line| !line.trim().is_empty())
.collect();
if lines.is_empty() {
return "git: ok".to_string();
}
let mut result: Vec<String> = lines
.iter()
.take(GIT_ADD_KEEP_PATHS)
.map(|line| line.trim_end().to_string())
.collect();
if lines.len() > GIT_ADD_KEEP_PATHS {
result.push(format!(
"... ({} more files added)",
lines.len() - GIT_ADD_KEEP_PATHS
));
}
cap_git_lines(result, "files added", GIT_WRITE_KEEP_LINES)
}
fn compress_commit(output: &str) -> String {
if output.trim().is_empty() {
return GenericCompressor::compress_output(output);
}
if looks_like_git_error(output) {
return trim_trailing_lines(output);
}
if let Some(line) = output
.lines()
.find(|line| line.contains("nothing to commit"))
{
return line.trim_end().to_string();
}
let subject = output.lines().find(|line| looks_like_commit_subject(line));
let summary = output.lines().find(|line| looks_like_commit_summary(line));
match (subject, summary) {
(Some(subject), Some(summary)) => {
trim_trailing_lines(&format!("{}\n{}", subject.trim_end(), summary.trim()))
}
(Some(subject), None) => subject.trim_end().to_string(),
_ => GenericCompressor::compress_output(output),
}
}
fn compress_push(output: &str) -> String {
if output.trim().is_empty() {
return GenericCompressor::compress_output(output);
}
if looks_like_git_error(output) {
return trim_trailing_lines(output);
}
if let Some(line) = output
.lines()
.find(|line| line.trim() == "Everything up-to-date")
{
return line.trim_end().to_string();
}
let result: Vec<String> = output
.lines()
.filter(|line| is_remote_destination(line) || is_ref_update_line(line))
.map(|line| line.trim_end().to_string())
.collect();
if result.is_empty() {
return GenericCompressor::compress_output(output);
}
cap_git_lines(result, "push lines", GIT_WRITE_KEEP_LINES)
}
fn compress_pull(output: &str) -> String {
if output.trim().is_empty() {
return GenericCompressor::compress_output(output);
}
if looks_like_git_error(output) {
return trim_trailing_lines(output);
}
if let Some(line) = output
.lines()
.find(|line| line.trim() == "Already up to date.")
{
return line.trim_end().to_string();
}
let result: Vec<String> = output
.lines()
.filter(|line| {
looks_like_updating_line(line)
|| looks_like_pull_marker(line)
|| looks_like_commit_summary(line)
})
.map(|line| line.trim_end().to_string())
.collect();
if result.is_empty() {
return GenericCompressor::compress_output(output);
}
cap_git_lines(result, "pull lines", GIT_WRITE_KEEP_LINES)
}
fn compress_fetch(output: &str) -> String {
if output.trim().is_empty() {
return "git fetch: ok".to_string();
}
if looks_like_git_error(output) {
return trim_trailing_lines(output);
}
let result: Vec<String> = output
.lines()
.filter(|line| is_fetch_from_line(line) || is_ref_update_line(line))
.map(|line| line.trim_end().to_string())
.collect();
if result.is_empty() {
return GenericCompressor::compress_output(output);
}
cap_git_lines(result, "fetch lines", GIT_WRITE_KEEP_LINES)
}
fn compress_stash(command: &str, output: &str) -> String {
if output.trim().is_empty() {
return GenericCompressor::compress_output(output);
}
if looks_like_git_error(output) {
return trim_trailing_lines(output);
}
match git_subcommand_after(command, "stash").as_deref() {
None | Some("push") | Some("save") => output
.lines()
.find(|line| line.starts_with("Saved working directory and index state"))
.map(|line| line.trim_end().to_string())
.unwrap_or_else(|| GenericCompressor::compress_output(output)),
Some("pop" | "apply") => cap_git_lines(
output
.lines()
.map(|line| line.trim_end().to_string())
.collect(),
"stash status lines",
GIT_STASH_STATUS_KEEP_LINES,
),
Some("list") => trim_trailing_lines(output),
_ => GenericCompressor::compress_output(output),
}
}
fn looks_like_git_error(output: &str) -> bool {
output.lines().any(|line| {
let trimmed = line.trim_start();
trimmed.starts_with("error:")
|| trimmed.starts_with("fatal:")
|| trimmed.starts_with("CONFLICT ")
|| trimmed.starts_with("Automatic merge failed")
|| trimmed.starts_with("! [rejected]")
|| trimmed.starts_with("! [remote rejected]")
|| trimmed.starts_with("failed to push")
})
}
fn looks_like_commit_subject(line: &str) -> bool {
let trimmed = line.trim_start();
trimmed.starts_with('[') && trimmed.contains("] ")
}
fn looks_like_commit_summary(line: &str) -> bool {
let trimmed = line.trim();
(trimmed.contains("file changed") || trimmed.contains("files changed"))
&& (trimmed.contains("insertion")
|| trimmed.contains("deletion")
|| trimmed.contains("changed"))
}
fn is_remote_destination(line: &str) -> bool {
line.starts_with("To ")
}
fn is_fetch_from_line(line: &str) -> bool {
line.starts_with("From ")
}
fn is_ref_update_line(line: &str) -> bool {
let trimmed = line.trim_start();
trimmed.contains(" -> ")
&& (trimmed.starts_with('*')
|| trimmed.starts_with('+')
|| trimmed.starts_with('-')
|| trimmed.starts_with('=')
|| trimmed.starts_with('!')
|| trimmed.split_whitespace().next().is_some_and(is_hash_range))
}
fn is_hash_range(token: &str) -> bool {
token
.split_once("..")
.is_some_and(|(left, right)| is_short_hash(left) && is_short_hash(right))
}
fn is_short_hash(token: &str) -> bool {
(4..=40).contains(&token.len()) && token.bytes().all(|byte| byte.is_ascii_hexdigit())
}
fn looks_like_updating_line(line: &str) -> bool {
line.trim_start().starts_with("Updating ")
}
fn looks_like_pull_marker(line: &str) -> bool {
let trimmed = line.trim();
trimmed == "Fast-forward" || trimmed.starts_with("Merge made by ")
}
fn cap_git_lines(mut lines: Vec<String>, summary_name: &str, keep_lines: usize) -> String {
if lines.len() > keep_lines {
let omitted = lines.len() - keep_lines;
lines.truncate(keep_lines);
lines.push(format!("... ({} more {})", omitted, summary_name));
}
trim_trailing_lines(&lines.join("\n"))
}
fn compress_status(output: &str) -> String {
if output.len() <= STATUS_SHORT_LIMIT {
return trim_trailing_lines(output);
}
let mut result = Vec::new();
let mut section_entries = Vec::new();
let mut in_section = false;
for line in output.lines() {
if is_status_section_header(line) {
flush_status_entries(&mut result, &mut section_entries);
result.push(line.to_string());
in_section = true;
} else if in_section && is_status_instructional(line) {
result.push(line.to_string());
} else if in_section && is_status_entry(line) {
section_entries.push(line.to_string());
} else {
flush_status_entries(&mut result, &mut section_entries);
result.push(line.to_string());
in_section = false;
}
}
flush_status_entries(&mut result, &mut section_entries);
trim_trailing_lines(&result.join("\n"))
}
fn is_status_section_header(line: &str) -> bool {
matches!(
line.trim_end_matches(':'),
"Changes to be committed"
| "Changes not staged for commit"
| "Untracked files"
| "Unmerged paths"
)
}
fn is_status_instructional(line: &str) -> bool {
let trimmed = line.trim_start();
trimmed.starts_with('(') || trimmed.starts_with("use ")
}
fn is_status_entry(line: &str) -> bool {
let trimmed = line.trim_start();
trimmed.starts_with("modified:")
|| trimmed.starts_with("new file:")
|| trimmed.starts_with("deleted:")
|| trimmed.starts_with("renamed:")
|| trimmed.starts_with("copied:")
|| trimmed.starts_with("both modified:")
|| trimmed.starts_with("both added:")
|| trimmed.starts_with("deleted by us:")
|| trimmed.starts_with("deleted by them:")
|| (!trimmed.is_empty()
&& !trimmed.starts_with('(')
&& !trimmed.starts_with("use ")
&& !trimmed.starts_with("no changes"))
}
fn flush_status_entries(result: &mut Vec<String>, entries: &mut Vec<String>) {
if entries.is_empty() {
return;
}
let keep = entries.len().min(STATUS_KEEP_PER_SECTION);
result.extend(entries.iter().take(keep).cloned());
if entries.len() > keep {
result.push(format!("... and {} more", entries.len() - keep));
}
entries.clear();
}
fn compress_diff(output: &str, keep_commit_header: bool) -> String {
let files = split_diff_files(output, keep_commit_header);
let total_hunks: usize = files.iter().map(|file| count_hunks(&file.lines)).sum();
if files.is_empty() || total_hunks <= 2 && output.len() <= 5 * 1024 {
return trim_trailing_lines(output);
}
let max_files = if total_hunks > DIFF_MAX_HUNKS {
DIFF_MAX_FILES
} else {
usize::MAX
};
let mut result = Vec::new();
let mut emitted_files = 0usize;
for file in &files {
if file.is_diff && emitted_files >= max_files {
continue;
}
result.extend(compress_diff_file(&file.lines));
emitted_files += usize::from(file.is_diff);
}
let changed_files = files.iter().filter(|file| file.is_diff).count();
if changed_files > emitted_files {
result.push(format!(
"... and {} more files changed",
changed_files - emitted_files
));
}
middle_truncate(
&trim_trailing_lines(&result.join("\n")),
16 * 1024,
7 * 1024,
7 * 1024,
)
}
struct DiffFile {
lines: Vec<String>,
is_diff: bool,
}
fn split_diff_files(output: &str, keep_commit_header: bool) -> Vec<DiffFile> {
let mut files = Vec::new();
let mut current = Vec::new();
let mut current_is_diff = false;
for line in output.lines() {
if line.starts_with("diff --git ") {
if !current.is_empty() {
files.push(DiffFile {
lines: std::mem::take(&mut current),
is_diff: current_is_diff,
});
}
current_is_diff = true;
} else if !current_is_diff && !keep_commit_header && !line.starts_with("diff --git ") {
current_is_diff = true;
}
current.push(line.to_string());
}
if !current.is_empty() {
files.push(DiffFile {
lines: current,
is_diff: current_is_diff,
});
}
files
}
fn compress_diff_file(lines: &[String]) -> Vec<String> {
let mut result = Vec::new();
let mut index = 0usize;
while index < lines.len() {
let line = &lines[index];
if !line.starts_with("@@") {
result.push(line.clone());
index += 1;
continue;
}
let hunk_start = index;
index += 1;
while index < lines.len() && !lines[index].starts_with("@@") {
index += 1;
}
let hunk = &lines[hunk_start..index];
append_hunk(&mut result, hunk);
}
result
}
fn append_hunk(result: &mut Vec<String>, hunk: &[String]) {
if hunk.len() <= HUNK_KEEP_LINES + 1 {
result.extend(hunk.iter().cloned());
return;
}
result.extend(hunk.iter().take(HUNK_KEEP_LINES + 1).cloned());
let remaining = &hunk[HUNK_KEEP_LINES + 1..];
let added = remaining
.iter()
.filter(|line| line.starts_with('+'))
.count();
let removed = remaining
.iter()
.filter(|line| line.starts_with('-'))
.count();
result.push(format!(
"... +{} -{} in {} more lines",
added,
removed,
remaining.len()
));
}
fn count_hunks(lines: &[String]) -> usize {
lines.iter().filter(|line| line.starts_with("@@")).count()
}
fn compress_log(output: &str) -> String {
if output.lines().any(|line| line.starts_with("commit ")) {
compress_full_format_log(output)
} else {
compress_oneline_log(output)
}
}
fn compress_full_format_log(output: &str) -> String {
let lines: Vec<&str> = output.lines().collect();
let mut blocks: Vec<usize> = Vec::new();
for (index, line) in lines.iter().enumerate() {
if line.starts_with("commit ") {
blocks.push(index);
}
}
if blocks.is_empty() {
return trim_trailing_lines(output);
}
let mut result = Vec::new();
for (block_index, &start) in blocks.iter().enumerate() {
let end = blocks.get(block_index + 1).copied().unwrap_or(lines.len());
let block = &lines[start..end];
if let Some(compact) = format_log_commit_block(block) {
result.push(compact);
}
}
trim_trailing_lines(&result.join("\n"))
}
fn format_log_commit_block(block: &[&str]) -> Option<String> {
let first = block.first()?;
let full_hash = first.strip_prefix("commit ")?.trim();
let short_hash = abbreviate_log_hash(full_hash);
let mut merge_parents: Option<String> = None;
let mut author: Option<String> = None;
let mut date_compact: Option<String> = None;
let mut header_end = 1usize;
for (offset, line) in block.iter().enumerate().skip(1) {
if line.starts_with("Merge: ") {
let rest = line.strip_prefix("Merge: ").unwrap_or("");
let parents: Vec<String> = rest.split_whitespace().map(abbreviate_log_hash).collect();
merge_parents = Some(format!("Merge: {}", parents.join(" ")));
header_end = offset + 1;
} else if let Some(rest) = line.strip_prefix("Author: ") {
author = Some(format_author_compact(rest.trim()));
header_end = offset + 1;
} else if let Some(rest) = line.strip_prefix("Date: ") {
date_compact = Some(compact_git_log_date(rest.trim()));
header_end = offset + 1;
} else if line.trim().is_empty() {
header_end = offset + 1;
break;
} else {
break;
}
}
let mut body_iter = block[header_end..].iter().copied();
let mut subject = String::new();
let mut body_rest = Vec::new();
if let Some(first_body) = body_iter.next() {
subject = first_body.trim().to_string();
for line in body_iter {
body_rest.push(normalize_log_body_line(line));
}
}
let author = author.unwrap_or_default();
let date_compact = date_compact.unwrap_or_default();
let mut header = format!("{short_hash} {subject}");
if let Some(merge) = merge_parents {
header = format!("{short_hash} {merge} {subject}");
}
if !author.is_empty() {
header.push_str(&format!(" {author}"));
}
if !date_compact.is_empty() {
header.push(' ');
header.push_str(&date_compact);
}
let mut out = header;
for line in collapse_log_body_blank_runs(&body_rest) {
out.push('\n');
out.push_str(&line);
}
Some(out)
}
fn normalize_log_body_line(line: &str) -> String {
if line.starts_with(' ') || line.starts_with('\t') {
format!(" {}", line.trim_start())
} else {
format!(" {line}")
}
}
fn collapse_log_body_blank_runs(body: &[String]) -> Vec<String> {
body.iter()
.filter(|line| !line.trim().is_empty())
.cloned()
.collect()
}
fn format_author_compact(author: &str) -> String {
if let Some((name, email)) = author.split_once('<') {
let name = name.trim();
let email = email.trim_end_matches('>').trim();
format!("<{name} {email}>")
} else {
format!("<{author}>")
}
}
fn abbreviate_log_hash(hash: &str) -> String {
let hash = hash.trim();
if hash.len() <= LOG_SHORT_HASH_LEN {
hash.to_string()
} else {
hash[..LOG_SHORT_HASH_LEN].to_string()
}
}
fn compact_git_log_date(date_field: &str) -> String {
let parts: Vec<&str> = date_field.split_whitespace().collect();
if parts.len() < 5 {
return date_field.to_string();
}
let month = parts[1];
let day = parts[2];
let time = parts[3];
let year = parts[4];
let month_num = match month {
"Jan" => "01",
"Feb" => "02",
"Mar" => "03",
"Apr" => "04",
"May" => "05",
"Jun" => "06",
"Jul" => "07",
"Aug" => "08",
"Sep" => "09",
"Oct" => "10",
"Nov" => "11",
"Dec" => "12",
_ => return date_field.to_string(),
};
let day_padded = if day.len() == 1 {
format!("0{day}")
} else {
day.to_string()
};
format!("{year}-{month_num}-{day_padded} {time}")
}
fn compress_oneline_log(output: &str) -> String {
let result: Vec<String> = output
.lines()
.filter(|line| !line.trim().is_empty())
.map(|line| {
if looks_like_oneline_commit(line) {
let mut parts = line.splitn(2, ' ');
let hash = parts.next().unwrap_or("");
let rest = parts.next().unwrap_or("");
let short = abbreviate_log_hash(hash);
if rest.is_empty() {
short
} else {
format!("{short} {rest}")
}
} else {
line.trim_end().to_string()
}
})
.collect();
trim_trailing_lines(&result.join("\n"))
}
fn looks_like_oneline_commit(line: &str) -> bool {
let Some((hash, _message)) = line.split_once(' ') else {
return false;
};
(7..=40).contains(&hash.len()) && hash.bytes().all(|byte| byte.is_ascii_hexdigit())
}
fn compress_blame(output: &str) -> String {
let total = output.lines().count();
if total <= BLAME_KEEP_LINES {
return trim_trailing_lines(output);
}
let mut result: Vec<String> = output
.lines()
.take(BLAME_KEEP_LINES)
.map(ToString::to_string)
.collect();
result.push(format!("... {} more blame lines", total - BLAME_KEEP_LINES));
result.join("\n")
}
fn trim_trailing_lines(input: &str) -> String {
input
.lines()
.map(str::trim_end)
.collect::<Vec<_>>()
.join("\n")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::compress::Compressor;
fn compress(command: &str, output: &str) -> CompressionResult {
GitCompressor.compress(command, output)
}
#[test]
fn test_add_empty_output_ok() {
let compressed = compress("git add .", "");
assert_eq!(compressed, "git: ok");
}
#[test]
fn test_add_verbose_many_files() {
let raw = "add 'src/a.rs'\nadd 'src/b.rs'\nadd 'src/c.rs'\nadd 'src/d.rs'\nadd 'src/e.rs'\nadd 'src/f.rs'\nadd 'src/g.rs'\n";
let compressed = compress("git add --verbose .", raw);
assert!(compressed.contains("add 'src/a.rs'"));
assert!(compressed.contains("add 'src/e.rs'"));
assert!(compressed.contains("... (2 more files added)"));
assert!(!compressed.contains("add 'src/g.rs'"));
}
#[test]
fn test_add_error_passthrough() {
let raw = "fatal: pathspec 'missing.rs' did not match any files\n";
let compressed = compress("git add missing.rs", raw);
assert_eq!(
compressed,
"fatal: pathspec 'missing.rs' did not match any files"
);
}
#[test]
fn test_commit_success_extracts_subject_and_summary() {
let raw = "[main 1a2b3c4] add git write compression\n 3 files changed, 42 insertions(+), 7 deletions(-)\n create mode 100644 crates/aft/src/foo.rs\n rewrite crates/aft/src/bar.rs (80%)\n";
let compressed = compress("git commit -m 'add git write compression'", raw);
assert_eq!(
compressed,
"[main 1a2b3c4] add git write compression\n3 files changed, 42 insertions(+), 7 deletions(-)"
);
}
#[test]
fn test_commit_nothing_to_commit_verbatim() {
let raw = "On branch main\nnothing to commit, working tree clean\n";
let compressed = compress("git commit -m noop", raw);
assert_eq!(compressed, "nothing to commit, working tree clean");
}
#[test]
fn test_commit_error_passthrough() {
let raw = "error: Committing is not possible because you have unmerged files.\nhint: Fix them up in the work tree, and then use 'git add/rm <file>'\nfatal: Exiting because of an unresolved conflict.\n";
let compressed = compress("git commit", raw);
assert!(compressed.contains("error: Committing is not possible"));
assert!(compressed.contains("fatal: Exiting because of an unresolved conflict."));
}
#[test]
fn test_push_success_drops_progress_keeps_remote_and_ref() {
let raw = "Counting objects: 12, done.\nDelta compression using up to 8 threads\nCompressing objects: 100% (7/7), done.\nWriting objects: 100% (7/7), 1.23 KiB | 1.23 MiB/s, done.\nTotal 7 (delta 4), reused 0 (delta 0), pack-reused 0\nremote: Resolving deltas: 100% (4/4), completed with 4 local objects.\nTo github.com:example/repo.git\n 9d8c7b6..1a2b3c4 main -> main\n";
let compressed = compress("git push", raw);
assert_eq!(
compressed,
"To github.com:example/repo.git\n 9d8c7b6..1a2b3c4 main -> main"
);
}
#[test]
fn test_push_everything_up_to_date_and_empty() {
assert_eq!(
compress("git push", "Everything up-to-date\n"),
"Everything up-to-date"
);
assert_eq!(compress("git push", ""), "");
}
#[test]
fn test_push_error_passthrough() {
let raw = "To github.com:example/repo.git\n ! [rejected] main -> main (fetch first)\nerror: failed to push some refs to 'github.com:example/repo.git'\n";
let compressed = compress("git push", raw);
assert!(compressed.contains("! [rejected] main -> main (fetch first)"));
assert!(compressed.contains("error: failed to push some refs"));
}
#[test]
fn test_pull_fast_forward_keeps_summary() {
let raw = "remote: Enumerating objects: 9, done.\nremote: Counting objects: 100% (9/9), done.\nFrom github.com:example/repo\n 1111111..2222222 main -> origin/main\nUpdating 1111111..2222222\nFast-forward\n crates/aft/src/compress/git.rs | 12 +++++++++---\n 1 file changed, 9 insertions(+), 3 deletions(-)\n";
let compressed = compress("git pull --ff-only", raw);
assert_eq!(
compressed,
"Updating 1111111..2222222\nFast-forward\n 1 file changed, 9 insertions(+), 3 deletions(-)"
);
}
#[test]
fn test_pull_already_up_to_date_empty_and_error() {
assert_eq!(
compress("git pull", "Already up to date.\n"),
"Already up to date."
);
assert_eq!(compress("git pull", ""), "");
let raw = "CONFLICT (content): Merge conflict in README.md\nAutomatic merge failed; fix conflicts and then commit the result.\n";
let compressed = compress("git pull", raw);
assert!(compressed.contains("CONFLICT (content): Merge conflict in README.md"));
assert!(compressed.contains("Automatic merge failed"));
}
#[test]
fn test_fetch_success_empty_and_error() {
let raw = "remote: Enumerating objects: 5, done.\nremote: Counting objects: 100% (5/5), done.\nFrom github.com:example/repo\n * [new branch] feature/git-compress -> origin/feature/git-compress\n abc1234..def5678 main -> origin/main\n";
let compressed = compress("git fetch --all", raw);
assert_eq!(
compressed,
"From github.com:example/repo\n * [new branch] feature/git-compress -> origin/feature/git-compress\n abc1234..def5678 main -> origin/main"
);
assert_eq!(compress("git fetch", " \n"), "git fetch: ok");
let error =
"fatal: unable to access 'https://example.invalid/repo.git/': Could not resolve host\n";
assert_eq!(
compress("git fetch", error),
"fatal: unable to access 'https://example.invalid/repo.git/': Could not resolve host"
);
}
#[test]
fn test_stash_push_pop_list_empty_and_error() {
let push = "Saved working directory and index state WIP on main: 1a2b3c4 add tests\nHEAD is now at 1a2b3c4 add tests\n";
assert_eq!(
compress("git stash push", push),
"Saved working directory and index state WIP on main: 1a2b3c4 add tests"
);
let pop = "On branch main\nChanges not staged for commit:\n (use \"git add <file>...\" to update what will be committed)\n\tmodified: README.md\nDropped refs/stash@{0} (abc123456789)\n";
let compressed_pop = compress("git stash pop", pop);
assert!(compressed_pop.contains("On branch main"));
assert!(compressed_pop.contains("Dropped refs/stash@{0}"));
let list = "stash@{0}: WIP on main: 1111111 first\nstash@{1}: On feature: second\n";
assert_eq!(compress("git stash list", list), list.trim_end());
assert_eq!(compress("git stash", ""), "");
let error = "error: Your local changes to the following files would be overwritten by merge:\n\tREADME.md\n";
let compressed_error = compress("git stash apply", error);
assert!(compressed_error.contains("error: Your local changes"));
assert!(compressed_error.contains("README.md"));
}
#[test]
fn test_log_merge_commit_keeps_parents() {
let raw = "commit cccccccccccccccccccccccccccccccccccc\nMerge: dddddddddddddddddddddddddddddddddddd eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\nAuthor: Merger <merge@example.com>\nDate: Mon Jan 01 12:00:00 2024 +0000\n\n Merge branch 'feature'\n";
let compressed = compress("git log", raw);
assert!(compressed.contains("Merge: dddddddddddd eeeeeeeeeeee"));
assert!(compressed.contains("Merge branch 'feature'"));
}
#[test]
fn test_log_format_collapse_short_log() {
let raw = "commit aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nAuthor: Alice Example <alice@example.com>\nDate: Thu Jun 18 17:39:12 2026 +0200\n\n first subject\n detail one\n\ncommit bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nAuthor: Bob Example <bob@example.com>\nDate: Wed Jun 17 10:00:00 2026 +0000\n\n second subject\n";
let compressed = compress("git log", raw);
assert!(!compressed.contains("commit "));
assert!(!compressed.contains("Author:"));
assert!(!compressed.contains("Date:"));
assert!(compressed.contains("aaaaaaaaaaaa first subject"));
assert!(compressed.contains("<Alice Example alice@example.com>"));
assert!(compressed.contains("2026-06-18 17:39:12"));
assert!(compressed.contains("detail one"));
assert!(compressed.contains("bbbbbbbbbbbb second subject"));
assert!(!compressed.contains(" ago"));
assert!(compressed.len() < raw.len());
}
#[test]
fn test_log_compress_is_deterministic() {
let raw = "commit 1111111111111111111111111111111111111111\nAuthor: x <x@y.com>\nDate: Thu Jun 18 17:39:12 2026 +0200\n\n subject\n body\n";
let a = compress_log(raw);
let b = compress_log(raw);
assert_eq!(a, b);
assert!(a.contains("111111111111"));
assert!(a.contains("2026-06-18 17:39:12"));
}
#[test]
fn test_log_oneline_abbreviates_hash_keeps_all_lines() {
let raw = "e4e8f7e1234567890abcdef1234567890abcdef (HEAD -> main) chore\n9c4aa18abcdef1234567890abcdef1234567890 feat\n";
let compressed = compress("git log --oneline", raw);
assert!(compressed.contains("e4e8f7e12345"));
assert!(compressed.contains("(HEAD -> main) chore"));
assert!(compressed.contains("9c4aa18abcde"));
assert!(compressed.contains("feat"));
assert!(!compressed.contains("... more commits"));
}
#[test]
fn test_log_deep_needle_survives_without_drop_line() {
let raw = include_str!("../../tests/fixtures/git_log_deep_needle.txt");
let compressed = compress("git log", raw);
assert!(compressed.contains("feedfacefeed"));
assert!(compressed.contains("NEEDLE_GIT_auth_bypass"));
assert!(compressed.contains("UNIQUE_BODY_MARKER_needle_xyz"));
assert!(!compressed.contains("... more commits"));
assert!(compressed.len() < raw.len());
}
#[test]
fn git_subcommand_returns_none_for_pipe_before_subcommand() {
assert_eq!(git_subcommand("git --no-pager | grep log"), None);
}
#[test]
fn git_subcommand_returns_subcommand_when_before_pipe() {
assert_eq!(git_subcommand("git log | grep fix").as_deref(), Some("log"));
}
#[test]
fn git_subcommand_returns_none_for_redirect_before_subcommand() {
assert_eq!(git_subcommand("git --no-pager > out.log"), None);
}
#[test]
fn git_subcommand_unaffected_without_metacharacters() {
assert_eq!(git_subcommand("git log --oneline").as_deref(), Some("log"));
}
}