filerefine 0.1.9

🧹 FileRefine is a Rust-based CLI tool that renames files in a directory to remove unwanted or problematic characters from filenames.
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

#[cfg(test)]
mod tests {
    use std::{os::unix::fs::PermissionsExt, path::PathBuf};

    #[test]
    fn test_parse_args_clean_directory() {
        let dir = "src".to_owned();
        let vec_args = vec!["filerefine".to_owned(), dir.clone(), "-j".to_owned()];
        let res = filerefine::parse_args(vec_args);
        let (options, vect) = res.ok().unwrap();
        let res_path = filerefine::filerefine(&options, vect);
        let number = std::fs::read_dir(dir)
            .ok()
            .unwrap()
            .filter(|entry| entry.is_ok())
            .count();
        assert_eq!(
            options,
            filerefine::OptionnalFields {
                options: filerefine::OptionsFields { dry_run: true },
                verbosity: filerefine::VerbosityFields {
                    verbose: false,
                    json: true,
                    json_pretty: false,
                    json_error: false,
                },
            }
        );
        assert_eq!(res_path.len(), number + 1);
    }

    #[test]
    fn test_check_similars_void() {
        let res = filerefine::check_similar(vec![], &mut String::new(), false);
        assert_eq!(res, false);
    }

    fn setup(dir: &String) {
        let directory_path = PathBuf::from(&dir);
        std::fs::create_dir(&directory_path).unwrap();
        std::fs::File::create(directory_path.join("test 1.txt")).unwrap();
        std::fs::File::create(directory_path.join("test_2.txt")).unwrap();
        let mut second_level = dir.clone();
        second_level.push_str(" second");
        let second_level = &directory_path.join(&second_level);
        std::fs::create_dir(&second_level).unwrap();
        std::fs::File::create(second_level.join("test 3.txt")).unwrap();
        std::fs::File::create(second_level.join("test_4.txt")).unwrap();
        std::fs::File::create(second_level.join("test_5.txt")).unwrap();

        // permissions file
        let mut perms = std::fs::metadata(&second_level.join("test_5.txt"))
            .unwrap()
            .permissions();
        perms.set_mode(0o000);
        std::fs::set_permissions(&second_level.join("test_5.txt"), perms).unwrap();
        // permissions firectory
        let mut perms = std::fs::metadata(&second_level).unwrap().permissions();
        perms.set_mode(0o000);
        std::fs::set_permissions(&second_level, perms).unwrap();
    }

    fn cleanup(dir: &String) {
        let directory_path = PathBuf::from(&dir);
        std::fs::remove_file(directory_path.join("test_1.txt")).unwrap();
        std::fs::remove_file(directory_path.join("test_2.txt")).unwrap();
        let mut second_level = dir.clone();
        second_level.push_str("_second");
        let second_level = &directory_path.join(&second_level);
        let mut perms = std::fs::metadata(&second_level).unwrap().permissions();
        perms.set_mode(0o777);
        std::fs::set_permissions(&second_level, perms).unwrap();
        std::fs::remove_file(second_level.join("test 3.txt")).unwrap();
        std::fs::remove_file(second_level.join("test_4.txt")).unwrap();

        // test 5
        let mut perms = std::fs::metadata(&second_level.join("test_5.txt"))
            .unwrap()
            .permissions();
        perms.set_mode(0o777);
        std::fs::set_permissions(&second_level.join("test_5.txt"), perms).unwrap();
        std::fs::remove_file(second_level.join("test_5.txt")).unwrap();

        // other
        std::fs::remove_dir(&second_level).unwrap();
        std::fs::remove_dir_all(&directory_path).unwrap();
    }

    #[test]
    fn test_parse_args_clean_directory_recursive() {
        let dir = "test_folder".to_owned();
        setup(&dir);

        let vec_args = vec![
            "filerefine".to_owned(),
            dir.clone(),
            "-j".to_owned(),
            "-d".to_owned(),
        ];
        let res = filerefine::parse_args(vec_args);
        let (options, vect) = res.ok().unwrap();
        let res_path = filerefine::filerefine(&options, vect);

        assert_eq!(
            options,
            filerefine::OptionnalFields {
                options: filerefine::OptionsFields { dry_run: false },
                verbosity: filerefine::VerbosityFields {
                    verbose: false,
                    json: true,
                    json_pretty: false,
                    json_error: false,
                },
            }
        );
        assert_eq!(res_path.len(), 5);
        cleanup(&dir);
    }
}