recurse 0.3.0

Recursive directory traversal file management tool
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

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

use anyhow::{anyhow, Result};

/// Returns a canonical absolute file path for the `filepath` argument.
/// This function will return an error in (at least) the following situations:
///
/// - The path does not exist.
/// - A non-final component in path is not a directory.
pub(crate) fn get_absolute_filepath<P>(filepath: P) -> Result<PathBuf>
where
    P: AsRef<Path>,
{
    match filepath.as_ref().canonicalize() {
        Ok(pb) => Ok(pb),
        Err(error) => Err(anyhow!(error)),
    }
}

/// Returns a boolean that indicates whether the `filepath` parameter
/// includes the `extension` file extension.  Also returns `false` in
/// cases where the filepath does not exist or there is no extension.
pub(crate) fn path_has_extension<P>(filepath: P, extension: &str) -> bool
where
    P: AsRef<Path>,
{
    match filepath.as_ref().extension() {
        Some(ext) => {
            // permissive comparison of the extension
            // allows for use of period character in
            // the parameter (e.g., `.txt`)
            if extension.starts_with(".") {
                return ext.to_str().unwrap() == &extension[1..];
            }
            // or no period character in the extension
            // parameter (e.g., `txt`)
            return ext.to_str().unwrap() == extension;
        }
        None => return false,
    }
}

/// Returns a boolean that indicates whether there is a dot directory
/// or dot file anywhere in the canonical absolute path to the file.
/// This is used as a filter during execution and requires a valid
/// file or directory path.  Panic is raised if the path is not valid.
pub(crate) fn path_is_hidden<P>(filepath: P) -> bool
where
    P: AsRef<Path>,
{
    match get_absolute_filepath(filepath) {
        Ok(pb) => {
            for path in pb.iter() {
                if path.to_str().unwrap().starts_with(".") {
                    return true;
                }
            }
            false
        }
        Err(_) => false,
    }
}

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

    // ======================================
    // get_absolute_filepath function tests
    // ======================================
    #[test]
    fn test_get_absolute_filepath_good_path() {
        let testpath = get_absolute_filepath("./Cargo.toml");
        assert!(testpath.is_ok());
        assert!(testpath.unwrap().ends_with("recurse/Cargo.toml"));
    }

    #[test]
    fn test_get_absolute_filepath_bad_path() {
        let testpath = get_absolute_filepath("./bogus.bad");
        assert!(testpath.is_err());
    }

    // ======================================
    // path_has_extension function tests
    // ======================================
    #[test]
    fn test_path_has_extension_with_correct_extension() {
        let testpath = Path::new("./tests/testfiles/path/test.txt");
        assert!(path_has_extension(testpath, ".txt"));
        assert!(path_has_extension(testpath, "txt"));
    }

    #[test]
    fn test_path_has_extension_with_incorrect_extension() {
        let testpath = Path::new("./tests/testfiles/path/test.txt");
        assert_eq!(path_has_extension(testpath, ".yaml"), false);
        assert_eq!(path_has_extension(testpath, "yaml"), false);
    }

    #[test]
    fn test_path_has_extension_with_no_extension() {
        let testpath = Path::new("./tests/testfiles/path/testfile");
        assert_eq!(path_has_extension(testpath, ".txt"), false);
        assert_eq!(path_has_extension(testpath, "txt"), false);
    }

    // ======================================
    // path_is_hidden function tests
    // ======================================
    #[test]
    fn test_path_is_hidden_with_dotfile() {
        let testpath = Path::new("./tests/testfiles/path/.testfile");
        assert!(path_is_hidden(testpath));
        assert!(path_is_hidden(testpath)); // confirm that we do not transfer ownership
    }

    #[test]
    fn test_path_is_hidden_with_dotfile_pathbuf() {
        let testpath = PathBuf::from("./tests/testfiles/path/.testfile");
        // Owned types need to be borrowed or ownership is relinquished and
        // raises panic
        assert!(path_is_hidden(&testpath)); // addressed by using &testpath
        assert!(path_is_hidden(testpath)); // ownership transitions on this call
    }

    #[test]
    fn test_path_is_hidden_with_dotdir_in_path() {
        let testpath = Path::new("./tests/testfiles/.dotdir/testfile");
        assert!(path_is_hidden(testpath));
    }

    #[test]
    fn test_path_is_hidden_with_dotdir_only() {
        let testpath = Path::new("./tests/testfiles/.dotdir");
        assert!(path_is_hidden(testpath));
    }

    #[test]
    fn test_path_is_not_hidden_without_dotfile_or_dotdir() {
        let testpath = Path::new("./tests/testfiles/path/testfile");
        assert_eq!(path_is_hidden(testpath), false);
    }
}