fwatcher 0.4.2

Auto run command when some files changed.
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

extern crate glob;
extern crate getopts;
extern crate fwatcher;

use fwatcher::Fwatcher;
use getopts::{HasArg, Occur, Options, ParsingStyle};
use glob::Pattern;
use std::{env, process};
use std::path::PathBuf;
use std::time::Duration;

fn main() {
    let mut opts = Options::new();
    opts.parsing_style(ParsingStyle::StopAtFirstFree);
    opts.optflag("h", "help", "Display this message");
    opts.optflag("v", "version", "Print version info");
    opts.optflag("r", "restart", "Auto restart command, default to false");
    opts.opt("d",
             "directory",
             "Watch directory, default to current directory",
             "<dir>",
             HasArg::Yes,
             Occur::Multi);
    opts.opt("p",
             "pattern",
             r#"Watch file glob pattern, default to "*""#,
             "<pattern>",
             HasArg::Yes,
             Occur::Multi);
    opts.opt("P",
             "exclude_pattern",
             "Watch file glob pattern exclusively, default null",
             "<exclude_pattern>",
             HasArg::Yes,
             Occur::Multi);
    opts.opt("",
             "delay",
             "Delay in seconds for watcher, default to 2",
             "<second>",
             HasArg::Yes,
             Occur::Optional);
    opts.opt("i",
             "interval",
             "Interval in seconds to scan filesystem, default to 1",
             "<second>",
             HasArg::Yes,
             Occur::Optional);

    let args: Vec<_> = env::args().collect();
    let matches = match opts.parse(&args[1..]) {
        Ok(m) => m,
        Err(why) => {
            eprintln!("{}", why);
            eprintln!("run `fwatcher -h` to get the usage.");
            process::exit(1);
        },
    };

    if matches.opt_present("h") {
        print_usage_and_exit(opts, 0);
    } else if matches.opt_present("v") {
        println!("fwatcher {}", env!("CARGO_PKG_VERSION"));
        process::exit(0);
    } else if matches.free.len() == 0 {
        print_usage_and_exit(opts, 1);
    }

    let dirs: Vec<_> = matches.opt_strs("directory")
                              .iter()
                              .map(|dir| PathBuf::from(dir))
                              .collect();
    let mut patterns: Vec<_> =
        matches.opt_strs("pattern")
               .iter()
               .map(|dir| Pattern::new(dir).expect("create pattern error"))
               .collect();
    if patterns.is_empty() {
        patterns.push(Pattern::new("*").unwrap());
    }
    let exclude_patterns: Vec<_> =
        matches.opt_strs("exclude_pattern")
               .iter()
               .map(|dir| Pattern::new(dir).expect("create pattern error"))
               .collect();
    let delay = matches.opt_str("delay")
                       .map(|i| i.parse().expect("parse delay option error"))
                       .or(Some(2))
                       .map(|i| Duration::new(i, 0))
                       .unwrap();
    let interval = matches.opt_str("interval")
                          .map(|i| i.parse().expect("parse interval option error"))
                          .or(Some(1))
                          .map(|i| Duration::new(i, 0))
                          .unwrap();
    let restart = matches.opt_present("restart");
    let mut fwatcher = Fwatcher::new(dirs, matches.free);
    fwatcher.patterns(&patterns)
            .exclude_patterns(&exclude_patterns)
            .delay(delay)
            .interval(interval)
            .restart(restart)
            .run();
}

fn print_usage_and_exit(opts: Options, exit_code: i32) -> ! {
    let brief = "\
Usage:
    fwatcher [options] CMD";
    if exit_code == 0 {
        print!("{}", opts.usage(brief));
    } else {
        eprint!("{}", opts.usage(brief));
    }
    process::exit(exit_code);
}