1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use crate::OutputFormat;

pub struct Options {
    pub format: OutputFormat,
    pub statistics: bool,
}

pub(crate) mod function {
    use std::{io, path::Path};

    use anyhow::bail;
    use gix::prelude::FindExt;

    use crate::{
        repository::attributes::query::{attributes_cache, Options},
        OutputFormat,
    };

    pub fn query(
        repo: gix::Repository,
        pathspecs: impl Iterator<Item = gix::path::Spec>,
        mut out: impl io::Write,
        mut err: impl io::Write,
        Options { format, statistics }: Options,
    ) -> anyhow::Result<()> {
        if format != OutputFormat::Human {
            bail!("JSON output isn't implemented yet");
        }

        let mut cache = attributes_cache(&repo)?;
        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(Path::to_string_lossy).unwrap_or_default(),
                        m.location.sequence_number,
                        m.pattern,
                        path,
                        m.assignment
                    )?;
                }
            }
        }

        if let Some(stats) = statistics.then(|| cache.take_statistics()) {
            out.flush()?;
            writeln!(err, "{stats:#?}").ok();
        }
        Ok(())
    }
}

pub(crate) fn attributes_cache(repo: &gix::Repository) -> anyhow::Result<gix::worktree::Cache> {
    let index = repo.index_or_load_from_head()?;
    Ok(repo.attributes(
        &index,
        if repo.is_bare() {
            gix::worktree::cache::state::attributes::Source::IdMapping
        } else {
            gix::worktree::cache::state::attributes::Source::WorktreeThenIdMapping
        },
        gix::worktree::cache::state::ignore::Source::IdMapping,
        None,
    )?)
}