riptree2 0.9.0

riptree2 is a Rust rewrite of the Unix tree command. It aims to be a drop in replacement (`alias tree="rt --compat"`) with some quality of life improvements, such as automatically respecting ignore files.
Documentation 
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::path::{Path, PathBuf};

use anyhow::Context;
use ignore::gitignore::{Gitignore, GitignoreBuilder};

pub struct IgnoreDir<'ignore> {
    parent: Option<&'ignore IgnoreDir<'ignore>>,
    gitignores: Vec<Gitignore>,
}

impl<'ignore> IgnoreDir<'ignore> {
    pub(crate) fn new(dir: &Path) -> anyhow::Result<Self> {
        let global_gitignore = match GitignoreBuilder::new("").build_global() {
            (_, Some(err)) => panic!("{err}"),
            (gitignore, None) => gitignore,
        };
        let mut gitignores = vec![global_gitignore];

        let canonicalized_root = dir.canonicalize().with_context(|| {
            format!(
                "Failed to canonicalize directory ({})",
                dir.to_string_lossy(),
            )
        })?;
        let mut path_components = canonicalized_root.components();

        let mut current_dir = if let Some(root) = path_components.next() {
            PathBuf::from(root.as_os_str())
        } else {
            return Ok(Self {
                parent: None,
                gitignores,
            });
        };

        for path_component in path_components {
            current_dir = current_dir.join(path_component.as_os_str());
            let mut builder = GitignoreBuilder::new(&current_dir);
            let gitignore_path = current_dir.join(".gitignore");
            if gitignore_path.exists() {
                if let Some(err) = builder.add(&gitignore_path) {
                    return Err(err).context(format!(
                        "Failed to load {}",
                        gitignore_path.to_string_lossy()
                    ));
                }
            }
            gitignores.push(
                builder.build().with_context(|| {
                    format!("Failed to load {}", gitignore_path.to_string_lossy())
                })?,
            );
        }

        // Reverse so the highest priority .gitignore is first
        gitignores.reverse();

        Ok(Self {
            parent: None,
            gitignores,
        })
    }

    pub(crate) fn enter_dir(&'ignore self, dir: &Path) -> anyhow::Result<Self> {
        let gitignore_path = dir.join(".gitignore");
        let gitignores =
            if gitignore_path.exists() {
                let mut builder = GitignoreBuilder::new(dir);
                if let Some(err) = builder.add(&gitignore_path) {
                    return Err(err).context(format!(
                        "Failed to load {}",
                        gitignore_path.to_string_lossy()
                    ));
                }
                vec![builder.build().with_context(|| {
                    format!("Failed to load {}", gitignore_path.to_string_lossy())
                })?]
            } else {
                vec![]
            };

        Ok(Self {
            parent: Some(self),
            gitignores,
        })
    }

    pub(crate) fn include(&self, path: &Path, is_dir: bool) -> bool {
        if is_dir && path.file_name().map(|name| name == ".git").unwrap_or(false) {
            return false;
        }

        for gitignore in &self.gitignores {
            let is_match = gitignore.matched(path, is_dir);

            if is_match.is_whitelist() {
                return true;
            }

            if is_match.is_ignore() {
                return false;
            }
        }

        if let Some(parent) = self.parent {
            parent.include(path, is_dir)
        } else {
            true
        }
    }
}