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
112
113
114

//! The source code in this file is Copyright (c) 2017 Gilad Naaman.
//!
//! Copied and modified as allowed per [`MIT license`], also listed below.
//!
//! Changes made:
//! * Now split to a function which returns the base/pattern instead of a glob walker and a function
//!     which creates the a GlobWalkerBuilder which can be further adapted to one's wishes
//! * Added error handling
//!
//! ```text
//! Copyright (c) 2017 Gilad Naaman
//!
//! Permission is hereby granted, free of charge, to any person obtaining a copy
//! of this software and associated documentation files (the "Software"), to deal
//! in the Software without restriction, including without limitation the rights
//! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//! copies of the Software, and to permit persons to whom the Software is
//! furnished to do so, subject to the following conditions:
//!
//! The above copyright notice and this permission notice shall be included in all
//! copies or substantial portions of the Software.
//!
//! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//! SOFTWARE.
//! ```
//!
//! [`MIT license`]: https://docs.rs/crate/globwalk/0.8.0/source/LICENSE

use anyhow::anyhow;
use globwalk::GlobWalkerBuilder;
use std::path::PathBuf;

/// Create a generic glob builder
pub fn glob_builder_base<PAT: AsRef<str>>(
    pattern: PAT,
    filters: &[PAT],
) -> anyhow::Result<GlobWalkerBuilder> {
    let (base, pat) = glob_base_unrooted(pattern.as_ref())?;

    let base_str: &str = base
        .to_str()
        .ok_or_else(|| anyhow!("Glob base path is not valid"))?;
    let pat_str: &str = pat
        .to_str()
        .ok_or_else(|| anyhow!("Glob pattern is not valid"))?;

    let mut filters = filters
        .iter()
        .map(|f| f.as_ref())
        .map(when_starts_with_dot_path)
        .collect::<Vec<_>>();
    filters.push(when_starts_with_dot_path(pat_str));

    Ok(GlobWalkerBuilder::from_patterns(
        when_starts_with_dot_path(base_str),
        &filters,
    ))
}

// FIXME: fix relative GlobWalkerBuilder with paths starting with "./" or ".\"
fn when_starts_with_dot_path(path: &str) -> &str {
    if path.starts_with("./") || path.starts_with(".\\") {
        &path[2..]
    } else {
        path
    }
}

pub type BasePath = PathBuf;
pub type Pattern = PathBuf;

/// Determine the longest possible base path
///
/// This function contains a partial copy of the [`globwalker::glob`] function
///
/// [`globwalker::glob`]: https://docs.rs/globwalk/0.8.0/src/globwalk/lib.rs.html#430
fn glob_base_unrooted(path_pattern: &str) -> anyhow::Result<(BasePath, Pattern)> {
    let path_buf = path_pattern.parse::<PathBuf>()?;

    Ok(if path_buf.is_absolute() {
        // If the pattern is an absolute path, split it into the longest base and a pattern.
        let mut base = PathBuf::new();
        let mut pattern = PathBuf::new();
        let mut globbing = false;

        // All `to_str().unwrap()` calls should be valid since the input is a string.
        for c in path_buf.components() {
            let os = c.as_os_str().to_str().unwrap();

            for c in &["*", "{", "}"][..] {
                if os.contains(c) {
                    globbing = true;
                    break;
                }
            }

            if globbing {
                pattern.push(c);
            } else {
                base.push(c);
            }
        }

        (base, pattern)
    } else {
        // If the pattern is relative, start searching from the current directory.
        (".".parse().unwrap(), path_buf)
    })
}