├── .gitignore
├── Cargo.toml
├── src
    ├── duration.rs
    ├── bytes.rs
    ├── time.rs
    ├── lib.rs
    ├── de.rs
    └── tests.rs
├── LICENSE
└── README.md


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


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "serde-humanize-rs"
 3 | version = "0.1.1"
 4 | authors = ["dtynn <dtynn@163.com>"]
 5 | description = """
 6 |     A Serde deserializer for duration and byte-size.
 7 | """
 8 | readme = "README.md"
 9 | license-file = "LICENSE"
10 | homepage = "https://github.com/dtynn/serde-humanize-rs"
11 | documentation = "https://docs.rs/serde-humanize-rs"
12 | repository = "https://github.com/dtynn/serde-humanize-rs"
13 | keywords = ["humanize", "human-friendly", "readable", "serde", "deserialize"]
14 | categories = ["parsing"]
15 | 
16 | [dependencies]
17 | serde = "1.0"
18 | humanize-rs = "0.1.4"
19 | 
20 | [dev-dependencies]
21 | serde_derive = "1.0"
22 | serde_json = "1.0"
23 | 


--------------------------------------------------------------------------------
/src/duration.rs:
--------------------------------------------------------------------------------
 1 | use de::DE;
 2 | use humanize_rs::duration::parse;
 3 | use serde::de::{Deserializer, Error, Unexpected, Visitor};
 4 | use std::fmt;
 5 | use std::time::Duration;
 6 | 
 7 | impl DE for Duration {
 8 |     fn de<'de, D>(d: D) -> Result<Duration, D::Error>
 9 |     where
10 |         D: Deserializer<'de>,
11 |     {
12 |         struct V;
13 | 
14 |         impl<'v> Visitor<'v> for V {
15 |             type Value = Duration;
16 | 
17 |             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
18 |                 formatter.write_str("expecting duration")
19 |             }
20 | 
21 |             fn visit_str<E>(self, s: &str) -> Result<Duration, E>
22 |             where
23 |                 E: Error,
24 |             {
25 |                 parse(s).map_err(|_| Error::invalid_value(Unexpected::Str(s), &self))
26 |             }
27 |         }
28 | 
29 |         d.deserialize_str(V)
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/bytes.rs:
--------------------------------------------------------------------------------
 1 | use de::DE;
 2 | use humanize_rs::bytes::Bytes;
 3 | use serde::de::{Deserializer, Error, Unexpected, Visitor};
 4 | use std::fmt;
 5 | 
 6 | impl DE for usize {
 7 |     fn de<'de, D>(d: D) -> Result<Self, D::Error>
 8 |     where
 9 |         Self: Sized,
10 |         D: Deserializer<'de>,
11 |     {
12 |         struct V;
13 | 
14 |         impl<'v> Visitor<'v> for V {
15 |             type Value = usize;
16 | 
17 |             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
18 |                 formatter.write_str("expecting byte-size")
19 |             }
20 | 
21 |             fn visit_str<E>(self, s: &str) -> Result<usize, E>
22 |             where
23 |                 E: Error,
24 |             {
25 |                 let bytes = s
26 |                     .parse::<Bytes>()
27 |                     .map_err(|_| Error::invalid_value(Unexpected::Str(s), &self))?;
28 | 
29 |                 Ok(bytes.size())
30 |             }
31 |         }
32 | 
33 |         d.deserialize_str(V)
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/time.rs:
--------------------------------------------------------------------------------
 1 | use de::DE;
 2 | use humanize_rs::time::Time;
 3 | use humanize_rs::ParseError;
 4 | use serde::de::{Deserializer, Error, Unexpected, Visitor};
 5 | use std::fmt;
 6 | use std::time::SystemTime;
 7 | 
 8 | impl DE for SystemTime {
 9 |     fn de<'de, D>(d: D) -> Result<SystemTime, D::Error>
10 |     where
11 |         D: Deserializer<'de>,
12 |     {
13 |         struct V;
14 | 
15 |         impl<'v> Visitor<'v> for V {
16 |             type Value = SystemTime;
17 | 
18 |             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
19 |                 formatter.write_str("expecting rfc3339 datetime string")
20 |             }
21 | 
22 |             fn visit_str<E>(self, s: &str) -> Result<SystemTime, E>
23 |             where
24 |                 E: Error,
25 |             {
26 |                 s.parse::<Time>()
27 |                     .and_then(|t| t.to_system_time().ok_or(ParseError::Overflow))
28 |                     .map_err(|_| Error::invalid_value(Unexpected::Str(s), &self))
29 |             }
30 |         }
31 | 
32 |         d.deserialize_str(V)
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/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 | ## serde-humanize-rs
 2 | A Serde deserializer for duration and byte-size using the crate [humanize-rs](https://github.com/dtynn/humanize-rs).
 3 | 
 4 | ### Supported typs
 5 | - Byte-size: "10 MB", "10 MiB", "3 tib" ...
 6 | - Duration: "10ms", "90m", "2d5h30m42s" ...
 7 | - Datetime(RFC3339): "2008-03-01T10:23:57Z", "2008-03-01T10:23:57.557", "2008-03-01T10:23:57.557+08:00" ...
 8 | 
 9 | ### Usage
10 | 1. Add this lib as a dependency
11 | ```
12 | [dependencies]
13 | serde-humanize-rs = "0.1"
14 | ```
15 | 
16 | 2. Add the crate reference
17 | ```
18 | extern crate serde_humanize_rs;
19 | ```
20 | 
21 | ### Example
22 | ```
23 | extern crate serde;
24 | #[macro_use] extern crate serde_derive;
25 | extern crate serde_json;
26 | extern crate serde_humanize_rs;
27 | 
28 | use std::time::Duration;
29 | 
30 | #[derive(Deserialize)]
31 | struct Config {
32 |     #[serde(with = "serde_humanize_rs")]
33 |     size: usize,
34 | 
35 |     #[serde(with = "serde_humanize_rs")]
36 |     interval: Duration,
37 | }
38 | 
39 | let json = r#"{"size": "1 M", "interval": "1h30m", "close_at": "2105-03-01T10:23:57.000013579+08:00"}"#;
40 | let cfg = serde_json::from_str::<Config>(json).unwrap();
41 | assert_eq!(cfg.size, 1_000_000);
42 | assert_eq!(cfg.interval, Duration::from_secs(5400));
43 | assert_eq!(
44 |     cfg.close_at.duration_since(SystemTime::UNIX_EPOCH).unwrap(),
45 |     Duration::new(4265317437, 000013579)
46 | );
47 | ```
48 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | //! A Serde deserializer for duration and byte-size using the crate [`humanize-rs`].
 2 | //!
 3 | //! # Example
 4 | //! ```
 5 | //! extern crate serde;
 6 | //! #[macro_use] extern crate serde_derive;
 7 | //! extern crate serde_json;
 8 | //! extern crate serde_humanize_rs;
 9 | //!
10 | //! use std::time::{Duration, SystemTime};
11 | //!
12 | //! #[derive(Deserialize)]
13 | //! struct Config {
14 | //!     #[serde(with = "serde_humanize_rs")]
15 | //!     size: usize,
16 | //!
17 | //!     #[serde(with = "serde_humanize_rs")]
18 | //!     interval: Duration,
19 | //!
20 | //!     #[serde(with = "serde_humanize_rs")]
21 | //!     close_at: SystemTime,
22 | //! }
23 | //!
24 | //! let json = r#"{"size": "1 M", "interval": "1h30m", "close_at": "2105-03-01T10:23:57.000013579+08:00"}"#;
25 | //! let cfg = serde_json::from_str::<Config>(json).unwrap();
26 | //! assert_eq!(cfg.size, 1_000_000);
27 | //! assert_eq!(cfg.interval, Duration::from_secs(5400));
28 | //! assert_eq!(
29 | //!     cfg.close_at.duration_since(SystemTime::UNIX_EPOCH).unwrap(),
30 | //!     Duration::new(4265317437, 000013579)
31 | //! );
32 | //! ```
33 | //!
34 | //! [`humanize-rs`]: https://github.com/dtynn/humanize-rs
35 | 
36 | #![warn(missing_docs)]
37 | 
38 | extern crate humanize_rs;
39 | extern crate serde;
40 | 
41 | #[cfg(test)]
42 | #[macro_use]
43 | extern crate serde_derive;
44 | #[cfg(test)]
45 | extern crate serde_json;
46 | 
47 | mod bytes;
48 | mod de;
49 | mod duration;
50 | mod time;
51 | 
52 | #[cfg(test)]
53 | mod tests;
54 | 
55 | pub use de::deserialize;
56 | 


--------------------------------------------------------------------------------
/src/de.rs:
--------------------------------------------------------------------------------
 1 | use serde::de::{Deserializer, Error, Visitor};
 2 | use std::fmt;
 3 | use std::marker::PhantomData;
 4 | 
 5 | pub trait DE {
 6 |     fn de<'de, D>(d: D) -> Result<Self, D::Error>
 7 |     where
 8 |         Self: Sized,
 9 |         D: Deserializer<'de>;
10 | }
11 | 
12 | /// Deserialize function.
13 | pub fn deserialize<'de, T, D>(d: D) -> Result<T, D::Error>
14 | where
15 |     D: Deserializer<'de>,
16 |     T: DE + Sized,
17 | {
18 |     <T as DE>::de(d)
19 | }
20 | 
21 | impl<T: DE> DE for Option<T> {
22 |     fn de<'de, D>(d: D) -> Result<Self, D::Error>
23 |     where
24 |         Self: Sized,
25 |         D: Deserializer<'de>,
26 |     {
27 |         struct OptVisitor<T> {
28 |             marker: PhantomData<T>,
29 |         }
30 | 
31 |         impl<'de, T: DE> Visitor<'de> for OptVisitor<T> {
32 |             type Value = Option<T>;
33 | 
34 |             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
35 |                 formatter.write_str("option")
36 |             }
37 | 
38 |             #[inline]
39 |             fn visit_unit<E>(self) -> Result<Option<T>, E>
40 |             where
41 |                 E: Error,
42 |             {
43 |                 Ok(None)
44 |             }
45 | 
46 |             #[inline]
47 |             fn visit_none<E>(self) -> Result<Option<T>, E>
48 |             where
49 |                 E: Error,
50 |             {
51 |                 Ok(None)
52 |             }
53 | 
54 |             #[inline]
55 |             fn visit_some<D>(self, deserializer: D) -> Result<Option<T>, D::Error>
56 |             where
57 |                 D: Deserializer<'de>,
58 |             {
59 |                 T::de(deserializer).map(Some)
60 |             }
61 |         }
62 | 
63 |         d.deserialize_option(OptVisitor {
64 |             marker: PhantomData,
65 |         })
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/tests.rs:
--------------------------------------------------------------------------------
  1 | use serde_json;
  2 | use std::time::{Duration, SystemTime};
  3 | 
  4 | #[test]
  5 | fn test_parse_duration() {
  6 |     #[derive(Deserialize)]
  7 |     struct Foo {
  8 |         #[serde(with = "super")]
  9 |         time: Duration,
 10 |     }
 11 | 
 12 |     let json = r#"{"time": "15s"}"#;
 13 |     let foo = serde_json::from_str::<Foo>(json).unwrap();
 14 |     assert_eq!(foo.time, Duration::from_secs(15));
 15 | }
 16 | 
 17 | #[test]
 18 | fn test_parse_option_duration() {
 19 |     #[derive(Deserialize)]
 20 |     struct Foo {
 21 |         #[serde(with = "super")]
 22 |         time: Option<Duration>,
 23 |     }
 24 | 
 25 |     let json = r#"{"time": "15s"}"#;
 26 |     let foo = serde_json::from_str::<Foo>(json).unwrap();
 27 |     assert_eq!(foo.time, Some(Duration::from_secs(15)));
 28 | 
 29 |     let json2 = r#"{"time": null}"#;
 30 |     let foo2 = serde_json::from_str::<Foo>(json2).unwrap();
 31 |     assert_eq!(foo2.time, None);
 32 | }
 33 | 
 34 | #[test]
 35 | fn test_parse_byte_size() {
 36 |     #[derive(Deserialize)]
 37 |     struct Foo {
 38 |         #[serde(with = "super")]
 39 |         size: usize,
 40 |     }
 41 | 
 42 |     let json = r#"{"size": "1 M"}"#;
 43 |     let foo = serde_json::from_str::<Foo>(json).unwrap();
 44 |     assert_eq!(foo.size, 1_000_000);
 45 | }
 46 | 
 47 | #[test]
 48 | fn test_parse_option_byte_size() {
 49 |     #[derive(Deserialize)]
 50 |     struct Foo {
 51 |         #[serde(with = "super")]
 52 |         size: Option<usize>,
 53 |     }
 54 | 
 55 |     let json = r#"{"size": "1 M"}"#;
 56 |     let foo = serde_json::from_str::<Foo>(json).unwrap();
 57 |     assert_eq!(foo.size, Some(1_000_000));
 58 | 
 59 |     let json2 = r#"{"size": null}"#;
 60 |     let foo2 = serde_json::from_str::<Foo>(json2).unwrap();
 61 |     assert_eq!(foo2.size, None);
 62 | }
 63 | 
 64 | #[test]
 65 | fn test_parse_datetime() {
 66 |     #[derive(Deserialize)]
 67 |     struct Foo {
 68 |         #[serde(with = "super")]
 69 |         close_at: SystemTime,
 70 |     }
 71 | 
 72 |     let json = r#"{"close_at": "2105-03-01T10:23:57.000013579+08:00"}"#;
 73 |     let foo = serde_json::from_str::<Foo>(json).unwrap();
 74 |     assert_eq!(
 75 |         foo.close_at.duration_since(SystemTime::UNIX_EPOCH).unwrap(),
 76 |         Duration::new(4265317437, 000013579)
 77 |     );
 78 | }
 79 | 
 80 | #[test]
 81 | fn test_parse_option_datetime() {
 82 |     #[derive(Deserialize)]
 83 |     struct Foo {
 84 |         #[serde(with = "super")]
 85 |         close_at: Option<SystemTime>,
 86 |     }
 87 | 
 88 |     let json = r#"{"close_at": "2105-03-01T10:23:57.000013579+08:00"}"#;
 89 |     let foo = serde_json::from_str::<Foo>(json).unwrap();
 90 |     assert_eq!(
 91 |         foo.close_at
 92 |             .unwrap()
 93 |             .duration_since(SystemTime::UNIX_EPOCH)
 94 |             .unwrap(),
 95 |         Duration::new(4265317437, 000013579)
 96 |     );
 97 | 
 98 |     let json2 = r#"{"close_at": null}"#;
 99 |     let foo2 = serde_json::from_str::<Foo>(json2).unwrap();
100 |     assert_eq!(foo2.close_at, None);
101 | }
102 | 


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