├── .gitignore
├── CHANGELOG.md
├── Cargo.toml
├── LICENSE
├── README.md
└── src
    ├── bytes
        ├── mod.rs
        └── tests.rs
    ├── duration
        ├── mod.rs
        └── tests.rs
    ├── lib.rs
    ├── num
        ├── checked.rs
        ├── mod.rs
        └── tests.rs
    └── time
        ├── mod.rs
        ├── tests.rs
        └── timezone.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | **/*.rs.bk
3 | Cargo.lock
4 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | ### v0.1.4
 2 | implement [RFC3339](https://tools.ietf.org/html/rfc3339) datetime parsing
 3 | 
 4 | ### v0.1.3
 5 | add method `size` for `Bytes`
 6 | 
 7 | ### v0.1.2
 8 | implement duration parsing
 9 | 
10 | ### v0.1.1
11 | use `struct Bytes<T: Int = usize>(T)` instead of `struct Bytes(usize)`
12 | 
13 | ### v0.1.0
14 | implement bytes parsing
15 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "humanize-rs"
 3 | description = """
 4 |     For parsing human-readable strings to some types.
 5 | """
 6 | readme = "README.md"
 7 | license-file = "LICENSE"
 8 | version = "0.1.5"
 9 | homepage = "https://github.com/dtynn/humanize-rs"
10 | documentation = "https://docs.rs/humanize-rs"
11 | repository = "https://github.com/dtynn/humanize-rs"
12 | authors = ["dtynn <dtynn@163.com>"]
13 | keywords = ["humanize", "human", "human-friendly", "readable", "parser"]
14 | categories = ["parsing"]
15 | 
16 | [dependencies]
17 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Caesar Wang
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## humanize-rs
 2 | [![Crates.io](https://img.shields.io/crates/v/humanize-rs.svg)](https://crates.io/crates/humanize-rs)
 3 | [![Docs](https://docs.rs/humanize-rs/badge.svg)](https://docs.rs/humanize-rs)
 4 | 
 5 | This lib aims at converting human-readable strings to specific types.
 6 | 
 7 | It's mainly used in parsing config files.
 8 | 
 9 | ### Usage
10 | 1. Add this lib as a dependency
11 | ```
12 | [dependencies]
13 | humanize-rs = "0.1"
14 | ```
15 | 
16 | 2. Add the crate reference
17 | ```
18 | extern crate humanize_rs;
19 | ```
20 | 
21 | 
22 | ### Example
23 | 
24 | 
25 | #### Bytes
26 | ```
27 | use humanize_rs::bytes::{Bytes, Unit};
28 | 
29 | let gigabytes1 = Bytes::new(1, Unit::GiByte);
30 | let gigabytes2 = "1 GiB".parse::<Bytes>();
31 | assert_eq!(gigabytes1, gigabytes2);
32 | assert_eq!(gigabytes2.unwrap().size(), 1 << 30);
33 | ```
34 | 
35 | #### Duration
36 | ```
37 | use humanize_rs::duration::parse;
38 | use std::time::Duration;
39 | 
40 | assert_eq!(parse("1h 30m 71s"), Ok(Duration::from_secs(60 * 90 + 71)));
41 | ```
42 | 
43 | #### RFC3339 Datetime
44 | ```
45 | use humanize_rs::time::{Time, TimeZone};
46 | 
47 | assert_eq!(
48 |     "2018-09-21T16:56:44.234867232+08:00".parse::<Time>(),
49 |     Ok(Time::from_timetuple(
50 |         2018,
51 |         9,
52 |         21,
53 |         16,
54 |         56,
55 |         44,
56 |         234867232,
57 |         TimeZone::new(8).unwrap(),
58 |     ).unwrap())
59 | );
60 | ```
61 | 
62 | 
63 | ### Contributing
64 | 
65 | Any PRs or issues are welcomed.
66 | 


--------------------------------------------------------------------------------
/src/bytes/mod.rs:
--------------------------------------------------------------------------------
  1 | //! This module is used to parse a string to byte size,
  2 | //! supports units of 2^10 like "KiB", "MiB",
  3 | //! or units of 1000 like "KB", "MB"
  4 | //!
  5 | //! # Example
  6 | //!
  7 | //! ```
  8 | //! use humanize_rs::bytes::{Bytes, Unit};
  9 | //!
 10 | //! let gigabytes1 = Bytes::new(1, Unit::GiByte);
 11 | //! let gigabytes2 = "1 GiB".parse::<Bytes>();
 12 | //! assert_eq!(gigabytes1, gigabytes2);
 13 | //! assert_eq!(gigabytes2.unwrap().size(), 1 << 30);
 14 | //! ```
 15 | 
 16 | use super::num::Int;
 17 | use std::fmt;
 18 | use std::str::FromStr;
 19 | use ParseError;
 20 | 
 21 | const IBYTES: [u64; 7] = [1, 1 << 10, 1 << 20, 1 << 30, 1 << 40, 1 << 50, 1 << 60];
 22 | const BYTES: [u64; 7] = [
 23 |     1,
 24 |     1_000,
 25 |     1_000_000,
 26 |     1_000_000_000,
 27 |     1_000_000_000_000,
 28 |     1_000_000_000_000_000,
 29 |     1_000_000_000_000_000_000,
 30 | ];
 31 | 
 32 | /// Bytes units, like "KB", "KiB"
 33 | #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 34 | pub enum Unit {
 35 |     /// 1 Byte
 36 |     Byte,
 37 | 
 38 |     /// 1 << 10 Byte
 39 |     KiByte,
 40 | 
 41 |     /// 1 << 20 Byte
 42 |     MiByte,
 43 | 
 44 |     /// 1 << 30 Byte
 45 |     GiByte,
 46 | 
 47 |     /// 1 << 40 Byte
 48 |     TiByte,
 49 | 
 50 |     /// 1 << 50 Byte
 51 |     PiByte,
 52 | 
 53 |     /// 1 << 60 Byte
 54 |     EiByte,
 55 | 
 56 |     /// 1000 Byte
 57 |     KByte,
 58 | 
 59 |     /// 1000 KByte
 60 |     MByte,
 61 | 
 62 |     /// 1000 MByte
 63 |     GByte,
 64 | 
 65 |     /// 1000 GByte
 66 |     TByte,
 67 | 
 68 |     /// 1000 TByte
 69 |     PByte,
 70 | 
 71 |     /// 1000 PByte
 72 |     EByte,
 73 | }
 74 | 
 75 | impl Unit {
 76 |     fn size<T: Int>(&self) -> Result<T, ParseError> {
 77 |         let v = match self {
 78 |             Unit::Byte => <T>::from_u64(1),
 79 |             Unit::KiByte => <T>::from_u64(IBYTES[1]),
 80 |             Unit::MiByte => <T>::from_u64(IBYTES[2]),
 81 |             Unit::GiByte => <T>::from_u64(IBYTES[3]),
 82 |             Unit::TiByte => <T>::from_u64(IBYTES[4]),
 83 |             Unit::PiByte => <T>::from_u64(IBYTES[5]),
 84 |             Unit::EiByte => <T>::from_u64(IBYTES[6]),
 85 |             Unit::KByte => <T>::from_u64(BYTES[1]),
 86 |             Unit::MByte => <T>::from_u64(BYTES[2]),
 87 |             Unit::GByte => <T>::from_u64(BYTES[3]),
 88 |             Unit::TByte => <T>::from_u64(BYTES[4]),
 89 |             Unit::PByte => <T>::from_u64(BYTES[5]),
 90 |             Unit::EByte => <T>::from_u64(BYTES[6]),
 91 |         }.ok_or(ParseError::Overflow)?;
 92 | 
 93 |         Ok(v)
 94 |     }
 95 | }
 96 | 
 97 | impl fmt::Display for Unit {
 98 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 99 |         let unit = match self {
100 |             Unit::Byte => "B",
101 |             Unit::KiByte => "KiB",
102 |             Unit::MiByte => "MiB",
103 |             Unit::GiByte => "GiB",
104 |             Unit::TiByte => "TiB",
105 |             Unit::PiByte => "PiB",
106 |             Unit::EiByte => "EiB",
107 |             Unit::KByte => "KB",
108 |             Unit::MByte => "MB",
109 |             Unit::GByte => "GB",
110 |             Unit::TByte => "TB",
111 |             Unit::PByte => "PB",
112 |             Unit::EByte => "EB",
113 |         };
114 | 
115 |         f.pad(unit)
116 |     }
117 | }
118 | 
119 | impl FromStr for Unit {
120 |     type Err = ParseError;
121 | 
122 |     fn from_str(s: &str) -> Result<Self, Self::Err> {
123 |         match s {
124 |             "" | "b" => Ok(Unit::Byte),
125 |             "ki" | "kib" => Ok(Unit::KiByte),
126 |             "mi" | "mib" => Ok(Unit::MiByte),
127 |             "gi" | "gib" => Ok(Unit::GiByte),
128 |             "ti" | "tib" => Ok(Unit::TiByte),
129 |             "pi" | "pib" => Ok(Unit::PiByte),
130 |             "ei" | "eib" => Ok(Unit::EiByte),
131 |             "k" | "kb" => Ok(Unit::KByte),
132 |             "m" | "mb" => Ok(Unit::MByte),
133 |             "g" | "gb" => Ok(Unit::GByte),
134 |             "t" | "tb" => Ok(Unit::TByte),
135 |             "p" | "pb" => Ok(Unit::PByte),
136 |             "e" | "eb" => Ok(Unit::EByte),
137 |             _ => Err(ParseError::InvalidUnit),
138 |         }
139 |     }
140 | }
141 | 
142 | /// Size calculated in [`Unit::Byte`]
143 | ///
144 | /// [`Unit::Byte`]: ./enum.Unit.html#variant.Byte
145 | #[derive(Debug, Copy, Clone, Eq, PartialEq)]
146 | pub struct Bytes<T: Int = usize>(T);
147 | 
148 | impl Bytes {
149 |     /// Returns a `Bytes` with a numeric value and a specific unit, or a `ParseError` if exists,
150 |     /// only [`ParseError::Overflow`] here.
151 |     ///
152 |     /// # Example
153 |     ///
154 |     /// ```
155 |     /// use humanize_rs::bytes::{Bytes, Unit};
156 |     ///
157 |     /// let megabytes = Bytes::new(1, Unit::MByte).unwrap();
158 |     /// ```
159 |     ///
160 |     /// [`ParseError::Overflow`]: ../enum.ParseError.html#variant.Overflow
161 |     pub fn new<T: Int>(value: T, unit: Unit) -> Result<Bytes<T>, ParseError> {
162 |         let unit_size = unit.size::<T>()?;
163 |         let size = value.checked_mul(unit_size).ok_or(ParseError::Overflow)?;
164 | 
165 |         Ok(Bytes(size))
166 |     }
167 | }
168 | 
169 | impl<T: Int> Bytes<T> {
170 |     /// return inner value of Bytes
171 |     pub fn size(&self) -> T {
172 |         return self.0;
173 |     }
174 | }
175 | 
176 | impl<T: Int> FromStr for Bytes<T> {
177 |     type Err = ParseError;
178 | 
179 |     fn from_str(s: &str) -> Result<Self, Self::Err> {
180 |         let input = s.trim();
181 |         if input.is_empty() {
182 |             return Err(ParseError::EmptyInput);
183 |         }
184 | 
185 |         let unit_index = input
186 |             .chars()
187 |             .position(|c| c.is_alphabetic() || c.is_whitespace())
188 |             .unwrap_or(input.len());
189 | 
190 |         if unit_index == 0 {
191 |             return Err(ParseError::MissingValue);
192 |         }
193 | 
194 |         let (vstr, ustr) = input.split_at(unit_index);
195 |         let unit = ustr.trim().to_lowercase().parse()?;
196 |         let value = vstr.parse::<T>().or(Err(ParseError::InvalidValue))?;
197 | 
198 |         Bytes::new(value, unit)
199 |     }
200 | }
201 | 
202 | #[cfg(test)]
203 | mod tests;
204 | 


--------------------------------------------------------------------------------
/src/bytes/tests.rs:
--------------------------------------------------------------------------------
  1 | use super::{Bytes, Unit};
  2 | use ParseError;
  3 | 
  4 | #[test]
  5 | fn test_parsing_strings() {
  6 |     let cases: Vec<(&str, Result<Bytes, ParseError>)> = vec![
  7 |         ("0", Ok(Bytes(0))),
  8 |         ("1", Ok(Bytes(1))),
  9 |         ("1b", Ok(Bytes(1))),
 10 |         ("1B", Ok(Bytes(1))),
 11 |         ("1 b", Ok(Bytes(1))),
 12 |         ("1 B", Ok(Bytes(1))),
 13 |         ("1 ki", Ok(Bytes(Unit::KiByte.size::<usize>().unwrap()))),
 14 |         ("1 Ki", Ok(Bytes(Unit::KiByte.size::<usize>().unwrap()))),
 15 |         ("1 kib", Ok(Bytes(Unit::KiByte.size::<usize>().unwrap()))),
 16 |         ("1 KiB", Ok(Bytes(Unit::KiByte.size::<usize>().unwrap()))),
 17 |         ("1 mi", Ok(Bytes(Unit::MiByte.size::<usize>().unwrap()))),
 18 |         ("1 Mi", Ok(Bytes(Unit::MiByte.size::<usize>().unwrap()))),
 19 |         ("1 mib", Ok(Bytes(Unit::MiByte.size::<usize>().unwrap()))),
 20 |         ("1 MiB", Ok(Bytes(Unit::MiByte.size::<usize>().unwrap()))),
 21 |         ("1 gi", Ok(Bytes(Unit::GiByte.size::<usize>().unwrap()))),
 22 |         ("1 Gi", Ok(Bytes(Unit::GiByte.size::<usize>().unwrap()))),
 23 |         ("1 gib", Ok(Bytes(Unit::GiByte.size::<usize>().unwrap()))),
 24 |         ("1 GiB", Ok(Bytes(Unit::GiByte.size::<usize>().unwrap()))),
 25 |         ("1 ti", Ok(Bytes(Unit::TiByte.size::<usize>().unwrap()))),
 26 |         ("1 Ti", Ok(Bytes(Unit::TiByte.size::<usize>().unwrap()))),
 27 |         ("1 tib", Ok(Bytes(Unit::TiByte.size::<usize>().unwrap()))),
 28 |         ("1 TiB", Ok(Bytes(Unit::TiByte.size::<usize>().unwrap()))),
 29 |         ("1 pi", Ok(Bytes(Unit::PiByte.size::<usize>().unwrap()))),
 30 |         ("1 Pi", Ok(Bytes(Unit::PiByte.size::<usize>().unwrap()))),
 31 |         ("1 pib", Ok(Bytes(Unit::PiByte.size::<usize>().unwrap()))),
 32 |         ("1 PiB", Ok(Bytes(Unit::PiByte.size::<usize>().unwrap()))),
 33 |         ("1 ei", Ok(Bytes(Unit::EiByte.size::<usize>().unwrap()))),
 34 |         ("1 Ei", Ok(Bytes(Unit::EiByte.size::<usize>().unwrap()))),
 35 |         ("1 eib", Ok(Bytes(Unit::EiByte.size::<usize>().unwrap()))),
 36 |         ("1 EiB", Ok(Bytes(Unit::EiByte.size::<usize>().unwrap()))),
 37 |         ("1 k", Ok(Bytes(Unit::KByte.size::<usize>().unwrap()))),
 38 |         ("1 K", Ok(Bytes(Unit::KByte.size::<usize>().unwrap()))),
 39 |         ("1 kb", Ok(Bytes(Unit::KByte.size::<usize>().unwrap()))),
 40 |         ("1 KB", Ok(Bytes(Unit::KByte.size::<usize>().unwrap()))),
 41 |         ("1 m", Ok(Bytes(Unit::MByte.size::<usize>().unwrap()))),
 42 |         ("1 M", Ok(Bytes(Unit::MByte.size::<usize>().unwrap()))),
 43 |         ("1 mb", Ok(Bytes(Unit::MByte.size::<usize>().unwrap()))),
 44 |         ("1 MB", Ok(Bytes(Unit::MByte.size::<usize>().unwrap()))),
 45 |         ("1 g", Ok(Bytes(Unit::GByte.size::<usize>().unwrap()))),
 46 |         ("1 G", Ok(Bytes(Unit::GByte.size::<usize>().unwrap()))),
 47 |         ("1 gb", Ok(Bytes(Unit::GByte.size::<usize>().unwrap()))),
 48 |         ("1 GB", Ok(Bytes(Unit::GByte.size::<usize>().unwrap()))),
 49 |         ("1 t", Ok(Bytes(Unit::TByte.size::<usize>().unwrap()))),
 50 |         ("1 T", Ok(Bytes(Unit::TByte.size::<usize>().unwrap()))),
 51 |         ("1 tb", Ok(Bytes(Unit::TByte.size::<usize>().unwrap()))),
 52 |         ("1 TB", Ok(Bytes(Unit::TByte.size::<usize>().unwrap()))),
 53 |         ("1 p", Ok(Bytes(Unit::PByte.size::<usize>().unwrap()))),
 54 |         ("1 P", Ok(Bytes(Unit::PByte.size::<usize>().unwrap()))),
 55 |         ("1 pb", Ok(Bytes(Unit::PByte.size::<usize>().unwrap()))),
 56 |         ("1 PB", Ok(Bytes(Unit::PByte.size::<usize>().unwrap()))),
 57 |         ("1 e", Ok(Bytes(Unit::EByte.size::<usize>().unwrap()))),
 58 |         ("1 E", Ok(Bytes(Unit::EByte.size::<usize>().unwrap()))),
 59 |         ("1 eb", Ok(Bytes(Unit::EByte.size::<usize>().unwrap()))),
 60 |         ("1 EB", Ok(Bytes(Unit::EByte.size::<usize>().unwrap()))),
 61 |         ("", Err(ParseError::EmptyInput)),
 62 |         ("EB", Err(ParseError::MissingValue)),
 63 |         ("0.5 EB", Err(ParseError::InvalidValue)),
 64 |         ("-1 EB", Err(ParseError::InvalidValue)),
 65 |         ("1 EEEEB", Err(ParseError::InvalidUnit)),
 66 |         ("100 EB", Err(ParseError::Overflow)),
 67 |     ];
 68 | 
 69 |     for c in cases {
 70 |         let b = c.0.parse::<Bytes>();
 71 |         assert_eq!(b, c.1);
 72 |     }
 73 | }
 74 | 
 75 | #[test]
 76 | fn test_int_types() {
 77 |     assert_eq!("1 B".parse::<Bytes<i8>>(), Ok(Bytes::<i8>(1)));
 78 |     assert_eq!("1 B".parse::<Bytes<u8>>(), Ok(Bytes::<u8>(1)));
 79 |     assert_eq!("1 B".parse::<Bytes<i16>>(), Ok(Bytes::<i16>(1)));
 80 |     assert_eq!("1 B".parse::<Bytes<u16>>(), Ok(Bytes::<u16>(1)));
 81 |     assert_eq!("1 B".parse::<Bytes<i32>>(), Ok(Bytes::<i32>(1)));
 82 |     assert_eq!("1 B".parse::<Bytes<u32>>(), Ok(Bytes::<u32>(1)));
 83 |     assert_eq!("1 B".parse::<Bytes<i64>>(), Ok(Bytes::<i64>(1)));
 84 |     assert_eq!("1 B".parse::<Bytes<u64>>(), Ok(Bytes::<u64>(1)));
 85 |     assert_eq!("1 B".parse::<Bytes<isize>>(), Ok(Bytes::<isize>(1)));
 86 |     assert_eq!("1 B".parse::<Bytes<usize>>(), Ok(Bytes::<usize>(1)));
 87 | 
 88 |     #[cfg(has_i128)]
 89 |     assert_eq!("1 B".parse::<Bytes<i128>>(), Ok(Bytes::<i128>(1)));
 90 |     #[cfg(has_i128)]
 91 |     assert_eq!("1 B".parse::<Bytes<u128>>(), Ok(Bytes::<u128>(1)));
 92 | }
 93 | 
 94 | #[test]
 95 | fn test_size() {
 96 |     assert_eq!("1 B".parse::<Bytes>().unwrap().size(), 1_usize);
 97 |     assert_eq!("1 B".parse::<Bytes<i8>>().unwrap().size(), 1_i8);
 98 |     assert_eq!("1 B".parse::<Bytes<u8>>().unwrap().size(), 1_u8);
 99 |     assert_eq!("1 B".parse::<Bytes<i16>>().unwrap().size(), 1_i16);
100 |     assert_eq!("1 B".parse::<Bytes<u16>>().unwrap().size(), 1_u16);
101 |     assert_eq!("1 B".parse::<Bytes<i32>>().unwrap().size(), 1_i32);
102 |     assert_eq!("1 B".parse::<Bytes<u32>>().unwrap().size(), 1_u32);
103 |     assert_eq!("1 B".parse::<Bytes<i64>>().unwrap().size(), 1_i64);
104 |     assert_eq!("1 B".parse::<Bytes<u64>>().unwrap().size(), 1_u64);
105 |     assert_eq!("1 B".parse::<Bytes<isize>>().unwrap().size(), 1_isize);
106 |     assert_eq!("1 B".parse::<Bytes<usize>>().unwrap().size(), 1_usize);
107 | 
108 |     #[cfg(has_i128)]
109 |     assert_eq!("1 B".parse::<Bytes<i128>>().unwrap().size(), 1_i128);
110 |     #[cfg(has_i128)]
111 |     assert_eq!("1 B".parse::<Bytes<u128>>().unwrap().size(), 1_u128);
112 | }
113 | 


--------------------------------------------------------------------------------
/src/duration/mod.rs:
--------------------------------------------------------------------------------
  1 | //! This module is used to parse strings to duration.
  2 | //!
  3 | //! # Example
  4 | //! ```
  5 | //! use humanize_rs::duration::parse;
  6 | //! use std::time::Duration;
  7 | //!
  8 | //! assert_eq!(parse("1h 30m 71s"), Ok(Duration::from_secs(60 * 90 + 71)));
  9 | //! ```
 10 | 
 11 | use std::str::from_utf8;
 12 | use std::time::Duration;
 13 | use ParseError;
 14 | 
 15 | const DIGIT_MIN: u8 = b'0';
 16 | const DIGIT_MAX: u8 = b'9';
 17 | 
 18 | const NANOS: [u64; 7] = [
 19 |     1,                         // ns
 20 |     1_000,                     // us
 21 |     1_000_000,                 // ms
 22 |     1_000_000_000,             // s
 23 |     60 * 1_000_000_000,        // min
 24 |     3600 * 1_000_000_000,      // h
 25 |     24 * 3600 * 1_000_000_000, // d
 26 | ];
 27 | 
 28 | /// parse a duration-type string, (e.g. "1h", "1h 30m")
 29 | ///
 30 | /// # Example
 31 | /// ```
 32 | /// use humanize_rs::duration::parse;
 33 | ///
 34 | ///
 35 | /// let d = parse("1h 30m").unwrap();
 36 | /// println!("{:?}", d);
 37 | /// ```
 38 | pub fn parse(s: &str) -> Result<Duration, ParseError> {
 39 |     let input = s.trim();
 40 |     if input.is_empty() {
 41 |         return Err(ParseError::EmptyInput);
 42 |     }
 43 | 
 44 |     if input == "0" {
 45 |         return Ok(Duration::new(0, 0));
 46 |     }
 47 | 
 48 |     let mut value: u64 = 0;
 49 | 
 50 |     let bs = input.as_bytes();
 51 |     let mut read: usize = 0;
 52 | 
 53 |     while read < bs.len() {
 54 |         let (v, consumed) = read_int(&bs[read..])?;
 55 |         read += consumed;
 56 | 
 57 |         let (unit, consumed) = read_unit(&bs[read..])?;
 58 |         read += consumed;
 59 | 
 60 |         let nanos = unit_to_nanos(unit)?;
 61 | 
 62 |         value = v
 63 |             .checked_mul(nanos)
 64 |             .and_then(|res| value.checked_add(res))
 65 |             .ok_or(ParseError::Overflow)?;
 66 |     }
 67 | 
 68 |     Ok(Duration::from_nanos(value))
 69 | }
 70 | 
 71 | fn read_int(bs: &[u8]) -> Result<(u64, usize), ParseError> {
 72 |     let mut v: u64 = 0;
 73 |     let mut read: usize = 0;
 74 |     while read < bs.len() {
 75 |         let c = bs[read];
 76 |         if c < DIGIT_MIN || c > DIGIT_MAX {
 77 |             break;
 78 |         }
 79 | 
 80 |         v = v
 81 |             .checked_mul(10)
 82 |             .and_then(|res| res.checked_add((c - DIGIT_MIN) as u64))
 83 |             .ok_or(ParseError::Overflow)?;
 84 | 
 85 |         read += 1;
 86 |     }
 87 | 
 88 |     if read == 0 {
 89 |         return Err(ParseError::MissingValue);
 90 |     }
 91 | 
 92 |     Ok((v, read))
 93 | }
 94 | 
 95 | fn read_unit(bs: &[u8]) -> Result<(&str, usize), ParseError> {
 96 |     let mut read: usize = 0;
 97 |     while read < bs.len() {
 98 |         let c = bs[read];
 99 |         if DIGIT_MIN <= c && c <= DIGIT_MAX {
100 |             break;
101 |         }
102 | 
103 |         read += 1;
104 |     }
105 | 
106 |     if read == 0 {
107 |         return Err(ParseError::MissingUnit);
108 |     }
109 | 
110 |     let unit = from_utf8(&bs[..read]).or(Err(ParseError::InvalidUnit))?;
111 | 
112 |     Ok((unit.trim(), read))
113 | }
114 | 
115 | fn unit_to_nanos(unit: &str) -> Result<u64, ParseError> {
116 |     match unit {
117 |         "ns" => Ok(NANOS[0]),
118 |         "us" => Ok(NANOS[1]),
119 |         "ms" => Ok(NANOS[2]),
120 |         "s" => Ok(NANOS[3]),
121 |         "m" => Ok(NANOS[4]),
122 |         "h" => Ok(NANOS[5]),
123 |         "d" => Ok(NANOS[6]),
124 |         _ => Err(ParseError::InvalidUnit),
125 |     }
126 | }
127 | 
128 | #[cfg(test)]
129 | mod tests;
130 | 


--------------------------------------------------------------------------------
/src/duration/tests.rs:
--------------------------------------------------------------------------------
 1 | use super::parse;
 2 | use std::time::Duration;
 3 | use ParseError;
 4 | 
 5 | #[test]
 6 | fn test_parse_duration_units() {
 7 |     assert_eq!(parse("1d"), Ok(Duration::from_secs(86400)));
 8 |     assert_eq!(parse("1h"), Ok(Duration::from_secs(3600)));
 9 |     assert_eq!(parse("1m"), Ok(Duration::from_secs(60)));
10 |     assert_eq!(parse("1s"), Ok(Duration::from_secs(1)));
11 |     assert_eq!(parse("1ms"), Ok(Duration::from_millis(1)));
12 |     assert_eq!(parse("1us"), Ok(Duration::from_micros(1)));
13 |     assert_eq!(parse("1ns"), Ok(Duration::from_nanos(1)));
14 | 
15 |     assert_eq!(parse("0d"), Ok(Duration::new(0, 0)));
16 |     assert_eq!(parse("0h"), Ok(Duration::new(0, 0)));
17 |     assert_eq!(parse("0m"), Ok(Duration::new(0, 0)));
18 |     assert_eq!(parse("0s"), Ok(Duration::new(0, 0)));
19 |     assert_eq!(parse("0ms"), Ok(Duration::new(0, 0)));
20 |     assert_eq!(parse("0us"), Ok(Duration::new(0, 0)));
21 |     assert_eq!(parse("0ns"), Ok(Duration::new(0, 0)));
22 |     assert_eq!(parse("0"), Ok(Duration::new(0, 0)));
23 | }
24 | 
25 | #[test]
26 | fn test_parse_duration_multi_parts() {
27 |     assert_eq!(parse("1d12h"), Ok(Duration::from_secs(86400 / 2 * 3)));
28 |     assert_eq!(parse("1h50m"), Ok(Duration::from_secs(60 * 110)));
29 |     assert_eq!(parse("3m20s"), Ok(Duration::from_secs(60 * 3 + 20)));
30 | 
31 |     assert_eq!(parse("1d 12h"), Ok(Duration::from_secs(86400 / 2 * 3)));
32 |     assert_eq!(parse("1h 50m"), Ok(Duration::from_secs(60 * 110)));
33 |     assert_eq!(parse("3m 20s"), Ok(Duration::from_secs(60 * 3 + 20)));
34 | 
35 |     assert_eq!(
36 |         parse("1d 12h 120s"),
37 |         Ok(Duration::from_secs(86400 / 2 * 3 + 120))
38 |     );
39 |     assert_eq!(
40 |         parse("1h 50m 35ms"),
41 |         Ok(Duration::new(60 * 110, 35 * 1_000_000))
42 |     );
43 |     assert_eq!(parse("3m 20s 100ns"), Ok(Duration::new(60 * 3 + 20, 100)));
44 | }
45 | 
46 | #[test]
47 | fn test_parse_errors() {
48 |     assert_eq!(parse(""), Err(ParseError::EmptyInput));
49 |     assert_eq!(parse("1"), Err(ParseError::MissingUnit));
50 |     assert_eq!(parse("s"), Err(ParseError::MissingValue));
51 |     assert_eq!(parse("1ss"), Err(ParseError::InvalidUnit));
52 |     assert_eq!(parse("1 中文"), Err(ParseError::InvalidUnit));
53 | 
54 |     assert_eq!(parse("100000000000000000000ns"), Err(ParseError::Overflow));
55 |     assert_eq!(parse("100000000000000000us"), Err(ParseError::Overflow));
56 |     assert_eq!(parse("100000000000000ms"), Err(ParseError::Overflow));
57 | 
58 |     assert_eq!(parse("100000000000000000000s"), Err(ParseError::Overflow));
59 |     assert_eq!(parse("10000000000000000000m"), Err(ParseError::Overflow));
60 |     assert_eq!(parse("1000000000000000000h"), Err(ParseError::Overflow));
61 |     assert_eq!(parse("100000000000000000d"), Err(ParseError::Overflow));
62 | }
63 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![warn(missing_docs)]
 2 | 
 3 | //! This lib is used to parse formatted strings to different types
 4 | 
 5 | use std::error::Error;
 6 | use std::fmt;
 7 | 
 8 | pub mod bytes;
 9 | pub mod duration;
10 | pub mod num;
11 | pub mod time;
12 | 
13 | /// Error parsing formatted strings
14 | #[derive(Debug, Copy, Clone, Eq, PartialEq)]
15 | pub enum ParseError {
16 |     /// Parsing an empty string
17 |     EmptyInput,
18 | 
19 |     /// The numeric value is missing
20 |     MissingValue,
21 | 
22 |     /// Malformed numeric value
23 |     InvalidValue,
24 | 
25 |     /// The unit is missing
26 |     MissingUnit,
27 | 
28 |     /// Unknown unit
29 |     InvalidUnit,
30 | 
31 |     /// The unit shows multiple times in the string
32 |     DuplicateUnit,
33 | 
34 |     /// The numeric value is too large
35 |     Overflow,
36 | 
37 |     /// Too short for some pattern
38 |     TooShort,
39 | 
40 |     /// Too long for some pattern
41 |     TooLong,
42 | 
43 |     /// Malformed string
44 |     Malformed,
45 | 
46 |     /// Invalid timezone
47 |     InvalidTimezone,
48 | }
49 | 
50 | impl ParseError {
51 |     fn description(&self) -> &str {
52 |         match self {
53 |             ParseError::EmptyInput => "empty input",
54 |             ParseError::MissingValue => "missing value",
55 |             ParseError::InvalidValue => "invalid value",
56 |             ParseError::MissingUnit => "missing unit",
57 |             ParseError::InvalidUnit => "invalid unit",
58 |             ParseError::DuplicateUnit => "duplicate unit",
59 |             ParseError::Overflow => "value overflow",
60 |             ParseError::TooShort => "too short",
61 |             ParseError::TooLong => "too long",
62 |             ParseError::Malformed => "malformed",
63 |             ParseError::InvalidTimezone => "invalid timezone",
64 |         }
65 |     }
66 | }
67 | 
68 | impl fmt::Display for ParseError {
69 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
70 |         f.pad(self.description())
71 |     }
72 | }
73 | 
74 | impl Error for ParseError {}
75 | 


--------------------------------------------------------------------------------
/src/num/checked.rs:
--------------------------------------------------------------------------------
 1 | use std::ops::Mul;
 2 | 
 3 | // Performs multiplication that returns `None` instead of wrapping around on underflow or
 4 | /// overflow.
 5 | pub trait CheckedMul: Copy + Sized + Mul<Self, Output = Self> {
 6 |     /// Multiplies two numbers, checking for underflow or overflow. If underflow
 7 |     /// or overflow happens, `None` is returned.
 8 |     fn checked_mul(self, rhs: Self) -> Option<Self>;
 9 | }
10 | 
11 | macro_rules! impl_checked_mul {
12 |     ($T:ty) => {
13 |         impl CheckedMul for $T {
14 |             fn checked_mul(self, rhs: $T) -> Option<$T> {
15 |                 <$T>::checked_mul(self, rhs)
16 |             }
17 |         }
18 |     };
19 | }
20 | 
21 | impl_checked_mul!(i8);
22 | impl_checked_mul!(u8);
23 | impl_checked_mul!(i16);
24 | impl_checked_mul!(u16);
25 | impl_checked_mul!(i32);
26 | impl_checked_mul!(u32);
27 | impl_checked_mul!(i64);
28 | impl_checked_mul!(u64);
29 | impl_checked_mul!(isize);
30 | impl_checked_mul!(usize);
31 | 
32 | #[cfg(has_i128)]
33 | impl_checked_mul!(i128);
34 | #[cfg(has_i128)]
35 | impl_checked_mul!(u128);
36 | 


--------------------------------------------------------------------------------
/src/num/mod.rs:
--------------------------------------------------------------------------------
 1 | //! This module provides some numeric traits used in parsing.
 2 | //!
 3 | //!
 4 | 
 5 | use std::mem::size_of;
 6 | #[cfg(has_i128)]
 7 | use std::{i128, u128};
 8 | use std::{i16, i32, i64, i8, isize, u16, u32, u64, u8, usize};
 9 | 
10 | mod checked;
11 | pub use self::checked::*;
12 | 
13 | use std::str::FromStr;
14 | 
15 | /// Represents the integer trait
16 | pub trait Int: Sized + Copy + FromStr + CheckedMul {
17 |     /// Returns a value from given u64 num
18 |     fn from_u64(n: u64) -> Option<Self>;
19 | }
20 | 
21 | macro_rules! impl_int {
22 |     ($dst:ident) => {
23 |         impl Int for $dst {
24 |             fn from_u64(n: u64) -> Option<$dst> {
25 |                 let max = $dst::MAX as u64;
26 |                 if size_of::<u64>() < size_of::<$dst>() || n <= max {
27 |                     Some(n as $dst)
28 |                 } else {
29 |                     None
30 |                 }
31 |             }
32 |         }
33 |     };
34 | }
35 | 
36 | impl_int!(i8);
37 | impl_int!(u8);
38 | 
39 | impl_int!(i16);
40 | impl_int!(u16);
41 | 
42 | impl_int!(i32);
43 | impl_int!(u32);
44 | 
45 | impl_int!(i64);
46 | impl_int!(u64);
47 | 
48 | impl_int!(isize);
49 | impl_int!(usize);
50 | 
51 | #[cfg(has_i128)]
52 | impl_int!(i128);
53 | #[cfg(has_i128)]
54 | impl_int!(u128);
55 | 
56 | #[cfg(test)]
57 | mod tests;
58 | 


--------------------------------------------------------------------------------
/src/num/tests.rs:
--------------------------------------------------------------------------------
 1 | use super::Int;
 2 | use std::i16;
 3 | 
 4 | #[test]
 5 | fn test_int_from_u64() {
 6 |     let num: u64 = i16::MAX as u64;
 7 | 
 8 |     let res_i8: Option<i8> = Int::from_u64(num);
 9 |     let res_i32: Option<i32> = Int::from_u64(num);
10 | 
11 |     assert_eq!(res_i8, None);
12 |     assert_eq!(res_i32, Some(i16::MAX as i32));
13 | }
14 | 


--------------------------------------------------------------------------------
/src/time/mod.rs:
--------------------------------------------------------------------------------
  1 | //! This module is used to parse [`RFC3339`] datetime string
  2 | //!
  3 | //! # Example
  4 | //! ```
  5 | //! use humanize_rs::time::{Time, TimeZone};
  6 | //!
  7 | //! assert_eq!(
  8 | //!     "2018-09-21T16:56:44.234867232+08:00".parse::<Time>(),
  9 | //!     Ok(Time::from_timetuple(
 10 | //!         2018,
 11 | //!         9,
 12 | //!         21,
 13 | //!         16,
 14 | //!         56,
 15 | //!         44,
 16 | //!         234867232,
 17 | //!         TimeZone::new(8).unwrap(),
 18 | //!     ).unwrap())
 19 | //! );
 20 | //! ```
 21 | //!
 22 | //! [`RFC3339`]: https://tools.ietf.org/html/rfc3339
 23 | 
 24 | mod timezone;
 25 | 
 26 | pub use self::timezone::*;
 27 | 
 28 | use std::cmp::Ordering;
 29 | use std::str::{from_utf8, FromStr};
 30 | use std::time::{Duration, SystemTime};
 31 | use ParseError;
 32 | 
 33 | const MAX_SECONDS: u64 = 315569433600;
 34 | const UNIX_EPOCH: Time = Time {
 35 |     sec: 62167132800,
 36 |     nano: 0,
 37 | };
 38 | 
 39 | const SECS_PER_MINUTE: u64 = 60;
 40 | const SECS_PER_HOUR: u64 = 60 * SECS_PER_MINUTE;
 41 | const SECS_PER_DAY: u64 = 24 * SECS_PER_HOUR;
 42 | const DAYS_PER_400_YEARS: u32 = 365 * 400 + 97;
 43 | const DAYS_PER_100_YEARS: u32 = 365 * 100 + 24;
 44 | const DAYS_PER_4_YEARS: u32 = 365 * 4 + 1;
 45 | const DAYS_BEFORE: [u32; 13] = [
 46 |     0,
 47 |     31,
 48 |     31 + 28,
 49 |     31 + 28 + 31,
 50 |     31 + 28 + 31 + 30,
 51 |     31 + 28 + 31 + 30 + 31,
 52 |     31 + 28 + 31 + 30 + 31 + 30,
 53 |     31 + 28 + 31 + 30 + 31 + 30 + 31,
 54 |     31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
 55 |     31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
 56 |     31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
 57 |     31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
 58 |     31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
 59 | ];
 60 | 
 61 | const DATE_TIME_FORMAT_MIN_LENGTH: usize = 10; // "2006-01-02"
 62 | const DATE_TIME_FORMAT_WITH_TIME: usize = 19; // "2006-01-02T15:04:05"
 63 | const DATE_TIME_FORMAT_MAX_LENGTH: usize = 35; // "2006-01-02T15:04:05.999999999Z07:00"
 64 | 
 65 | /// Represents a time in range [0000-01-01T00:00:00Z, 10000-01-01T00:00:00Z)
 66 | #[derive(Debug, Eq, PartialEq)]
 67 | pub struct Time {
 68 |     sec: u64,
 69 |     nano: u32,
 70 | }
 71 | 
 72 | impl Time {
 73 |     /// Represents `1970-01-01 00:00:00Z`
 74 |     pub const UNIX_EPOCH: Time = UNIX_EPOCH;
 75 | 
 76 |     /// Returns a Time with the given time tuple
 77 |     pub fn from_timetuple(
 78 |         year: u32,
 79 |         month: u32,
 80 |         day: u32,
 81 |         hour: u32,
 82 |         minute: u32,
 83 |         second: u32,
 84 |         nano: u32,
 85 |         timezone: TimeZone,
 86 |     ) -> Option<Time> {
 87 |         if !in_range(year, 0, 10000)
 88 |             || !in_range(month, 1, 12)
 89 |             || !in_range(day, 1, 31)
 90 |             || !in_range(hour, 0, 23)
 91 |             || !in_range(minute, 0, 59)
 92 |             || !in_range(second, 0, 59)
 93 |             || !in_range(nano, 0, 1_000_000_000 - 1)
 94 |         {
 95 |             return None;
 96 |         }
 97 | 
 98 |         let is_leap = is_leap_year(year);
 99 | 
100 |         if !is_day_validate(is_leap, month, day) {
101 |             return None;
102 |         }
103 | 
104 |         let mut d: u32 = 0;
105 | 
106 |         let mut y = year;
107 | 
108 |         let mut n: u32 = y / 400;
109 |         y -= 400 * n;
110 |         d += DAYS_PER_400_YEARS * n;
111 | 
112 |         n = y / 100;
113 |         y -= n * 100;
114 |         d += DAYS_PER_100_YEARS * n;
115 | 
116 |         n = y / 4;
117 |         y -= n * 4;
118 |         d += DAYS_PER_4_YEARS * n;
119 | 
120 |         n = y;
121 |         d += 365 * n;
122 | 
123 |         d += DAYS_BEFORE[(month - 1) as usize];
124 |         // already calculated in DAYS_PER_XX_YEARS
125 |         if year > 0 && is_leap && month <= 2 {
126 |             d -= 1;
127 |         }
128 | 
129 |         d += day - 1;
130 | 
131 |         let mut sec: u64 = d as u64 * SECS_PER_DAY
132 |             + hour as u64 * SECS_PER_HOUR
133 |             + minute as u64 * SECS_PER_MINUTE
134 |             + second as u64;
135 | 
136 |         let offset = timezone.offset();
137 |         if offset >= 0 {
138 |             let minus = offset as u64;
139 |             if minus > sec {
140 |                 return None;
141 |             }
142 | 
143 |             sec -= minus;
144 |         } else {
145 |             sec += (-offset) as u64;
146 |         }
147 | 
148 |         if sec >= MAX_SECONDS {
149 |             return None;
150 |         }
151 | 
152 |         Some(Time {
153 |             sec: sec,
154 |             nano: nano,
155 |         })
156 |     }
157 | 
158 |     /// Convert the time to SystemTime, returns None if the time is before unix epoch
159 |     pub fn to_system_time(&self) -> Option<SystemTime> {
160 |         if let Some(d) = self.since(&UNIX_EPOCH) {
161 |             return Some(SystemTime::UNIX_EPOCH + d);
162 |         }
163 | 
164 |         None
165 |     }
166 | 
167 |     /// Returns the duration since an earlier time, and None if earlier is not before self.
168 |     pub fn since(&self, earlier: &Time) -> Option<Duration> {
169 |         if self < earlier {
170 |             return None;
171 |         }
172 | 
173 |         let mut sec = self.sec - earlier.sec;
174 |         let mut nano = self.nano;
175 |         if nano < earlier.nano {
176 |             sec -= 1;
177 |             nano += 1_000_000_000;
178 |         }
179 |         nano -= earlier.nano;
180 | 
181 |         Some(Duration::new(sec, nano))
182 |     }
183 | }
184 | 
185 | fn is_leap_year(y: u32) -> bool {
186 |     return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
187 | }
188 | 
189 | fn in_range(n: u32, min: u32, max: u32) -> bool {
190 |     return min <= n && n <= max;
191 | }
192 | 
193 | fn is_day_validate(is_leap: bool, m: u32, d: u32) -> bool {
194 |     match m {
195 |         2 if is_leap => d <= 29,
196 |         2 => d <= 28,
197 |         4 | 6 | 9 | 11 => d <= 30,
198 |         _ => d <= 31,
199 |     }
200 | }
201 | 
202 | impl FromStr for Time {
203 |     type Err = ParseError;
204 | 
205 |     fn from_str(s: &str) -> Result<Self, Self::Err> {
206 |         parse_rfc3339(s)
207 |     }
208 | }
209 | 
210 | impl PartialOrd for Time {
211 |     fn partial_cmp(&self, other: &Time) -> Option<Ordering> {
212 |         Some(self.cmp(other))
213 |     }
214 | }
215 | 
216 | impl Ord for Time {
217 |     fn cmp(&self, other: &Time) -> Ordering {
218 |         let ord = self.sec.cmp(&other.sec);
219 |         match ord {
220 |             Ordering::Equal => self.nano.cmp(&other.nano),
221 |             _ => ord,
222 |         }
223 |     }
224 | }
225 | 
226 | /// Parses a [`RFC3339`] datetime string
227 | ///
228 | /// [`RFC3339`]: https://tools.ietf.org/html/rfc3339
229 | pub fn parse_rfc3339(s: &str) -> Result<Time, ParseError> {
230 |     let bs = s.trim().as_bytes();
231 |     let size = bs.len();
232 |     if size == 0 {
233 |         return Err(ParseError::EmptyInput);
234 |     }
235 | 
236 |     if size < DATE_TIME_FORMAT_MIN_LENGTH
237 |         || (size > DATE_TIME_FORMAT_MIN_LENGTH && size < DATE_TIME_FORMAT_WITH_TIME)
238 |     {
239 |         return Err(ParseError::TooShort);
240 |     }
241 | 
242 |     if size > DATE_TIME_FORMAT_MAX_LENGTH {
243 |         return Err(ParseError::TooLong);
244 |     }
245 | 
246 |     if !check_pattern(bs) {
247 |         return Err(ParseError::Malformed);
248 |     }
249 | 
250 |     let year = read_u32(&bs[0..4])?;
251 |     let month = read_u32(&bs[5..7])?;
252 |     let day = read_u32(&bs[8..10])?;
253 | 
254 |     let hour: u32;
255 |     let minute: u32;
256 |     let second: u32;
257 |     if size > DATE_TIME_FORMAT_MIN_LENGTH {
258 |         hour = read_u32(&bs[DATE_TIME_FORMAT_MIN_LENGTH + 1..DATE_TIME_FORMAT_MIN_LENGTH + 3])?;
259 |         minute = read_u32(&bs[DATE_TIME_FORMAT_MIN_LENGTH + 4..DATE_TIME_FORMAT_MIN_LENGTH + 6])?;
260 |         second = read_u32(&bs[DATE_TIME_FORMAT_MIN_LENGTH + 7..DATE_TIME_FORMAT_MIN_LENGTH + 9])?;
261 |     } else {
262 |         hour = 0;
263 |         minute = 0;
264 |         second = 0;
265 |     }
266 | 
267 |     let nano: u32;
268 |     let tzstr: &str;
269 |     if size > DATE_TIME_FORMAT_WITH_TIME {
270 |         let tz_start: usize;
271 |         if bs[DATE_TIME_FORMAT_WITH_TIME] == b'.' {
272 |             let (v, read) = read_nano(&bs[DATE_TIME_FORMAT_WITH_TIME + 1..]);
273 |             if read == 0 {
274 |                 return Err(ParseError::MissingValue);
275 |             }
276 |             nano = v;
277 |             tz_start = DATE_TIME_FORMAT_WITH_TIME + 1 + read;
278 |         } else {
279 |             nano = 0;
280 |             tz_start = DATE_TIME_FORMAT_WITH_TIME;
281 |         }
282 | 
283 |         tzstr = from_utf8(&bs[tz_start..]).or(Err(ParseError::InvalidTimezone))?;
284 |     } else {
285 |         nano = 0;
286 |         tzstr = "";
287 |     }
288 | 
289 |     let tz = tzstr.parse::<TimeZone>()?;
290 | 
291 |     Time::from_timetuple(year, month, day, hour, minute, second, nano, tz)
292 |         .ok_or(ParseError::Overflow)
293 | }
294 | 
295 | fn check_pattern(bs: &[u8]) -> bool {
296 |     if bs[4] != b'-' || bs[7] != b'-' {
297 |         return false;
298 |     }
299 | 
300 |     if bs.len() > DATE_TIME_FORMAT_MIN_LENGTH {
301 |         if (bs[DATE_TIME_FORMAT_MIN_LENGTH] != b'T' && bs[DATE_TIME_FORMAT_MIN_LENGTH] != b' ')
302 |             || bs[DATE_TIME_FORMAT_MIN_LENGTH + 3] != b':'
303 |             || bs[DATE_TIME_FORMAT_MIN_LENGTH + 6] != b':'
304 |         {
305 |             return false;
306 |         }
307 |     }
308 | 
309 |     if bs.len() > DATE_TIME_FORMAT_WITH_TIME {
310 |         if bs[DATE_TIME_FORMAT_WITH_TIME] != b'.'
311 |             && bs[DATE_TIME_FORMAT_WITH_TIME] != b'Z'
312 |             && bs[DATE_TIME_FORMAT_WITH_TIME] != b'+'
313 |             && bs[DATE_TIME_FORMAT_WITH_TIME] != b'-'
314 |         {
315 |             return false;
316 |         }
317 |     }
318 | 
319 |     true
320 | }
321 | 
322 | fn read_u32(bs: &[u8]) -> Result<u32, ParseError> {
323 |     let mut read: usize = 0;
324 |     let mut n: u32 = 0;
325 | 
326 |     while read < bs.len() {
327 |         let c = bs[read];
328 |         if c < b'0' || c > b'9' {
329 |             return Err(ParseError::InvalidValue);
330 |         }
331 | 
332 |         n = n * 10;
333 |         n += (c - b'0') as u32;
334 | 
335 |         read += 1;
336 |     }
337 | 
338 |     Ok(n)
339 | }
340 | 
341 | fn read_nano(bs: &[u8]) -> (u32, usize) {
342 |     let mut read: usize = 0;
343 |     let mut n: u32 = 0;
344 | 
345 |     while read < bs.len() && read <= 9 {
346 |         let c = bs[read];
347 |         if c < b'0' || c > b'9' {
348 |             break;
349 |         }
350 | 
351 |         n = n * 10;
352 |         n += (c - b'0') as u32;
353 | 
354 |         read += 1;
355 |     }
356 | 
357 |     if read < 9 {
358 |         n = n * 10_u32.pow((9 - read) as u32);
359 |     }
360 | 
361 |     (n, read)
362 | }
363 | 
364 | #[cfg(test)]
365 | mod tests;
366 | 


--------------------------------------------------------------------------------
/src/time/tests.rs:
--------------------------------------------------------------------------------
  1 | use super::TimeZone;
  2 | use super::{is_leap_year, parse_rfc3339, Time, UNIX_EPOCH};
  3 | use std::time::{Duration, SystemTime};
  4 | use ParseError;
  5 | 
  6 | #[test]
  7 | fn test_timetuple() {
  8 |     struct Case {
  9 |         tuple: (u32, u32, u32, u32, u32, u32, u32, TimeZone),
 10 |         expect: Option<Duration>,
 11 |     }
 12 | 
 13 |     let cases = vec![
 14 |         Case {
 15 |             tuple: (2018, 1, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 16 |             expect: Some(Duration::new(1514736000, 0)),
 17 |         },
 18 |         Case {
 19 |             tuple: (2018, 2, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 20 |             expect: Some(Duration::new(1517414400, 0)),
 21 |         },
 22 |         Case {
 23 |             tuple: (2018, 3, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 24 |             expect: Some(Duration::new(1519833600, 0)),
 25 |         },
 26 |         Case {
 27 |             tuple: (2018, 4, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 28 |             expect: Some(Duration::new(1522512000, 0)),
 29 |         },
 30 |         Case {
 31 |             tuple: (2018, 5, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 32 |             expect: Some(Duration::new(1525104000, 0)),
 33 |         },
 34 |         Case {
 35 |             tuple: (2018, 6, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 36 |             expect: Some(Duration::new(1527782400, 0)),
 37 |         },
 38 |         Case {
 39 |             tuple: (2018, 7, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 40 |             expect: Some(Duration::new(1530374400, 0)),
 41 |         },
 42 |         Case {
 43 |             tuple: (2018, 8, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 44 |             expect: Some(Duration::new(1533052800, 0)),
 45 |         },
 46 |         Case {
 47 |             tuple: (2018, 9, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 48 |             expect: Some(Duration::new(1535731200, 0)),
 49 |         },
 50 |         Case {
 51 |             tuple: (2018, 10, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 52 |             expect: Some(Duration::new(1538323200, 0)),
 53 |         },
 54 |         Case {
 55 |             tuple: (2018, 11, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 56 |             expect: Some(Duration::new(1541001600, 0)),
 57 |         },
 58 |         Case {
 59 |             tuple: (2018, 12, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 60 |             expect: Some(Duration::new(1543593600, 0)),
 61 |         },
 62 |         Case {
 63 |             tuple: (
 64 |                 2018,
 65 |                 9,
 66 |                 21,
 67 |                 16,
 68 |                 56,
 69 |                 44,
 70 |                 234867232,
 71 |                 TimeZone::new(8).unwrap(),
 72 |             ),
 73 |             expect: Some(Duration::new(1537520204, 234867232)),
 74 |         },
 75 |         Case {
 76 |             tuple: (2000, 2, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 77 |             expect: Some(Duration::new(949334400, 0)),
 78 |         },
 79 |         Case {
 80 |             tuple: (2000, 3, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 81 |             expect: Some(Duration::new(951840000, 0)),
 82 |         },
 83 |         Case {
 84 |             tuple: (2100, 2, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 85 |             expect: Some(Duration::new(4105094400, 0)),
 86 |         },
 87 |         Case {
 88 |             tuple: (2100, 3, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 89 |             expect: Some(Duration::new(4107513600, 0)),
 90 |         },
 91 |         Case {
 92 |             tuple: (2104, 2, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 93 |             expect: Some(Duration::new(4231238400, 0)),
 94 |         },
 95 |         Case {
 96 |             tuple: (2104, 3, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
 97 |             expect: Some(Duration::new(4233744000, 0)),
 98 |         },
 99 |         Case {
100 |             tuple: (2105, 2, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
101 |             expect: Some(Duration::new(4262860800, 0)),
102 |         },
103 |         Case {
104 |             tuple: (2105, 3, 1, 0, 0, 0, 0, TimeZone::new(8).unwrap()),
105 |             expect: Some(Duration::new(4265280000, 0)),
106 |         },
107 |     ];
108 | 
109 |     for c in cases {
110 |         let d = Time::from_timetuple(
111 |             c.tuple.0, c.tuple.1, c.tuple.2, c.tuple.3, c.tuple.4, c.tuple.5, c.tuple.6, c.tuple.7,
112 |         ).unwrap();
113 | 
114 |         assert_eq!(d.since(&UNIX_EPOCH), c.expect);
115 |     }
116 | }
117 | 
118 | #[test]
119 | fn test_1970_to_9999() {
120 |     let mut sec: u64 = 0; // +08:00
121 | 
122 |     for y in 1970..10000 {
123 |         let year = y as u32;
124 |         if year > 1970 {
125 |             sec += 3600 * 24 * 365;
126 |             if is_leap_year(year - 1) {
127 |                 sec += 3600 * 24;
128 |             }
129 |         }
130 | 
131 |         assert!(
132 |             Time::from_timetuple(year, 1, 1, 0, 0, 0, 0, TimeZone::utc())
133 |                 .unwrap()
134 |                 .to_system_time()
135 |                 == Some(SystemTime::UNIX_EPOCH + Duration::new(sec.clone(), 0)),
136 |             "{}-01-01",
137 |             year,
138 |         );
139 | 
140 |         let feb_1st_sec = sec + 3600 * 24 * 31;
141 |         assert!(
142 |             Time::from_timetuple(year, 2, 1, 0, 0, 0, 0, TimeZone::new(0).unwrap())
143 |                 .unwrap()
144 |                 .to_system_time()
145 |                 == Some(SystemTime::UNIX_EPOCH + Duration::new(feb_1st_sec, 0)),
146 |             "{}-02-01",
147 |             year,
148 |         );
149 | 
150 |         let mut march_1st_sec = sec + 3600 * 24 * (31 + 28);
151 |         if is_leap_year(year) {
152 |             march_1st_sec += 3600 * 24;
153 |         }
154 | 
155 |         assert!(
156 |             Time::from_timetuple(year, 3, 1, 0, 0, 0, 0, TimeZone::new(0).unwrap())
157 |                 .unwrap()
158 |                 .to_system_time()
159 |                 == Some(SystemTime::UNIX_EPOCH + Duration::new(march_1st_sec, 0)),
160 |             "{}-03-01",
161 |             year,
162 |         );
163 |     }
164 | }
165 | 
166 | #[test]
167 | fn test_invalid_timetuple() {
168 |     let tuples: Vec<(u32, u32, u32, u32, u32, u32, u32, TimeZone)> = vec![
169 |         (10000, 1, 1, 0, 0, 0, 0, TimeZone::utc()),
170 |         (0, 1, 1, 0, 0, 0, 0, TimeZone::new(1).unwrap()),
171 |         (9999, 12, 31, 23, 0, 0, 0, TimeZone::new(-1).unwrap()),
172 |         (1988, 0, 1, 0, 0, 0, 0, TimeZone::utc()),
173 |         (1988, 13, 1, 0, 0, 0, 0, TimeZone::utc()),
174 |         (1988, 1, 0, 0, 0, 0, 0, TimeZone::utc()),
175 |         (1988, 1, 32, 0, 0, 0, 0, TimeZone::utc()),
176 |         (1987, 2, 29, 0, 0, 0, 0, TimeZone::utc()),
177 |         (1988, 2, 30, 0, 0, 0, 0, TimeZone::utc()),
178 |         (1988, 3, 32, 0, 0, 0, 0, TimeZone::utc()),
179 |         (1988, 4, 31, 0, 0, 0, 0, TimeZone::utc()),
180 |         (1988, 5, 32, 0, 0, 0, 0, TimeZone::utc()),
181 |         (1988, 6, 31, 0, 0, 0, 0, TimeZone::utc()),
182 |         (1988, 7, 32, 0, 0, 0, 0, TimeZone::utc()),
183 |         (1988, 8, 32, 0, 0, 0, 0, TimeZone::utc()),
184 |         (1988, 9, 31, 0, 0, 0, 0, TimeZone::utc()),
185 |         (1988, 10, 32, 0, 0, 0, 0, TimeZone::utc()),
186 |         (1988, 11, 31, 0, 0, 0, 0, TimeZone::utc()),
187 |         (1988, 12, 32, 0, 0, 0, 0, TimeZone::utc()),
188 |         (1988, 1, 1, 24, 0, 0, 0, TimeZone::utc()),
189 |         (1988, 1, 1, 23, 60, 0, 0, TimeZone::utc()),
190 |         (1988, 1, 1, 23, 59, 60, 0, TimeZone::utc()),
191 |         (1988, 1, 1, 23, 59, 59, 1_000_000_000, TimeZone::utc()),
192 |     ];
193 | 
194 |     for t in tuples {
195 |         assert_eq!(
196 |             Time::from_timetuple(t.0, t.1, t.2, t.3, t.4, t.5, t.6, t.7),
197 |             None,
198 |             "{:?}",
199 |             t,
200 |         );
201 |     }
202 | }
203 | 
204 | #[test]
205 | fn test_parse_rfc3339() {
206 |     struct Case<'a> {
207 |         s: &'a str,
208 |         expect: Result<Time, ParseError>,
209 |     }
210 | 
211 |     let cases: Vec<Case> = vec![
212 |         Case {
213 |             s: "2006-01-02",
214 |             expect: Ok(Time::from_timetuple(2006, 1, 2, 0, 0, 0, 0, TimeZone::utc()).unwrap()),
215 |         },
216 |         Case {
217 |             s: "2006-01-02T15:04:05",
218 |             expect: Ok(Time::from_timetuple(2006, 1, 2, 15, 4, 5, 0, TimeZone::utc()).unwrap()),
219 |         },
220 |         Case {
221 |             s: "2006-01-02 15:04:05",
222 |             expect: Ok(Time::from_timetuple(2006, 1, 2, 15, 4, 5, 0, TimeZone::utc()).unwrap()),
223 |         },
224 |         Case {
225 |             s: "2006-01-02 15:04:05Z",
226 |             expect: Ok(Time::from_timetuple(2006, 1, 2, 15, 4, 5, 0, TimeZone::utc()).unwrap()),
227 |         },
228 |         Case {
229 |             s: "2006-01-02 15:04:05+00:00",
230 |             expect: Ok(Time::from_timetuple(2006, 1, 2, 15, 4, 5, 0, TimeZone::utc()).unwrap()),
231 |         },
232 |         Case {
233 |             s: "2006-01-02 15:04:05-00:00",
234 |             expect: Ok(Time::from_timetuple(2006, 1, 2, 15, 4, 5, 0, TimeZone::utc()).unwrap()),
235 |         },
236 |         Case {
237 |             s: "2006-01-02T15:04:05.999999999Z",
238 |             expect: Ok(
239 |                 Time::from_timetuple(2006, 1, 2, 15, 4, 5, 999999999, TimeZone::utc()).unwrap(),
240 |             ),
241 |         },
242 |         Case {
243 |             s: "2006-01-02T15:04:05.123Z",
244 |             expect: Ok(
245 |                 Time::from_timetuple(2006, 1, 2, 15, 4, 5, 123000000, TimeZone::utc()).unwrap(),
246 |             ),
247 |         },
248 |         Case {
249 |             s: "2018-09-21T16:56:44.234867232+08:00",
250 |             expect: Ok(Time::from_timetuple(
251 |                 2018,
252 |                 9,
253 |                 21,
254 |                 16,
255 |                 56,
256 |                 44,
257 |                 234867232,
258 |                 TimeZone::new(8).unwrap(),
259 |             ).unwrap()),
260 |         },
261 |     ];
262 | 
263 |     for c in cases {
264 |         assert_eq!(parse_rfc3339(c.s), c.expect, "{}", c.s);
265 |     }
266 | }
267 | 
268 | #[test]
269 | fn test_parse_rfc3339_errors() {
270 |     struct Case<'a> {
271 |         s: &'a str,
272 |         expect: Result<Time, ParseError>,
273 |     }
274 | 
275 |     let cases: Vec<Case> = vec![
276 |         Case {
277 |             s: "",
278 |             expect: Err(ParseError::EmptyInput),
279 |         },
280 |         Case {
281 |             s: "2006-01-0",
282 |             expect: Err(ParseError::TooShort),
283 |         },
284 |         Case {
285 |             s: "2006-01-02 15:04:5",
286 |             expect: Err(ParseError::TooShort),
287 |         },
288 |         Case {
289 |             s: "2006-01-02T15:04:05.1234567890+08:00",
290 |             expect: Err(ParseError::TooLong),
291 |         },
292 |         Case {
293 |             s: "2006-01/02T15:04:05",
294 |             expect: Err(ParseError::Malformed),
295 |         },
296 |         Case {
297 |             s: "2006-01-02F15:04:05",
298 |             expect: Err(ParseError::Malformed),
299 |         },
300 |         Case {
301 |             s: "2006-01-02 15+04:05",
302 |             expect: Err(ParseError::Malformed),
303 |         },
304 |         Case {
305 |             s: "2006-01-02 15:04:05?",
306 |             expect: Err(ParseError::Malformed),
307 |         },
308 |         Case {
309 |             s: "200A-01-02 15:04:05",
310 |             expect: Err(ParseError::InvalidValue),
311 |         },
312 |         Case {
313 |             s: "2006-A1-02 15:04:05",
314 |             expect: Err(ParseError::InvalidValue),
315 |         },
316 |         Case {
317 |             s: "2006-01-0A 15:04:05",
318 |             expect: Err(ParseError::InvalidValue),
319 |         },
320 |         Case {
321 |             s: "2006-01-02 1A:04:05",
322 |             expect: Err(ParseError::InvalidValue),
323 |         },
324 |         Case {
325 |             s: "2006-01-02 15:0A:05",
326 |             expect: Err(ParseError::InvalidValue),
327 |         },
328 |         Case {
329 |             s: "2006-01-02 15:04:A5",
330 |             expect: Err(ParseError::InvalidValue),
331 |         },
332 |         Case {
333 |             s: "2006-01-02 15:04:05.Z",
334 |             expect: Err(ParseError::MissingValue),
335 |         },
336 |         Case {
337 |             s: "2006-01-02T15:04:05.1235Z08",
338 |             expect: Err(ParseError::InvalidTimezone),
339 |         },
340 |         Case {
341 |             s: "2018-02-29T15:04:05.1235",
342 |             expect: Err(ParseError::Overflow),
343 |         },
344 |     ];
345 | 
346 |     for c in cases {
347 |         assert_eq!(parse_rfc3339(c.s), c.expect, "{}", c.s);
348 |     }
349 | }
350 | 
351 | #[test]
352 | fn test_from_str() {
353 |     assert_eq!(
354 |         "2018-09-21T16:56:44.234867232+08:00".parse::<Time>(),
355 |         Ok(Time::from_timetuple(
356 |             2018,
357 |             9,
358 |             21,
359 |             16,
360 |             56,
361 |             44,
362 |             234867232,
363 |             TimeZone::new(8).unwrap(),
364 |         ).unwrap())
365 |     );
366 | }
367 | 


--------------------------------------------------------------------------------
/src/time/timezone.rs:
--------------------------------------------------------------------------------
 1 | use std::str::FromStr;
 2 | use ParseError;
 3 | 
 4 | const OFFSETS: [i32; 25] = [
 5 |     3600 * -12,
 6 |     3600 * -11,
 7 |     3600 * -10,
 8 |     3600 * -9,
 9 |     3600 * -8,
10 |     3600 * -7,
11 |     3600 * -6,
12 |     3600 * -5,
13 |     3600 * -4,
14 |     3600 * -3,
15 |     3600 * -2,
16 |     3600 * -1,
17 |     0,
18 |     3600,
19 |     3600 * 2,
20 |     3600 * 3,
21 |     3600 * 4,
22 |     3600 * 5,
23 |     3600 * 6,
24 |     3600 * 7,
25 |     3600 * 8,
26 |     3600 * 9,
27 |     3600 * 10,
28 |     3600 * 11,
29 |     3600 * 12,
30 | ];
31 | 
32 | /// Represents timezone in datetime string
33 | #[derive(Debug, Copy, Clone, Eq, PartialEq)]
34 | pub struct TimeZone(i32);
35 | 
36 | impl TimeZone {
37 |     /// Returns timezone UTC
38 |     pub fn utc() -> TimeZone {
39 |         TimeZone(0)
40 |     }
41 | 
42 |     /// Returns a timezone with the given hour offset
43 |     pub fn new(hoffset: i32) -> Option<TimeZone> {
44 |         if hoffset < -12 || hoffset > 12 {
45 |             return None;
46 |         }
47 | 
48 |         Some(TimeZone(OFFSETS[(hoffset + 12) as usize]))
49 |     }
50 | 
51 |     /// Returns the actual offset in seconds
52 |     pub fn offset(&self) -> i32 {
53 |         return self.0;
54 |     }
55 | }
56 | 
57 | impl FromStr for TimeZone {
58 |     type Err = ParseError;
59 |     fn from_str(s: &str) -> Result<Self, Self::Err> {
60 |         match s {
61 |             "" | "Z" | "+00:00" | "-00:00" => Ok(TimeZone(0)),
62 |             "-12:00" => Ok(TimeZone(OFFSETS[0])),
63 |             "-11:00" => Ok(TimeZone(OFFSETS[1])),
64 |             "-10:00" => Ok(TimeZone(OFFSETS[2])),
65 |             "-09:00" => Ok(TimeZone(OFFSETS[3])),
66 |             "-08:00" => Ok(TimeZone(OFFSETS[4])),
67 |             "-07:00" => Ok(TimeZone(OFFSETS[5])),
68 |             "-06:00" => Ok(TimeZone(OFFSETS[6])),
69 |             "-05:00" => Ok(TimeZone(OFFSETS[7])),
70 |             "-04:00" => Ok(TimeZone(OFFSETS[8])),
71 |             "-03:00" => Ok(TimeZone(OFFSETS[9])),
72 |             "-02:00" => Ok(TimeZone(OFFSETS[10])),
73 |             "-01:00" => Ok(TimeZone(OFFSETS[11])),
74 | 
75 |             "+01:00" => Ok(TimeZone(OFFSETS[13])),
76 |             "+02:00" => Ok(TimeZone(OFFSETS[14])),
77 |             "+03:00" => Ok(TimeZone(OFFSETS[15])),
78 |             "+04:00" => Ok(TimeZone(OFFSETS[16])),
79 |             "+05:00" => Ok(TimeZone(OFFSETS[17])),
80 |             "+06:00" => Ok(TimeZone(OFFSETS[18])),
81 |             "+07:00" => Ok(TimeZone(OFFSETS[19])),
82 |             "+08:00" => Ok(TimeZone(OFFSETS[20])),
83 |             "+09:00" => Ok(TimeZone(OFFSETS[21])),
84 |             "+10:00" => Ok(TimeZone(OFFSETS[22])),
85 |             "+11:00" => Ok(TimeZone(OFFSETS[23])),
86 |             "+12:00" => Ok(TimeZone(OFFSETS[24])),
87 |             _ => Err(ParseError::InvalidTimezone),
88 |         }
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------