runiq-lib 1.2.2

An efficient way to filter duplicate lines from input, à la uniq.
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

//! Options parsing module used to configure application state.
//!
//! Nothing particularly important to see here, just typical
//! parsing of things like command line arguments into something
//! more easily used internally (from the main application flow).
use crate::filters::FilterKind;
use clap::{value_t, App, AppSettings, Arg, ArgSettings};
use std::ffi::OsString;

/// Options struct to store configuration state.
///
/// The options struct will basically contain anything relevant
/// to the execution of the application; things such as inputs
/// and flags to dictate behaviour will be stored here. It acts
/// (in essence) as application configuration.
#[derive(Clone, Debug)]
pub struct Options {
    pub filter: FilterKind,
    pub inputs: Vec<String>,
    pub inverted: bool,
    pub statistics: bool,
}

impl Options {
    /// Creates an `Options` struct from an iterable set of arguments.
    ///
    /// Arguments can be any kind of iterator, as long as they can be
    /// successfully cloned and parsed into an instance of `OsString`.
    pub fn from<I, T>(args: I) -> Options
    where
        I: IntoIterator<Item = T>,
        T: Into<OsString> + Clone,
    {
        // create a new parser for our args
        let parser = Options::create_parser();

        // parse out the arguments into matching opts
        let options = parser.get_matches_from(args);

        // attempt to parse the provided filter
        let filter = value_t!(options.value_of("filter"), FilterKind);

        // create opts
        Options {
            // grab and store statistics flags
            statistics: options.is_present("statistics"),

            // grab and store inversion flags
            inverted: options.is_present("invert"),

            // store the filter to use for unique detection
            filter: filter.unwrap_or(FilterKind::Digest),

            // own all inputs
            inputs: options
                .values_of("inputs")
                .unwrap()
                .map(|s| s.to_owned())
                .collect(),
        }
    }

    /// Creates a parser used to generate `Options`.
    ///
    /// All command line usage information can be found in the definitions
    /// below, and follows the API of the `clap` library.
    ///
    /// In terms of visibility, this method is defined on the struct due to
    /// the parser being specifically designed around the `Options` struct.
    fn create_parser<'a, 'b>() -> App<'a, 'b> {
        App::new("")
            // package metadata from cargo
            .name(env!("CARGO_PKG_NAME"))
            .about(env!("CARGO_PKG_DESCRIPTION"))
            .version(env!("CARGO_PKG_VERSION"))
            // arguments and flag details
            .args(&[
                // filter: -f, --filter [naive]
                Arg::with_name("filter")
                    .help("Filter to use to determine uniqueness")
                    .short("f")
                    .long("filter")
                    .takes_value(true)
                    .possible_values(&FilterKind::variants())
                    .set(ArgSettings::CaseInsensitive)
                    .set(ArgSettings::HideDefaultValue),
                // inputs: +required +multiple
                Arg::with_name("inputs")
                    .help("Input sources to filter")
                    .multiple(true)
                    .required(true),
                // invert: -i --invert
                Arg::with_name("invert")
                    .help("Prints duplicates instead of uniques")
                    .short("i")
                    .long("invert"),
                // statistics: -s --statistics
                Arg::with_name("statistics")
                    .help("Prints statistics instead of entries")
                    .short("s")
                    .long("statistics"),
            ])
            // settings required for parsing
            .settings(&[
                AppSettings::ArgRequiredElseHelp,
                AppSettings::HidePossibleValuesInHelp,
                AppSettings::TrailingVarArg,
            ])
    }
}