Skip to content

Commit ffbc6ab

Browse files
robjtederobjtede
authored
chore: move serde impls to module (#62)
1 parent bb37433 commit ffbc6ab

File tree

3 files changed

+105
-105
lines changed

3 files changed

+105
-105
lines changed

‎Cargo.toml

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ version = "1.3.0"
55
authors = ["Hyunsik Choi <[email protected]>", "MrCroxx <[email protected]>"]
66
keywords = ["byte", "byte-size", "utility", "human-readable", "format"]
77
categories = ["development-tools", "filesystem"]
8-
repository = "https://github.com/hyunsik/bytesize"
8+
repository = "https://github.com/bytesize-rs/bytesize"
99
license = "Apache-2.0"
1010
edition = "2021"
1111
rust-version = "1.65"

‎src/lib.rs

Lines changed: 1 addition & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -28,15 +28,8 @@
2828
//! ```
2929
3030
mod parse;
31-
32-
#[cfg(feature = "arbitrary")]
33-
extern crate arbitrary;
34-
#[cfg(feature = "serde")]
35-
extern crate serde;
36-
#[cfg(feature = "serde")]
37-
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
3831
#[cfg(feature = "serde")]
39-
use std::convert::TryFrom;
32+
mod serde;
4033

4134
use std::fmt::{self, Debug, Display, Formatter};
4235
use std::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
@@ -342,70 +335,6 @@ where
342335
}
343336
}
344337

345-
#[cfg(feature = "serde")]
346-
impl<'de> Deserialize<'de> for ByteSize {
347-
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
348-
where
349-
D: Deserializer<'de>,
350-
{
351-
struct ByteSizeVisitor;
352-
353-
impl de::Visitor<'_> for ByteSizeVisitor {
354-
type Value = ByteSize;
355-
356-
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
357-
formatter.write_str("an integer or string")
358-
}
359-
360-
fn visit_i64<E: de::Error>(self, value: i64) -> Result<Self::Value, E> {
361-
if let Ok(val) = u64::try_from(value) {
362-
Ok(ByteSize(val))
363-
} else {
364-
Err(E::invalid_value(
365-
de::Unexpected::Signed(value),
366-
&"integer overflow",
367-
))
368-
}
369-
}
370-
371-
fn visit_u64<E: de::Error>(self, value: u64) -> Result<Self::Value, E> {
372-
Ok(ByteSize(value))
373-
}
374-
375-
fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
376-
if let Ok(val) = value.parse() {
377-
Ok(val)
378-
} else {
379-
Err(E::invalid_value(
380-
de::Unexpected::Str(value),
381-
&"parsable string",
382-
))
383-
}
384-
}
385-
}
386-
387-
if deserializer.is_human_readable() {
388-
deserializer.deserialize_any(ByteSizeVisitor)
389-
} else {
390-
deserializer.deserialize_u64(ByteSizeVisitor)
391-
}
392-
}
393-
}
394-
395-
#[cfg(feature = "serde")]
396-
impl Serialize for ByteSize {
397-
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
398-
where
399-
S: Serializer,
400-
{
401-
if serializer.is_human_readable() {
402-
<str>::serialize(self.to_string().as_str(), serializer)
403-
} else {
404-
self.0.serialize(serializer)
405-
}
406-
}
407-
}
408-
409338
#[cfg(test)]
410339
mod tests {
411340
use super::*;
@@ -537,36 +466,4 @@ mod tests {
537466
fn test_to_string() {
538467
assert_to_string("609.0 PB", ByteSize::pb(609), false);
539468
}
540-
541-
#[cfg(feature = "serde")]
542-
#[test]
543-
fn test_serde() {
544-
#[derive(Serialize, Deserialize)]
545-
struct S {
546-
x: ByteSize,
547-
}
548-
549-
let s: S = serde_json::from_str(r#"{ "x": "5 B" }"#).unwrap();
550-
assert_eq!(s.x, ByteSize(5));
551-
552-
let s: S = serde_json::from_str(r#"{ "x": 1048576 }"#).unwrap();
553-
assert_eq!(s.x, "1 MiB".parse::<ByteSize>().unwrap());
554-
555-
let s: S = toml::from_str(r#"x = "2.5 MiB""#).unwrap();
556-
assert_eq!(s.x, "2.5 MiB".parse::<ByteSize>().unwrap());
557-
558-
// i64 MAX
559-
let s: S = toml::from_str(r#"x = "9223372036854775807""#).unwrap();
560-
assert_eq!(s.x, "9223372036854775807".parse::<ByteSize>().unwrap());
561-
}
562-
563-
#[test]
564-
#[cfg(feature = "serde")]
565-
fn test_serde_json() {
566-
let json = serde_json::to_string(&ByteSize::mib(1)).unwrap();
567-
assert_eq!(json, "\"1.0 MiB\"");
568-
569-
let deserialized: ByteSize = serde_json::from_str(&json).unwrap();
570-
assert_eq!(deserialized.0, 1048576);
571-
}
572469
}

‎src/serde.rs

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
use std::fmt;
2+
3+
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
4+
5+
use crate::ByteSize;
6+
7+
impl<'de> Deserialize<'de> for ByteSize {
8+
fn deserialize<D>(de: D) -> Result<Self, D::Error>
9+
where
10+
D: Deserializer<'de>,
11+
{
12+
struct ByteSizeVisitor;
13+
14+
impl de::Visitor<'_> for ByteSizeVisitor {
15+
type Value = ByteSize;
16+
17+
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
18+
formatter.write_str("an integer or string")
19+
}
20+
21+
fn visit_i64<E: de::Error>(self, value: i64) -> Result<Self::Value, E> {
22+
if let Ok(val) = u64::try_from(value) {
23+
Ok(ByteSize(val))
24+
} else {
25+
Err(E::invalid_value(
26+
de::Unexpected::Signed(value),
27+
&"integer overflow",
28+
))
29+
}
30+
}
31+
32+
fn visit_u64<E: de::Error>(self, value: u64) -> Result<Self::Value, E> {
33+
Ok(ByteSize(value))
34+
}
35+
36+
fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
37+
if let Ok(val) = value.parse() {
38+
Ok(val)
39+
} else {
40+
Err(E::invalid_value(
41+
de::Unexpected::Str(value),
42+
&"parsable string",
43+
))
44+
}
45+
}
46+
}
47+
48+
if de.is_human_readable() {
49+
de.deserialize_any(ByteSizeVisitor)
50+
} else {
51+
de.deserialize_u64(ByteSizeVisitor)
52+
}
53+
}
54+
}
55+
56+
impl Serialize for ByteSize {
57+
fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
58+
where
59+
S: Serializer,
60+
{
61+
if ser.is_human_readable() {
62+
<str>::serialize(self.to_string().as_str(), ser)
63+
} else {
64+
self.0.serialize(ser)
65+
}
66+
}
67+
}
68+
69+
#[cfg(test)]
70+
mod tests {
71+
use super::*;
72+
73+
#[test]
74+
fn test_serde() {
75+
#[derive(Serialize, Deserialize)]
76+
struct S {
77+
x: ByteSize,
78+
}
79+
80+
let s = serde_json::from_str::<S>(r#"{ "x": "5 B" }"#).unwrap();
81+
assert_eq!(s.x, ByteSize(5));
82+
83+
let s = serde_json::from_str::<S>(r#"{ "x": 1048576 }"#).unwrap();
84+
assert_eq!(s.x, "1 MiB".parse::<ByteSize>().unwrap());
85+
86+
let s = toml::from_str::<S>(r#"x = "2.5 MiB""#).unwrap();
87+
assert_eq!(s.x, "2.5 MiB".parse::<ByteSize>().unwrap());
88+
89+
// i64 MAX
90+
let s = toml::from_str::<S>(r#"x = "9223372036854775807""#).unwrap();
91+
assert_eq!(s.x, "9223372036854775807".parse::<ByteSize>().unwrap());
92+
}
93+
94+
#[test]
95+
96+
fn test_serde_json() {
97+
let json = serde_json::to_string(&ByteSize::mib(1)).unwrap();
98+
assert_eq!(json, "\"1.0 MiB\"");
99+
100+
let deserialized = serde_json::from_str::<ByteSize>(&json).unwrap();
101+
assert_eq!(deserialized.0, 1048576);
102+
}
103+
}

0 commit comments

Comments
 (0)