use std::{borrow::Cow, io, io::BufWriter};
use anyhow::bail;
use gix::Tree;
use crate::OutputFormat;
mod entries {
use std::collections::VecDeque;
use gix::{
bstr::{BStr, BString, ByteSlice, ByteVec},
objs::tree::EntryRef,
traverse::tree::visit::Action,
};
use crate::repository::tree::format_entry;
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[derive(Default)]
pub struct Statistics {
pub num_trees: usize,
pub num_links: usize,
pub num_blobs: usize,
pub num_blobs_exec: usize,
pub num_submodules: usize,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
#[cfg_attr(not(feature = "serde"), allow(dead_code))]
pub bytes: Option<u64>,
#[cfg_attr(feature = "serde", serde(skip))]
pub num_bytes: u64,
}
pub struct Traverse<'repo, 'a> {
pub stats: Statistics,
repo: Option<&'repo gix::Repository>,
out: Option<&'a mut dyn std::io::Write>,
path: BString,
path_deque: VecDeque<BString>,
}
impl<'repo, 'a> Traverse<'repo, 'a> {
pub fn new(repo: Option<&'repo gix::Repository>, out: Option<&'a mut dyn std::io::Write>) -> Self {
Traverse {
stats: Default::default(),
repo,
out,
path: BString::default(),
path_deque: VecDeque::new(),
}
}
fn pop_element(&mut self) {
if let Some(pos) = self.path.rfind_byte(b'/') {
self.path.resize(pos, 0);
} else {
self.path.clear();
}
}
fn push_element(&mut self, name: &BStr) {
if name.is_empty() {
return;
}
if !self.path.is_empty() {
self.path.push(b'/');
}
self.path.push_str(name);
}
}
impl gix::traverse::tree::Visit for Traverse<'_, '_> {
fn pop_back_tracked_path_and_set_current(&mut self) {
self.path = self.path_deque.pop_back().unwrap_or_default();
}
fn pop_front_tracked_path_and_set_current(&mut self) {
self.path = self.path_deque.pop_front().expect("every parent is set only once");
}
fn push_back_tracked_path_component(&mut self, component: &BStr) {
self.push_element(component);
self.path_deque.push_back(self.path.clone());
}
fn push_path_component(&mut self, component: &BStr) {
self.push_element(component);
}
fn pop_path_component(&mut self) {
self.pop_element();
}
fn visit_tree(&mut self, _entry: &EntryRef<'_>) -> Action {
self.stats.num_trees += 1;
std::ops::ControlFlow::Continue(true)
}
fn visit_nontree(&mut self, entry: &EntryRef<'_>) -> Action {
let size = self
.repo
.and_then(|repo| repo.find_header(entry.oid).map(|h| h.size()).ok());
if let Some(out) = &mut self.out {
format_entry(out, entry, self.path.as_bstr(), size).ok();
}
if let Some(size) = size {
self.stats.num_bytes += size;
}
use gix::object::tree::EntryKind::*;
match entry.mode.kind() {
Commit => self.stats.num_submodules += 1,
Blob => self.stats.num_blobs += 1,
BlobExecutable => self.stats.num_blobs_exec += 1,
Link => self.stats.num_links += 1,
Tree => unreachable!("BUG"),
}
std::ops::ControlFlow::Continue(true)
}
}
}
#[cfg_attr(not(feature = "serde"), allow(unused_variables))]
pub fn info(
repo: gix::Repository,
treeish: Option<&str>,
extended: bool,
format: OutputFormat,
out: impl io::Write,
mut err: impl io::Write,
) -> anyhow::Result<()> {
if format == OutputFormat::Human {
writeln!(err, "Only JSON is implemented - using that instead")?;
}
let tree = treeish_to_tree(treeish, &repo)?;
let mut delegate = entries::Traverse::new(extended.then_some(&repo), None);
tree.traverse().breadthfirst(&mut delegate)?;
#[cfg(feature = "serde")]
{
delegate.stats.bytes = extended.then_some(delegate.stats.num_bytes);
serde_json::to_writer_pretty(out, &delegate.stats)?;
}
Ok(())
}
pub fn entries(
repo: gix::Repository,
treeish: Option<&str>,
recursive: bool,
extended: bool,
format: OutputFormat,
mut out: impl io::Write,
) -> anyhow::Result<()> {
if format != OutputFormat::Human {
bail!("Only human output format is supported at the moment");
}
let tree = treeish_to_tree(treeish, &repo)?;
if recursive {
let mut write = BufWriter::new(out);
let mut delegate = entries::Traverse::new(extended.then_some(&repo), Some(&mut write));
tree.traverse().depthfirst(&mut delegate)?;
} else {
for entry in tree.iter() {
let entry = entry?;
format_entry(
&mut out,
&entry.inner,
entry.inner.filename,
extended.then(|| entry.id().header().map(|o| o.size())).transpose()?,
)?;
}
}
Ok(())
}
fn treeish_to_tree<'repo>(treeish: Option<&str>, repo: &'repo gix::Repository) -> anyhow::Result<Tree<'repo>> {
let spec = treeish.map_or_else(|| "@^{tree}".into(), |spec| format!("{spec}^{{tree}}"));
Ok(repo.rev_parse_single(spec.as_str())?.object()?.into_tree())
}
fn format_entry(
mut out: impl io::Write,
entry: &gix::objs::tree::EntryRef<'_>,
filename: &gix::bstr::BStr,
size: Option<u64>,
) -> std::io::Result<()> {
use gix::objs::tree::EntryKind::*;
write!(
out,
"{} {}{} ",
match entry.mode.kind() {
Tree => "TREE",
Blob => "BLOB",
BlobExecutable => " EXE",
Link => "LINK",
Commit => "SUBM",
},
entry.oid,
size.map_or_else(|| "".into(), |s| Cow::Owned(format!(" {s}")))
)?;
out.write_all(filename)?;
out.write_all(b"\n")
}