feat: gix attribute query as something similar to git check-attrs.

Author: Byron

gitoxide-core/src/repository/attributes.rs

@@ -0,0 +1,51 @@
+use std::io;
+
+use anyhow::bail;
+use gix::prelude::FindExt;
+
+use crate::OutputFormat;
+
+pub fn query(
+    repo: gix::Repository,
+    pathspecs: impl Iterator<Item = gix::path::Spec>,
+    mut out: impl io::Write,
+    format: OutputFormat,
+) -> anyhow::Result<()> {
+    if format != OutputFormat::Human {
+        bail!("JSON output isn't implemented yet");
+    }
+
+    let index = repo.index()?;
+    let mut cache = repo.attributes(
+        &index,
+        gix::worktree::cache::state::attributes::Source::WorktreeThenIdMapping,
+        gix::worktree::cache::state::ignore::Source::IdMapping,
+        None,
+    )?;
+
+    let prefix = repo.prefix().expect("worktree - we have an index by now")?;
+    let mut matches = cache.attribute_matches();
+
+    for mut spec in pathspecs {
+        for path in spec.apply_prefix(&prefix).items() {
+            let is_dir = gix::path::from_bstr(path).metadata().ok().map(|m| m.is_dir());
+            let entry = cache.at_entry(path, is_dir, |oid, buf| repo.objects.find_blob(oid, buf))?;
+
+            if !entry.matching_attributes(&mut matches) {
+                continue;
+            }
+            for m in matches.iter() {
+                writeln!(
+                    out,
+                    "{}:{}:{}\t{}\t{}",
+                    m.location.source.map(|p| p.to_string_lossy()).unwrap_or_default(),
+                    m.location.sequence_number,
+                    m.pattern,
+                    path,
+                    m.assignment
+                )?;
+            }
+        }
+    }
+    Ok(())
+}

gitoxide-core/src/repository/mod.rs

@@ -15,6 +15,7 @@ pub mod commit;
 pub mod config;
 mod credential;
 pub use credential::function as credential;
+pub mod attributes;
 #[cfg(feature = "blocking-client")]
 pub mod clone;
 pub mod exclude;

src/plumbing/main.rs

@@ -13,6 +13,7 @@ use gitoxide_core as core;
 use gitoxide_core::pack::verify;
 use gix::bstr::io::BufReadExt;
 
+use crate::plumbing::options::attributes;
 use crate::{
     plumbing::{
         options::{commit, config, credential, exclude, free, index, mailmap, odb, revision, tree, Args, Subcommands},
@@ -831,6 +832,33 @@ pub fn main() -> Result<()> {
                 },
             ),
         },
+        Subcommands::Attributes(cmd) => match cmd {
+            attributes::Subcommands::Query { pathspecs } => prepare_and_run(
+                "attributes-query",
+                verbose,
+                progress,
+                progress_keep_open,
+                None,
+                move |_progress, out, _err| {
+                    use gix::bstr::ByteSlice;
+                    core::repository::attributes::query(
+                        repository(Mode::Strict)?,
+                        if pathspecs.is_empty() {
+                            Box::new(
+                                stdin_or_bail()?
+                                    .byte_lines()
+                                    .filter_map(Result::ok)
+                                    .filter_map(|line| gix::path::Spec::from_bytes(line.as_bstr())),
+                            ) as Box<dyn Iterator<Item = gix::path::Spec>>
+                        } else {
+                            Box::new(pathspecs.into_iter())
+                        },
+                        out,
+                        format,
+                    )
+                },
+            ),
+        },
         Subcommands::Exclude(cmd) => match cmd {
             exclude::Subcommands::Query {
                 patterns,

src/plumbing/options/mod.rs

@@ -103,6 +103,9 @@ pub enum Subcommands {
     /// Interact with the remote hosts.
     #[cfg(any(feature = "gitoxide-core-async-client", feature = "gitoxide-core-blocking-client"))]
     Remote(remote::Platform),
+    /// Interact with the attribute files like .gitattributes.
+    #[clap(subcommand, visible_alias = "attrs")]
+    Attributes(attributes::Subcommands),
     /// Interact with the exclude files like .gitignore.
     #[clap(subcommand)]
     Exclude(exclude::Subcommands),
@@ -440,6 +443,20 @@ pub mod revision {
     }
 }
 
+pub mod attributes {
+    use crate::shared::AsPathSpec;
+
+    #[derive(Debug, clap::Subcommand)]
+    pub enum Subcommands {
+        /// List all attributes of the given path-specs and display the result similar to `git check-attr`.
+        Query {
+            /// The git path specifications to list attributes for, or unset to read from stdin one per line.
+            #[clap(value_parser = AsPathSpec)]
+            pathspecs: Vec<gix::path::Spec>,
+        },
+    }
+}
+
 pub mod exclude {
     use std::ffi::OsString;