runiq 2.1.0

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
111
112
113
114
115
116
117
118

//! 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 clap::{value_parser, Arg, ArgAction, Command};
use runiq::Filters;
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: Filters,
    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 = options.get_one::<Filters>("filter");

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

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

            // store the filter to use for unique detection
            filter: filter.unwrap().to_owned(),

            // own all inputs
            inputs: options
                .get_many::<String>("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() -> Command {
        Command::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::new("filter")
                    .help("Filter to use to determine uniqueness")
                    .short('f')
                    .long("filter")
                    .num_args(1)
                    .value_parser(value_parser!(Filters))
                    .hide_default_value(true)
                    .default_value("quick")
                    .ignore_case(true),
                // inputs: +required +multiple
                Arg::new("inputs")
                    .help("Input sources to filter")
                    .action(ArgAction::Append)
                    .hide_default_value(true)
                    .default_value("-"),
                // invert: -i --invert
                Arg::new("invert")
                    .help("Prints duplicates instead of uniques")
                    .short('i')
                    .long("invert")
                    .action(ArgAction::SetTrue),
                // statistics: -s --statistics
                Arg::new("statistics")
                    .help("Prints statistics instead of entries")
                    .short('s')
                    .long("statistics")
                    .action(ArgAction::SetTrue),
                // help: -h, --help
                Arg::new("help")
                    .short('h')
                    .long("help")
                    .action(ArgAction::HelpLong)
                    .hide(true),
            ])
            // settings required for parsing
            .disable_help_subcommand(true)
            .disable_help_flag(true)
            .trailing_var_arg(true)
    }
}