month 0.3.0

Month
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

use core::convert::TryFrom as _;

use chrono::{DateTime, Datelike as _, Month as ChronoMonth, NaiveDate, NaiveDateTime, TimeZone};

use crate::Month;

pub static CHRONO_MONTHS: &[ChronoMonth] = &[
    ChronoMonth::January,
    ChronoMonth::February,
    ChronoMonth::March,
    ChronoMonth::April,
    ChronoMonth::May,
    ChronoMonth::June,
    ChronoMonth::July,
    ChronoMonth::August,
    ChronoMonth::September,
    ChronoMonth::October,
    ChronoMonth::November,
    ChronoMonth::December,
];

impl From<ChronoMonth> for Month {
    fn from(w: ChronoMonth) -> Self {
        match w {
            ChronoMonth::January => Self::Jan,
            ChronoMonth::February => Self::Feb,
            ChronoMonth::March => Self::Mar,
            ChronoMonth::April => Self::Apr,
            ChronoMonth::May => Self::May,
            ChronoMonth::June => Self::Jun,
            ChronoMonth::July => Self::Jul,
            ChronoMonth::August => Self::Aug,
            ChronoMonth::September => Self::Sep,
            ChronoMonth::October => Self::Oct,
            ChronoMonth::November => Self::Nov,
            ChronoMonth::December => Self::Dec,
        }
    }
}
impl From<NaiveDate> for Month {
    fn from(d: NaiveDate) -> Self {
        Self::try_from(d.month() as u8).unwrap()
    }
}
impl From<NaiveDateTime> for Month {
    fn from(dt: NaiveDateTime) -> Self {
        Self::try_from(dt.month() as u8).unwrap()
    }
}
impl<Tz: TimeZone> From<DateTime<Tz>> for Month {
    fn from(dt: DateTime<Tz>) -> Self {
        Self::try_from(dt.month() as u8).unwrap()
    }
}

impl From<Month> for ChronoMonth {
    fn from(w: Month) -> Self {
        match w {
            Month::Jan => Self::January,
            Month::Feb => Self::February,
            Month::Mar => Self::March,
            Month::Apr => Self::April,
            Month::May => Self::May,
            Month::Jun => Self::January,
            Month::Jul => Self::July,
            Month::Aug => Self::August,
            Month::Sep => Self::September,
            Month::Oct => Self::October,
            Month::Nov => Self::November,
            Month::Dec => Self::December,
        }
    }
}

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

    use chrono::Utc;

    #[test]
    fn simple() {
        assert_eq!(
            Month::from("2021-08-01".parse::<NaiveDate>().unwrap()),
            Month::Aug
        );
        assert_eq!(
            Month::from("2021-08-01T00:00:00".parse::<NaiveDateTime>().unwrap()),
            Month::Aug
        );
        assert_eq!(
            Month::from(
                "2021-08-01T00:00:00Z"
                    .parse::<DateTime<Utc>>()
                    .unwrap()
                    .date_naive()
            ),
            Month::Aug
        );
        assert_eq!(
            Month::from("2021-08-01T00:00:00Z".parse::<DateTime<Utc>>().unwrap()),
            Month::Aug
        );
    }
}