From 556822fda7f2af13ad89399710a1c216f537dc5e Mon Sep 17 00:00:00 2001 From: William Date: Thu, 12 Sep 2024 08:23:50 -0700 Subject: [PATCH] change error message in try_unpack when entry not found --- example/src/main.rs | 5 +++-- wkt-types/src/lib.rs | 1 - wkt-types/src/pbany.rs | 2 +- wkt-types/src/pbempty.rs | 3 ++- wkt-types/src/pbstruct.rs | 26 +++++++++----------------- wkt-types/src/pbtime/datetime.rs | 1 - wkt-types/src/pbtime/duration.rs | 8 +++----- wkt-types/src/pbtime/mod.rs | 12 ++++++++---- wkt-types/src/pbtime/timestamp.rs | 1 - wkt-types/tests/pbstruct_test.rs | 5 ++--- 10 files changed, 28 insertions(+), 36 deletions(-) diff --git a/example/src/main.rs b/example/src/main.rs index a29d30d..8c300d2 100644 --- a/example/src/main.rs +++ b/example/src/main.rs @@ -6,8 +6,9 @@ include!(concat!(env!("OUT_DIR"), "/my.messages.rs")); include!(concat!(env!("OUT_DIR"), "/my.requests.rs")); fn main() -> Result<(), AnyError> { - - let content: Content = Content { body: Some(content::Body::SomeBool(true)) }; + let content: Content = Content { + body: Some(content::Body::SomeBool(true)), + }; let foo_msg: Foo = Foo { data: "Hello World".to_string(), diff --git a/wkt-types/src/lib.rs b/wkt-types/src/lib.rs index 1d02c1c..940a3d4 100644 --- a/wkt-types/src/lib.rs +++ b/wkt-types/src/lib.rs @@ -16,4 +16,3 @@ mod pbmask; pub use crate::pbmask::*; pub use prost_wkt::MessageSerde; - diff --git a/wkt-types/src/pbany.rs b/wkt-types/src/pbany.rs index a2b6c84..59dbedf 100644 --- a/wkt-types/src/pbany.rs +++ b/wkt-types/src/pbany.rs @@ -91,7 +91,7 @@ impl Any { /// let back: Box = any.try_unpack()?; /// ``` pub fn try_unpack(self) -> Result, AnyError> { - find_entry(&self.type_url).ok_or_else(|| format!("Failed to deserialize {}. Make sure prost-wkt-build is executed.", self.type_url)) + find_entry(&self.type_url).ok_or_else(|| format!("Failed to deserialize {}. Make sure the MessageSerde trait is derived through its proc macro.", self.type_url)) .and_then(|entry| { (entry.decoder)(&self.value).map_err(|error| { format!( diff --git a/wkt-types/src/pbempty.rs b/wkt-types/src/pbempty.rs index 659d09e..12ab968 100644 --- a/wkt-types/src/pbempty.rs +++ b/wkt-types/src/pbempty.rs @@ -24,7 +24,8 @@ mod tests { #[test] fn deserialize_empty() { - let msg: Empty = serde_json::from_str("{}").expect("Could not deserialize `{}` to an Empty struct!"); + let msg: Empty = + serde_json::from_str("{}").expect("Could not deserialize `{}` to an Empty struct!"); assert_eq!(msg, EMPTY); } diff --git a/wkt-types/src/pbstruct.rs b/wkt-types/src/pbstruct.rs index 4b53097..26b8e82 100644 --- a/wkt-types/src/pbstruct.rs +++ b/wkt-types/src/pbstruct.rs @@ -201,7 +201,7 @@ impl Serialize for Struct { { let mut map = serializer.serialize_map(Some(self.fields.len()))?; for (k, v) in &self.fields { - map.serialize_entry( k, v)?; + map.serialize_entry(k, v)?; } map.end() } @@ -217,12 +217,8 @@ impl Serialize for Value { Some(value::Kind::StringValue(string)) => serializer.serialize_str(string), Some(value::Kind::BoolValue(boolean)) => serializer.serialize_bool(*boolean), Some(value::Kind::NullValue(_)) => serializer.serialize_none(), - Some(value::Kind::ListValue(list)) => { - list.serialize(serializer) - } - Some(value::Kind::StructValue(object)) => { - object.serialize(serializer) - } + Some(value::Kind::ListValue(list)) => list.serialize(serializer), + Some(value::Kind::StructValue(object)) => object.serialize(serializer), _ => serializer.serialize_none(), } } @@ -244,9 +240,7 @@ impl<'de> Visitor<'de> for ListValueVisitor { while let Some(el) = seq.next_element()? { values.push(el) } - Ok(ListValue { - values - }) + Ok(ListValue { values }) } } @@ -271,21 +265,19 @@ impl<'de> Visitor<'de> for StructVisitor { where A: MapAccess<'de>, { - let mut fields: std::collections::HashMap = - std::collections::HashMap::new(); + let mut fields: std::collections::HashMap = std::collections::HashMap::new(); while let Some((key, value)) = map.next_entry::()? { fields.insert(key, value); } - Ok(Struct { - fields - }) + Ok(Struct { fields }) } } impl<'de> Deserialize<'de> for Struct { fn deserialize(deserializer: D) -> Result>::Error> - where - D: Deserializer<'de> { + where + D: Deserializer<'de>, + { deserializer.deserialize_map(StructVisitor) } } diff --git a/wkt-types/src/pbtime/datetime.rs b/wkt-types/src/pbtime/datetime.rs index b2f1c07..369cb89 100644 --- a/wkt-types/src/pbtime/datetime.rs +++ b/wkt-types/src/pbtime/datetime.rs @@ -4,7 +4,6 @@ //////////////////////////////////////////////////////////////////////////////// /// FROM prost-types/src/datetime.rs //////////////////////////////////////////////////////////////////////////////// - use core::fmt; use crate::Duration; diff --git a/wkt-types/src/pbtime/duration.rs b/wkt-types/src/pbtime/duration.rs index fcad5ec..c5df49d 100644 --- a/wkt-types/src/pbtime/duration.rs +++ b/wkt-types/src/pbtime/duration.rs @@ -190,9 +190,10 @@ impl From for chrono::Duration { // A call to `normalize` should capture all out-of-bound sitations hopefully // ensuring a panic never happens! Ideally this implementation should be // deprecated in favour of TryFrom but unfortunately having `TryFrom` along with - // `From` causes a conflict. + // `From` causes a conflict. value.normalize(); - let s = chrono::TimeDelta::try_seconds(value.seconds).expect("invalid or out-of-range seconds"); + let s = + chrono::TimeDelta::try_seconds(value.seconds).expect("invalid or out-of-range seconds"); let ns = chrono::Duration::nanoseconds(value.nanos as i64); s + ns } @@ -276,6 +277,3 @@ impl<'de> Deserialize<'de> for Duration { deserializer.deserialize_str(DurationVisitor) } } - - - diff --git a/wkt-types/src/pbtime/mod.rs b/wkt-types/src/pbtime/mod.rs index 19266c7..e58df0d 100644 --- a/wkt-types/src/pbtime/mod.rs +++ b/wkt-types/src/pbtime/mod.rs @@ -8,8 +8,8 @@ pub use timestamp::TimestampError; use core::convert::TryFrom; use core::str::FromStr; -use core::*; use core::time; +use core::*; use std::convert::TryInto; use chrono::prelude::*; @@ -26,7 +26,6 @@ include!(concat!(env!("OUT_DIR"), "/pbtime/google.protobuf.rs")); const NANOS_PER_SECOND: i32 = 1_000_000_000; const NANOS_MAX: i32 = NANOS_PER_SECOND - 1; - #[cfg(test)] mod tests { @@ -89,12 +88,17 @@ mod tests { }; let chrono_duration: chrono::Duration = duration.into(); assert_eq!(chrono_duration.num_seconds(), 10); - assert_eq!((chrono_duration - chrono::Duration::try_seconds(10).expect("seconds")).num_nanoseconds(), Some(100)); + assert_eq!( + (chrono_duration - chrono::Duration::try_seconds(10).expect("seconds")) + .num_nanoseconds(), + Some(100) + ); } #[test] fn test_duration_conversion_chrono_to_pb() { - let chrono_duration = chrono::Duration::try_seconds(10).expect("seconds") + chrono::Duration::nanoseconds(100); + let chrono_duration = chrono::Duration::try_seconds(10).expect("seconds") + + chrono::Duration::nanoseconds(100); let duration: Duration = chrono_duration.into(); assert_eq!(duration.seconds, 10); assert_eq!(duration.nanos, 100); diff --git a/wkt-types/src/pbtime/timestamp.rs b/wkt-types/src/pbtime/timestamp.rs index 471a205..6e66724 100644 --- a/wkt-types/src/pbtime/timestamp.rs +++ b/wkt-types/src/pbtime/timestamp.rs @@ -320,4 +320,3 @@ impl<'de> Deserialize<'de> for Timestamp { deserializer.deserialize_str(TimestampVisitor) } } - diff --git a/wkt-types/tests/pbstruct_test.rs b/wkt-types/tests/pbstruct_test.rs index 6f59808..add9ef6 100644 --- a/wkt-types/tests/pbstruct_test.rs +++ b/wkt-types/tests/pbstruct_test.rs @@ -30,7 +30,7 @@ fn test_flatten_struct() { let mut fields: HashMap = HashMap::new(); fields.insert("test".to_string(), create_struct()); let strct = Struct { - fields: fields.clone() + fields: fields.clone(), }; let string_strct = serde_json::to_string_pretty(&strct).expect("Serialized struct"); println!("{string_strct}"); @@ -46,7 +46,7 @@ fn test_flatten_struct() { fn test_flatten_list() { let values: Vec = vec![Value::null(), Value::from(20.0), Value::from(true)]; let list: ListValue = ListValue { - values: values.clone() + values: values.clone(), }; let string_list = serde_json::to_string_pretty(&list).expect("Serialized list"); println!("{string_list}"); @@ -56,5 +56,4 @@ fn test_flatten_list() { println!("{string}"); assert_eq!(string_list, string); - }