feat: gix index entries also prints attributes.

Author: Byron

gitoxide-core/src/repository/index/entries.rs

@@ -1,86 +1,175 @@
-pub fn entries(repo: gix::Repository, mut out: impl std::io::Write, format: crate::OutputFormat) -> anyhow::Result<()> {
-    use crate::OutputFormat::*;
-    let index = repo.index()?;
+#[derive(Debug)]
+pub struct Options {
+    pub format: crate::OutputFormat,
+    /// If true, also show attributes
+    pub attributes: bool,
+}
+pub(crate) mod function {
+    use crate::repository::index::entries::Options;
+    use gix::attrs::State;
+    use gix::bstr::ByteSlice;
+    use gix::odb::FindExt;
+    use std::borrow::Cow;
+    use std::io::BufWriter;
 
-    #[cfg(feature = "serde")]
-    if let Json = format {
-        out.write_all(b"[\n")?;
-    }
+    pub fn entries(
+        repo: gix::Repository,
+        mut out: impl std::io::Write,
+        Options { format, attributes }: Options,
+    ) -> anyhow::Result<()> {
+        use crate::OutputFormat::*;
+        let index = repo.index()?;
+        let mut cache = attributes
+            .then(|| {
+                repo.attributes(
+                    &index,
+                    gix::worktree::cache::state::attributes::Source::WorktreeThenIdMapping,
+                    None,
+                )
+                .map(|cache| (cache.attribute_matches(), cache))
+            })
+            .transpose()?;
 
-    let mut entries = index.entries().iter().peekable();
-    while let Some(entry) = entries.next() {
-        match format {
-            Human => to_human(&mut out, &index, entry)?,
-            #[cfg(feature = "serde")]
-            Json => to_json(&mut out, &index, entry, entries.peek().is_none())?,
+        #[cfg(feature = "serde")]
+        if let Json = format {
+            out.write_all(b"[\n")?;
         }
-    }
 
-    #[cfg(feature = "serde")]
-    if let Json = format {
-        out.write_all(b"]\n")?;
-    }
-    Ok(())
-}
+        let mut out = BufWriter::new(out);
+        let mut entries = index.entries().iter().peekable();
+        while let Some(entry) = entries.next() {
+            let attrs = cache
+                .as_mut()
+                .map(|(attrs, cache)| {
+                    cache
+                        .at_entry(entry.path(&index), None, |id, buf| repo.objects.find_blob(id, buf))
+                        .map(|entry| Attrs {
+                            is_excluded: entry.is_excluded(),
+                            attributes: {
+                                entry.matching_attributes(attrs);
+                                attrs.iter().map(|m| m.assignment.to_owned()).collect()
+                            },
+                        })
+                })
+                .transpose()?;
+            match format {
+                Human => to_human(&mut out, &index, entry, attrs)?,
+                #[cfg(feature = "serde")]
+                Json => to_json(&mut out, &index, entry, attrs, entries.peek().is_none())?,
+            }
+        }
 
-#[cfg(feature = "serde")]
-pub(crate) fn to_json(
-    mut out: &mut impl std::io::Write,
-    index: &gix::index::File,
-    entry: &gix::index::Entry,
-    is_last: bool,
-) -> anyhow::Result<()> {
-    use gix::bstr::ByteSlice;
+        #[cfg(feature = "serde")]
+        if let Json = format {
+            use std::io::Write;
+            out.write_all(b"]\n")?;
+        }
+        Ok(())
+    }
 
     #[cfg_attr(feature = "serde", derive(serde::Serialize))]
-    struct Entry<'a> {
-        stat: &'a gix::index::entry::Stat,
-        hex_id: String,
-        flags: u32,
-        mode: u32,
-        path: std::borrow::Cow<'a, str>,
+    struct Attrs {
+        is_excluded: bool,
+        attributes: Vec<gix::attrs::Assignment>,
     }
 
-    serde_json::to_writer(
-        &mut out,
-        &Entry {
-            stat: &entry.stat,
-            hex_id: entry.id.to_hex().to_string(),
-            flags: entry.flags.bits(),
-            mode: entry.mode.bits(),
-            path: entry.path(index).to_str_lossy(),
-        },
-    )?;
+    #[cfg(feature = "serde")]
+    fn to_json(
+        mut out: &mut impl std::io::Write,
+        index: &gix::index::File,
+        entry: &gix::index::Entry,
+        attrs: Option<Attrs>,
+        is_last: bool,
+    ) -> anyhow::Result<()> {
+        #[cfg_attr(feature = "serde", derive(serde::Serialize))]
+        struct Entry<'a> {
+            stat: &'a gix::index::entry::Stat,
+            hex_id: String,
+            flags: u32,
+            mode: u32,
+            path: std::borrow::Cow<'a, str>,
+            meta: Option<Attrs>,
+        }
 
-    if is_last {
-        out.write_all(b"\n")?;
-    } else {
-        out.write_all(b",\n")?;
-    }
-    Ok(())
-}
+        serde_json::to_writer(
+            &mut out,
+            &Entry {
+                stat: &entry.stat,
+                hex_id: entry.id.to_hex().to_string(),
+                flags: entry.flags.bits(),
+                mode: entry.mode.bits(),
+                path: entry.path(index).to_str_lossy(),
+                meta: attrs,
+            },
+        )?;
 
-pub(crate) fn to_human(
-    out: &mut impl std::io::Write,
-    file: &gix::index::File,
-    entry: &gix::index::Entry,
-) -> std::io::Result<()> {
-    writeln!(
-        out,
-        "{} {}{:?} {} {}",
-        match entry.flags.stage() {
-            0 => "BASE   ",
-            1 => "OURS   ",
-            2 => "THEIRS ",
-            _ => "UNKNOWN",
-        },
-        if entry.flags.is_empty() {
-            "".to_string()
+        if is_last {
+            out.write_all(b"\n")?;
         } else {
-            format!("{:?} ", entry.flags)
-        },
-        entry.mode,
-        entry.id,
-        entry.path(file)
-    )
+            out.write_all(b",\n")?;
+        }
+        Ok(())
+    }
+
+    fn to_human(
+        out: &mut impl std::io::Write,
+        file: &gix::index::File,
+        entry: &gix::index::Entry,
+        attrs: Option<Attrs>,
+    ) -> std::io::Result<()> {
+        writeln!(
+            out,
+            "{} {}{:?} {} {}{}",
+            match entry.flags.stage() {
+                0 => "BASE   ",
+                1 => "OURS   ",
+                2 => "THEIRS ",
+                _ => "UNKNOWN",
+            },
+            if entry.flags.is_empty() {
+                "".to_string()
+            } else {
+                format!("{:?} ", entry.flags)
+            },
+            entry.mode,
+            entry.id,
+            entry.path(file),
+            attrs
+                .map(|a| {
+                    let mut buf = String::new();
+                    if a.is_excluded {
+                        buf.push_str(" ❌");
+                    }
+                    if !a.attributes.is_empty() {
+                        buf.push_str(" (");
+                        for assignment in a.attributes {
+                            match assignment.state {
+                                State::Set => {
+                                    buf.push_str(assignment.name.as_str());
+                                }
+                                State::Unset => {
+                                    buf.push('-');
+                                    buf.push_str(assignment.name.as_str());
+                                }
+                                State::Value(v) => {
+                                    buf.push_str(assignment.name.as_str());
+                                    buf.push('=');
+                                    buf.push_str(v.as_ref().as_bstr().to_str_lossy().as_ref());
+                                }
+                                State::Unspecified => {
+                                    buf.push('!');
+                                    buf.push_str(assignment.name.as_str());
+                                }
+                            }
+                            buf.push_str(", ");
+                        }
+                        buf.pop();
+                        buf.pop();
+                        buf.push(')');
+                    }
+                    buf.into()
+                })
+                .unwrap_or(Cow::Borrowed(""))
+        )
+    }
 }

gitoxide-core/src/repository/index/mod.rs

@@ -35,5 +35,5 @@ pub fn from_tree(
     Ok(())
 }
 
-mod entries;
-pub use entries::entries;
+pub mod entries;
+pub use entries::function::entries;

src/plumbing/main.rs

@@ -855,14 +855,21 @@ pub fn main() -> Result<()> {
             ),
         },
         Subcommands::Index(cmd) => match cmd {
-            index::Subcommands::Entries => prepare_and_run(
+            index::Subcommands::Entries { no_attributes } => prepare_and_run(
                 "index-entries",
                 verbose,
                 progress,
                 progress_keep_open,
                 None,
                 move |_progress, out, _err| {
-                    core::repository::index::entries(repository(Mode::LenientWithGitInstallConfig)?, out, format)
+                    core::repository::index::entries(
+                        repository(Mode::LenientWithGitInstallConfig)?,
+                        out,
+                        core::repository::index::entries::Options {
+                            format,
+                            attributes: !no_attributes,
+                        },
+                    )
                 },
             ),
             index::Subcommands::FromTree {

src/plumbing/options/mod.rs

@@ -472,7 +472,11 @@ pub mod index {
     #[derive(Debug, clap::Subcommand)]
     pub enum Subcommands {
         /// Print all entries to standard output
-        Entries,
+        Entries {
+            /// Do not visualize excluded entries or attributes per path.
+            #[clap(long)]
+            no_attributes: bool,
+        },
         /// Create an index from a tree-ish.
         #[clap(visible_alias = "read-tree")]
         FromTree {