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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
use crate::error::{Error, ErrorKind};
use serde::{de, Deserialize, Serialize};
use std::str::FromStr;
pub(crate) const YEAR_MIN: u32 = 2000;
pub(crate) const YEAR_MAX: u32 = YEAR_MIN + 100;
#[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord, Serialize)]
pub struct Date(String);
impl Date {
pub fn year(&self) -> u32 {
self.component(0).expect("has year")
}
pub fn month(&self) -> u32 {
self.component(1).expect("has month")
}
pub fn day(&self) -> u32 {
self.component(2).expect("has day")
}
pub fn as_str(&self) -> &str {
self.0.as_ref()
}
fn component(&self, index: usize) -> Option<u32> {
self.0
.split('-')
.nth(index)
.map(|cmp| cmp.parse().expect("numerical date components"))
}
}
impl<'de> Deserialize<'de> for Date {
fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use de::Error;
let string = String::deserialize(deserializer)?;
string.parse().map_err(D::Error::custom)
}
}
impl AsRef<str> for Date {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl FromStr for Date {
type Err = Error;
fn from_str(rfc3339_date: &str) -> Result<Self, Error> {
validate_date(rfc3339_date)?;
Ok(Date(rfc3339_date.into()))
}
}
impl Into<String> for Date {
fn into(self) -> String {
self.0
}
}
macro_rules! check_date_part {
($name:expr, $string:expr, $parts:expr, $len:expr, $min:expr, $max:expr) => {
let part = $parts
.next()
.ok_or_else(|| format_err!(ErrorKind::Parse, "invalid date: {}", $string))?;
if part.len() != $len {
fail!(ErrorKind::Parse, "malformed {}: {}", $name, $string);
}
match part.parse::<u32>() {
Ok($min..=$max) => (),
_ => fail!(ErrorKind::Parse, "malformed {}: {}", $name, $string),
}
};
}
fn validate_date(string: &str) -> Result<(), Error> {
let mut parts = string.split('-');
check_date_part!("year", string, parts, 4, YEAR_MIN, YEAR_MAX);
check_date_part!("month", string, parts, 2, 1, 12);
check_date_part!("day", string, parts, 2, 1, 31);
if parts.next().is_some() {
fail!(ErrorKind::Parse, "invalid date: {}", string)
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::Date;
use std::str::FromStr;
#[test]
fn from_str_test() {
assert!(Date::from_str("2000-01-01").is_ok());
assert!(Date::from_str("2017-01-01").is_ok());
assert!(Date::from_str("2099-12-31").is_ok());
assert!(Date::from_str("derp").is_err());
assert!(Date::from_str("1999-12-31").is_err());
assert!(Date::from_str("02017-01-01").is_err());
assert!(Date::from_str("2017-00-01").is_err());
assert!(Date::from_str("2017-01-00").is_err());
assert!(Date::from_str("2017-13-01").is_err());
assert!(Date::from_str("2017-01-32").is_err());
assert!(Date::from_str("2017-01-").is_err());
assert!(Date::from_str("2017-01-01-01").is_err());
}
#[test]
fn date_components_test() {
let date = Date::from_str("2000-01-02").unwrap();
assert_eq!(date.year(), 2000);
assert_eq!(date.month(), 1);
assert_eq!(date.day(), 2);
}
}