us_time_parser 0.1.2

A Rust utility for parsing and validating time components using pest and clap crates.
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

use anyhow::*;
use pest::Parser;
use pest_derive::Parser;

#[derive(Parser)]
#[grammar = "grammar.pest"]
pub struct TimeParser;

// Parse the input string as a time using the 'time' rule
pub fn parse_time(input: &str) -> anyhow::Result<pest::iterators::Pairs<'_, Rule>> {
    let parse = TimeParser::parse(Rule::time, input)?;
    Ok(parse)
}

// Parse the input string as an hour using the 'hour' rule
pub fn parse_hour(input: &str) -> anyhow::Result<pest::iterators::Pairs<'_, Rule>> {
    let parse = TimeParser::parse(Rule::hour, input)?;
    Ok(parse)
}

// Parse the input string as a minute using the 'minute' rule
pub fn parse_minute(input: &str) -> anyhow::Result<pest::iterators::Pairs<'_, Rule>> {
    let parse = TimeParser::parse(Rule::minute, input)?;
    Ok(parse)
}

// Parse the input string as a second using the 'second' rule
pub fn parse_second(input: &str) -> anyhow::Result<pest::iterators::Pairs<'_, Rule>> {
    let parse = TimeParser::parse(Rule::second, input)?;
    Ok(parse)
}

// Parse the input string as AM/PM using the 'am_pm' rule
pub fn parse_am_pm(input: &str) -> anyhow::Result<pest::iterators::Pairs<'_, Rule>> {
    let parse = TimeParser::parse(Rule::am_pm, input)?;
    Ok(parse)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_time_valid() {
        assert!(parse_time("12:34").is_ok());
        assert!(parse_time("23:59:59").is_ok());
        assert!(parse_time("11:45 PM").is_ok());
        assert!(parse_time("11:45a.m.").is_ok());
    }

    #[test]
    fn test_parse_time_invalid() {
        assert!(parse_time("25:00").is_err());
        assert!(parse_time("12:60:00").is_err());
        assert!(parse_time("3:45 BM").is_err());
    }

    #[test]
    fn test_parse_hour_valid() {
        assert!(parse_hour("12").is_ok());
        assert!(parse_hour("00").is_ok());
        assert!(parse_hour("23").is_ok());
    }

    #[test]
    fn test_parse_hour_invalid() {
        assert!(parse_hour("24").is_err());
        assert!(parse_hour("9").is_err());
        assert!(parse_hour("60").is_err());
    }

    #[test]
    fn test_parse_minute_valid() {
        assert!(parse_minute("00").is_ok());
        assert!(parse_minute("59").is_ok());
        assert!(parse_minute("05").is_ok());
    }

    #[test]
    fn test_parse_minute_invalid() {
        assert!(parse_minute("60").is_err());
        assert!(parse_minute("abcd").is_err());
    }

    #[test]
    fn test_parse_second_valid() {
        assert!(parse_second("00").is_ok());
        assert!(parse_second("59").is_ok());
        assert!(parse_second("05").is_ok());
    }

    #[test]
    fn test_parse_second_invalid() {
        assert!(parse_second("60").is_err());
        assert!(parse_second("abcd").is_err());
    }

    #[test]
    fn test_parse_am_pm_valid() {
        assert!(parse_am_pm("AM").is_ok());
        assert!(parse_am_pm("PM").is_ok());
        assert!(parse_am_pm("am").is_ok());
        assert!(parse_am_pm("pm").is_ok());
    }

    #[test]
    fn test_parse_am_pm_invalid() {
        assert!(parse_am_pm("xxx").is_err());
        assert!(parse_am_pm("noon").is_err());
    }
}