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

use config::Options;
use ignore::types::TypesBuilder;
use ignore::{Error, Walk, WalkBuilder};
use std::path::Path;

/// Returns a Result for Walker based on options passed in.
pub fn build(opt: &Options) -> Result<Walk, Error> {
    let mut walker = WalkBuilder::new(opt.root.clone().unwrap_or(String::from(".")));
    let mut builder = TypesBuilder::new();

    if let Some(ref pattern) = opt.pattern {
        builder.add("custom", &format!("*{}*", pattern))?;
        builder.select("custom");
    }

    if let Some(ref extension) = opt.extension {
        builder.add("ext", &format!("*.{}", extension))?;
        builder.select("ext");
    }

    let types = builder.build()?;

    walker.types(types);
    walker.follow_links(opt.follow_sym_links);
    walker.max_depth(opt.max_depth);
    walker.hidden(!opt.show_hidden);
    walker.git_ignore(!opt.show_hidden);
    walker.sort_by_file_name(|a, b| a.cmp(b));

    Ok(walker.build())
}

/// Returns a Result for shallow Walker that has the near equilvalent search settings as normal walk.
/// It always only traverses with depth 1
pub fn build_shallow(path: &Path, opt: &Options) -> Result<Walk, Error> {
    let path = path
        .to_str()
        .expect("Invalid UTF8 path given to build_shallow")
        .to_string();

    let shallow_options = Options::new(
        Some(path),
        Some(1),
        false,
        opt.show_hidden,
        opt.dir_only,
        opt.pattern.clone(),
        opt.extension.clone(),
        opt.line_count,
        opt.no_colours,
    );

    build(&shallow_options)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn options() -> Options {
        Options::new(
            Some(String::from(".")),
            Some(1),
            true,
            true,
            false,
            None,
            None,
            true,
            false,
        )
    }

    #[test]
    fn build_naive_works() {
        let walker = build(&options());

        match walker {
            Ok(_) => assert!(true),
            Err(err) => panic!(err),
        }
    }

    #[test]
    fn build_shallow_naive_works() {
        let path = Path::new(".");
        let walker = build_shallow(path, &options());

        match walker {
            Ok(_) => assert!(true),
            Err(err) => panic!(err),
        }
    }
}