app 0.6.5

A easy-to-use command-line-parser.
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

extern crate app;
use app::{App, Args, Opt};

use std::path::PathBuf;

fn main() {
    Config::parse_args().call()
}

impl Config {
    fn call(self) {
        println!("call:\n{:?}", self);
        //do some work
    }
    fn parse_args() -> Self {
        let mut config = Config::default();

        let helper = {
            App::new("cp")
                .version("0.6.0")
                .author("Wspsxing", "biluohc@qq.com")
                .addr(
                    "Github",
                    "https://github.com/biluohc/app/blob/master/examples/cp.rs",
                )
                .desc("Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.")
                .opt(
                    Opt::new("force", &mut config.force)
                        .short('f')
                        .long("force")
                        .help("if an existing destination file cannot be opened, remove it and try again"),
                )
                .opt(
                    Opt::new("recursive", &mut config.recursive)
                        .short('r')
                        .long("recursive")
                        .help("Recursively copy all content within a directory and its subdirectories"),
                )
                .args(Args::new("SOURCE", &mut config.source).help("CP the SOURCE(s) to DEST"))
                .args(
                    Args::new("DEST", &mut config.dest)
                        .len(1usize)
                        .help("DEST Path"),
                )
                .parse_args()
        };
        config
            .check()
            .map_err(|e| helper.help_err_exit(e, 1))
            .unwrap() // map_err alrendy exit if it is err, so unwrap is safe.
    }
    fn check(self) -> Result<Self, String> {
        println!("check:\n{:?}", self);
        for path in &self.source {
            if !path.as_path().exists() {
                return Err(format!("Args(SOURCE): {:?} is not exists", path));
            }
        }
        Ok(self)
    }
}

#[derive(Debug, Default)]
pub struct Config {
    pub recursive: bool,
    pub force: bool,
    pub source: Vec<PathBuf>,
    pub dest: Vec<PathBuf>,
}