rnr 0.3.0

RnR is a command-line tool to rename multiple files and directories that supports regular expressions 
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use clap::{App, AppSettings, Arg, SubCommand};
use std::ffi::{OsStr, OsString};

/// Create application using clap. It sets all options and command-line help.
pub fn create_app<'a>() -> App<'a, 'a> {
    App::new(crate_name!())
        .setting(AppSettings::SubcommandsNegateReqs)
        .version(crate_version!())
        .author(crate_authors!())
        .about(crate_description!())
        .arg(
            Arg::with_name("EXPRESSION")
                .help("Expression to match (can be a regex)")
                .required(true)
                .validator_os(is_valid_string)
                .index(1),
        )
        .arg(
            Arg::with_name("REPLACEMENT")
                .help("Expression replacement")
                .required(true)
                .validator_os(is_valid_string)
                .index(2),
        )
        .arg(
            Arg::with_name("PATH(S)")
                .help("Target paths")
                .validator_os(is_valid_string)
                .multiple(true)
                .required(true),
        )
        .arg(
            Arg::with_name("dry-run")
                .long("dry-run")
                .short("n")
                .help("Only show what would be done (default mode)")
                .global(true)
                .conflicts_with("force"),
        )
        .arg(
            Arg::with_name("force")
                .long("force")
                .short("f")
                .global(true)
                .help("Make actual changes to files"),
        )
        .arg(
            Arg::with_name("backup")
                .long("backup")
                .short("b")
                .global(true)
                .help("Generate file backups before renaming"),
        )
        .arg(
            Arg::with_name("include-dirs")
                .long("include-dirs")
                .short("D")
                .help("Rename matching directories"),
        )
        .arg(
            Arg::with_name("recursive")
                .long("recursive")
                .short("r")
                .help("Recursive mode"),
        )
        .arg(
            Arg::with_name("max-depth")
                .requires("recursive")
                .long("max-depth")
                .short("d")
                .takes_value(true)
                .value_name("LEVEL")
                .validator(is_integer)
                .help("Set max depth in recursive mode"),
        )
        .arg(
            Arg::with_name("hidden")
                .requires("recursive")
                .long("hidden")
                .short("x")
                .help("Include hidden files and directories"),
        )
        .arg(
            Arg::with_name("silent")
                .long("silent")
                .short("s")
                .global(true)
                .help("Do not print any information"),
        )
        .arg(
            Arg::with_name("color")
                .long("color")
                .possible_values(&["always", "auto", "never"])
                .default_value("auto")
                .global(true)
                .help("Set color output mode"),
        )
        .arg(
            Arg::with_name("dump")
                .long("dump")
                .help("Force dumping operations into a file even in dry-run mode")
                .global(true)
                .conflicts_with("no-dump"),
        )
        .arg(
            Arg::with_name("no-dump")
                .long("no-dump")
                .help("Do not dump operations into a file")
                .global(true)
                .conflicts_with("dump"),
        )
        .arg(
            Arg::with_name("replace-limit")
                .long("replace-limit")
                .short("l")
                .takes_value(true)
                .value_name("LIMIT")
                .default_value("1")
                .validator(is_integer)
                .help("Limit of replacements, all matches if set to 0"),
        )
        .subcommand(
            SubCommand::with_name("from-file")
                .arg(
                    Arg::with_name("DUMPFILE")
                        .takes_value(true)
                        .required(true)
                        .value_name("DUMPFILE")
                        .validator_os(is_valid_string)
                        .index(1),
                )
                .arg(
                    Arg::with_name("undo")
                        .long("undo")
                        .short("u")
                        .help("Undo the operations from the dump file"),
                )
                .about("Read operations from a dump file"),
        )
}
#[allow(clippy::all)]
/// Check if the input provided is valid unsigned integer
fn is_integer(arg_value: String) -> Result<(), String> {
    match arg_value.parse::<usize>() {
        Ok(_) => Ok(()),
        Err(_) => Err("Value provided is not an integer".to_string()),
    }
}
/// Check if the input provided is valid UTF-8
fn is_valid_string(os_str: &OsStr) -> Result<(), OsString> {
    match os_str.to_str() {
        Some(_) => Ok(()),
        None => Err(OsString::from("Value provided is not a valid UTF-8 string")),
    }
}

#[cfg(test)]
mod test {}