xloc 0.2.0

A fast, multi-threaded line counting utility written in Rust.
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

use clap::{App, Arg};

pub struct Parser {
    pub njobs: usize,
    pub paths: Vec<String>,
    pub words: bool,
}

impl Parser {
    pub fn new() -> Self {
        let cli = App::new("xloc")
            .version("0.1.0")
            .about("A fast, multi-threaded line counting utility")
            .arg(
                Arg::with_name("jobs")
                    .short("j")
                    .long("jobs")
                    .value_name("NUM")
                    .help("The number of jobs (threads) to run")
                    .takes_value(true)
                    .default_value("1"),
            )
            .arg(
                Arg::with_name("words")
                    .short("w")
                    .long("--words")
                    .help("If included, count words instead of lines")
                    .takes_value(false),
            )
            .arg(
                Arg::with_name("path")
                    .help("The path or paths to parse")
                    .takes_value(true)
                    .multiple(true)
                    .required(true)
                    .default_value("."),
            );

        let matches = cli.get_matches();
        let words = matches.is_present("words");

        let paths = matches
            .values_of("path")
            .unwrap()
            .map(|p| p.to_string())
            .collect::<Vec<String>>();

        let njobs = matches
            .value_of("jobs")
            .unwrap()
            .parse::<usize>()
            .unwrap_or(1);

        Self {
            njobs,
            paths,
            words,
        }
    }
}

#[cfg(test)]
mod parser_tests {
    use super::Parser;

    #[test]
    fn new_parser() {
        let parser = Parser::new();
        assert_eq!(parser.njobs, 1);
        assert_eq!(parser.paths, vec!["."]);
        assert_eq!(parser.words, false);
    }

    #[test]
    fn mut_parser() {
        let mut parser = Parser::new();
        parser.njobs = 3;
        parser.paths = vec!["tests/data".to_owned()];
        parser.words = true;

        assert_eq!(parser.njobs, 3);
        assert_eq!(parser.paths, vec!["tests/data"]);
        assert_eq!(parser.words, true);
    }
}