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
159
160
161
162
163

use app::create_app;
use atty;
use output::Printer;
use regex::Regex;
use std::sync::Arc;

/// This module is defined Config struct to carry application configuration. This struct is created
/// from the parsed arguments from command-line input using `clap`. Only UTF-8 valid arguments are
/// considered.
pub struct Config {
    pub expression: Regex,
    pub replacement: String,
    pub force: bool,
    pub backup: bool,
    pub dirs: bool,
    pub dump: bool,
    pub mode: RunMode,
    pub printer: Printer,
    pub limit: usize,
}

impl Config {
    pub fn new() -> Result<Arc<Config>, String> {
        let config = match parse_arguments() {
            Ok(config) => config,
            Err(err) => return Err(err),
        };
        Ok(Arc::new(config))
    }
}

pub enum RunMode {
    Simple(Vec<String>),
    Recursive {
        paths: Vec<String>,
        max_depth: Option<usize>,
        hidden: bool,
    },
    FromFile {
        path: String,
        undo: bool,
    },
}

/// Parse arguments and do some checking.
fn parse_arguments() -> Result<Config, String> {
    let app = create_app();
    let matches = app.get_matches();

    // Set output mode
    let printer = if matches.is_present("silent") {
        Printer::silent()
    } else {
        match matches.value_of("color").unwrap_or("auto") {
            "always" => Printer::color(),
            "never" => Printer::no_color(),
            "auto" | _ => detect_output_color(),
        }
    };

    // Get and validate regex expression and replacement from arguments
    let expression = match Regex::new(matches.value_of("EXPRESSION").unwrap_or_default()) {
        Ok(expr) => expr,
        Err(err) => {
            return Err(format!(
                "{}Bad expression provided\n\n{}",
                printer.colors.error.paint("Error: "),
                printer.colors.error.paint(err.to_string())
            ));
        }
    };
    let replacement = String::from(matches.value_of("REPLACEMENT").unwrap_or_default());

    // Detect run mode and set parameters accordingly
    let input_paths: Vec<String> = matches
        .values_of("PATH(S)")
        .unwrap_or_default()
        .map(String::from)
        .collect();

    let mode = if matches.is_present("from-file") {
        let submatches = match matches.subcommand_matches("from-file") {
            Some(matches) => matches,
            None => {
                return Err(format!(
                    "{}Empty from-file subcommand provided\n\n",
                    printer.colors.error.paint("Error: ")
                ))
            }
        };

        RunMode::FromFile {
            path: String::from(submatches.value_of("DUMPFILE").unwrap_or_default()),
            undo: submatches.is_present("undo"),
        }
    } else if matches.is_present("recursive") {
        let max_depth = if matches.is_present("max-depth") {
            Some(
                matches
                    .value_of("max-depth")
                    .unwrap_or_default()
                    .parse::<usize>()
                    .unwrap_or_default(),
            )
        } else {
            None
        };

        RunMode::Recursive {
            paths: input_paths,
            max_depth,
            hidden: matches.is_present("hidden"),
        }
    } else {
        RunMode::Simple(input_paths)
    };

    // Set dump defaults: write in force mode and do not in dry-run unless it is explicitly asked
    let dump = if matches.is_present("force") {
        !matches.is_present("no-dump")
    } else {
        matches.is_present("dump")
    };

    let limit = matches
        .value_of("replace-limit")
        .unwrap_or_default()
        .parse::<usize>()
        .unwrap_or_default();

    Ok(Config {
        expression,
        replacement,
        force: matches.is_present("force"),
        backup: matches.is_present("backup"),
        dirs: matches.is_present("include-dirs"),
        dump,
        mode,
        printer,
        limit,
    })
}

/// Detect if output must be colored and returns a properly configured printer.
fn detect_output_color() -> Printer {
    if atty::is(atty::Stream::Stdout) {
        #[cfg(not(windows))]
        {
            Printer::color()
        }
        // Enable color support for Windows 10
        #[cfg(windows)]
        {
            use ansi_term;
            match ansi_term::enable_ansi_support() {
                Ok(_) => Printer::color(),
                Err(_) => Printer::no_color(),
            }
        }
    } else {
        Printer::no_color()
    }
}