click-rs 1.0.0

A Rust port of Python's Click library for creating command-line interfaces
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
119
120
121
122
123
124

//! Validation example - demonstrates declarative parameter validation.
//!
//! Equivalent to Python Click's examples/validation/validation.py

use click::{echo, run, Result, TypeConverter};

/// A URL parameter type that validates HTTP/HTTPS URLs.
#[derive(Debug, Clone)]
struct UrlType;

/// Parsed URL components (simplified version of Python's urlparse result).
#[derive(Debug, Clone)]
struct ParsedUrl {
    scheme: String,
    netloc: String,
    path: String,
}

impl ParsedUrl {
    fn parse(url: &str) -> Option<Self> {
        let mut parts = url.splitn(2, "://");
        let scheme = parts.next()?.to_lowercase();
        let rest = parts.next()?;
        let (netloc, path) = if let Some(slash_pos) = rest.find('/') {
            (&rest[..slash_pos], &rest[slash_pos..])
        } else {
            (rest, "")
        };
        Some(Self {
            scheme,
            netloc: netloc.to_string(),
            path: path.to_string(),
        })
    }
}

impl std::fmt::Display for ParsedUrl {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "ParsedUrl(scheme='{}', netloc='{}', path='{}')",
            self.scheme, self.netloc, self.path
        )
    }
}

impl TypeConverter for UrlType {
    type Value = ParsedUrl;

    fn name(&self) -> &str {
        "URL"
    }

    fn convert(&self, value: &str) -> std::result::Result<Self::Value, String> {
        let parsed = ParsedUrl::parse(value).ok_or_else(|| format!("invalid URL: {}", value))?;
        if parsed.scheme != "http" && parsed.scheme != "https" {
            return Err(format!(
                "invalid URL scheme ({}). Only HTTP URLs are allowed",
                parsed.scheme
            ));
        }
        Ok(parsed)
    }

    fn get_metavar(&self) -> Option<String> {
        Some("URL".to_string())
    }
}

fn validate_count(value: &String) -> std::result::Result<(), String> {
    let count: i32 = value
        .parse()
        .map_err(|_| format!("'{}' is not a valid integer", value))?;
    if count < 0 || count % 2 != 0 {
        return Err("Should be a positive, even integer.".to_string());
    }
    Ok(())
}

fn validate_foo(value: &String) -> std::result::Result<(), String> {
    if value == "wat" {
        Ok(())
    } else {
        Err("If a value is provided it needs to be the value \"wat\".".to_string())
    }
}

#[click::command(name = "validation")]
fn validation(
    #[option(
        long,
        default = "2".to_string(),
        help = "A positive even number.",
        validate = validate_count
    )]
    count: String,
    #[option(long, help = "A mysterious parameter.", validate = validate_foo)]
    foo: Option<String>,
    #[option(long, help = "A URL", type = UrlType)]
    url: Option<ParsedUrl>,
) -> Result<()> {
    echo(&format!("count: {}", count), true, false, None);
    echo(
        &format!("foo: {}", foo.as_deref().unwrap_or("None")),
        true,
        false,
        None,
    );
    echo(
        &format!(
            "url: {}",
            url.map(|parsed| parsed.to_string())
                .unwrap_or_else(|| "None".to_string())
        ),
        true,
        false,
        None,
    );
    Ok(())
}

fn main() {
    run(&validation_command());
}