clap-digest 0.3.0

clap and digest integration
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

//! Contains ready-to-use [`clap::Arg`] implementations.
//!
//! # Examples
//!
//! ```
//! use clap::{Command, ValueEnum};
//! use clap_digest::{Digest, DynDigest};
//!
//! let cli = Command::new("myapp")
//!     .arg(clap_digest::arg::digest().required_unless_present("list-digests"))
//!     .arg(clap_digest::arg::list_digests());
//!
//! let args = cli.get_matches_from(["myapp", "--list-digests"]);
//!
//! if args.contains_id("list-digests") {
//!     for digest in Digest::value_variants() {
//!         println!("{digest}");
//!     }
//! } else {
//!     let digest = *args
//!         .get_one::<Digest>("digest")
//!         .expect("has default via clap");
//!
//!     todo!()
//! }
//! ```

use clap::builder::{Arg, ArgAction, EnumValueParser};

use crate::Digest;

/// Returns a ready-to-use [`clap::Arg`] to choose a supported digest
/// algorithm.
///
/// # Examples
///
/// ```
/// use clap::Command;
/// use clap_digest::Digest;
///
/// let cli = Command::new("myapp").arg(clap_digest::arg::digest());
/// let args = cli.get_matches_from(["myapp", "--digest", "MD5"]);
///
/// let digest = *args
///     .get_one::<Digest>("digest")
///     .unwrap();
///
/// assert_eq!(digest, Digest::MD5);
/// ```
#[must_use]
pub fn digest() -> Arg {
    Arg::new("digest")
        .short('d')
        .long("digest")
        .help("digest algorithm")
        .long_help(
            "Use this digest algorithm. These algorithms are optional \
             dependencies/features that may be chosen during compilation.",
        )
        .action(ArgAction::Set)
        .value_parser(EnumValueParser::<Digest>::new())
}

/// Returns a ready-to-use [`clap::Arg`] to list supported digest
/// algorithms.
///
/// # Examples
///
/// ```
/// use clap::Command;
///
/// let cli = Command::new("myapp").arg(clap_digest::arg::list_digests());
/// let args = cli.get_matches_from(["myapp", "--list-digests"]);
///
/// assert!(args.contains_id("list-digests"));
/// ```
#[must_use]
pub fn list_digests() -> Arg {
    Arg::new("list-digests")
        .long("list-digests")
        .action(ArgAction::SetTrue)
        .help("list supported digest algorithms")
}

// ----------------------------------------------------------------------------
// tests
// ----------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use clap::Command;

    #[test]
    fn list_digests() {
        let cli = Command::new("myapp").arg(crate::arg::list_digests());
        let args = cli.get_matches_from(["myapp", "--list-digests"]);
        assert!(args.contains_id("list-digests"));
    }
}