From 0f2e26d88a845755c7121ffa902321e71dc786f6 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Tue, 29 Aug 2023 14:47:37 +0200 Subject: [PATCH 1/3] Remove AsMap and AsList type These types are more related to serde and sval than they are to log. Because of that is falls out of scope for the log crate. --- src/kv/source.rs | 325 ----------------------------------------------- 1 file changed, 325 deletions(-) diff --git a/src/kv/source.rs b/src/kv/source.rs index c8e7a05a3..9c56f8b76 100644 --- a/src/kv/source.rs +++ b/src/kv/source.rs @@ -402,319 +402,6 @@ mod std_support { } } -/// The result of calling `Source::as_map`. -pub struct AsMap(S); - -/// Visit this source as a map. -pub fn as_map(source: S) -> AsMap -where - S: Source, -{ - AsMap(source) -} - -impl Source for AsMap -where - S: Source, -{ - fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> { - self.0.visit(visitor) - } - - fn get(&self, key: Key) -> Option> { - self.0.get(key) - } - - fn count(&self) -> usize { - self.0.count() - } -} - -impl fmt::Debug for AsMap -where - S: Source, -{ - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let mut f = f.debug_map(); - self.0.visit(&mut f).map_err(|_| fmt::Error)?; - f.finish() - } -} - -/// The result of calling `Source::as_list` -pub struct AsList(S); - -/// Visit this source as a list. -pub fn as_list(source: S) -> AsList -where - S: Source, -{ - AsList(source) -} - -impl Source for AsList -where - S: Source, -{ - fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> { - self.0.visit(visitor) - } - - fn get(&self, key: Key) -> Option> { - self.0.get(key) - } - - fn count(&self) -> usize { - self.0.count() - } -} - -impl fmt::Debug for AsList -where - S: Source, -{ - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let mut f = f.debug_list(); - self.0.visit(&mut f).map_err(|_| fmt::Error)?; - f.finish() - } -} - -#[cfg(feature = "kv_unstable_sval")] -mod sval_support { - use super::*; - - impl sval::Value for AsMap - where - S: Source, - { - fn stream<'sval, SV: sval::Stream<'sval> + ?Sized>( - &'sval self, - stream: &mut SV, - ) -> sval::Result { - struct StreamVisitor<'a, V: ?Sized>(&'a mut V); - - impl<'a, 'kvs, V: sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> { - fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> { - self.0 - .map_key_begin() - .map_err(|_| Error::msg("failed to stream map key"))?; - sval_ref::stream_ref(self.0, key) - .map_err(|_| Error::msg("failed to stream map key"))?; - self.0 - .map_key_end() - .map_err(|_| Error::msg("failed to stream map key"))?; - - self.0 - .map_value_begin() - .map_err(|_| Error::msg("failed to stream map value"))?; - sval_ref::stream_ref(self.0, value) - .map_err(|_| Error::msg("failed to stream map value"))?; - self.0 - .map_value_end() - .map_err(|_| Error::msg("failed to stream map value"))?; - - Ok(()) - } - } - - stream - .map_begin(Some(self.count())) - .map_err(|_| sval::Error::new())?; - - self.visit(&mut StreamVisitor(stream)) - .map_err(|_| sval::Error::new())?; - - stream.map_end().map_err(|_| sval::Error::new()) - } - } - - impl sval::Value for AsList - where - S: Source, - { - fn stream<'sval, SV: sval::Stream<'sval> + ?Sized>( - &'sval self, - stream: &mut SV, - ) -> sval::Result { - struct StreamVisitor<'a, V: ?Sized>(&'a mut V); - - impl<'a, 'kvs, V: sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> { - fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> { - self.0 - .seq_value_begin() - .map_err(|_| Error::msg("failed to stream seq value"))?; - sval_ref::stream_ref(self.0, (key, value)) - .map_err(|_| Error::msg("failed to stream seq value"))?; - self.0 - .seq_value_end() - .map_err(|_| Error::msg("failed to stream seq value"))?; - - Ok(()) - } - } - - stream - .seq_begin(Some(self.count())) - .map_err(|_| sval::Error::new())?; - - self.visit(&mut StreamVisitor(stream)) - .map_err(|_| sval::Error::new())?; - - stream.seq_end().map_err(|_| sval::Error::new()) - } - } - - #[cfg(test)] - mod tests { - use super::*; - use sval_derive::Value; - - #[test] - fn derive_stream() { - #[derive(Value)] - pub struct MyRecordAsMap<'a> { - msg: &'a str, - kvs: AsMap<&'a dyn Source>, - } - - #[derive(Value)] - pub struct MyRecordAsList<'a> { - msg: &'a str, - kvs: AsList<&'a dyn Source>, - } - } - } -} - -#[cfg(feature = "kv_unstable_serde")] -pub mod as_map { - //! `serde` adapters for serializing a `Source` as a map. - - use super::*; - use serde::{Serialize, Serializer}; - - /// Serialize a `Source` as a map. - pub fn serialize(source: &T, serializer: S) -> Result - where - T: Source, - S: Serializer, - { - as_map(source).serialize(serializer) - } -} - -#[cfg(feature = "kv_unstable_serde")] -pub mod as_list { - //! `serde` adapters for serializing a `Source` as a list. - - use super::*; - use serde::{Serialize, Serializer}; - - /// Serialize a `Source` as a list. - pub fn serialize(source: &T, serializer: S) -> Result - where - T: Source, - S: Serializer, - { - as_list(source).serialize(serializer) - } -} - -#[cfg(feature = "kv_unstable_serde")] -mod serde_support { - use super::*; - use serde::ser::{Error as SerError, Serialize, SerializeMap, SerializeSeq, Serializer}; - - impl Serialize for AsMap - where - T: Source, - { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - struct SerializerVisitor<'a, S>(&'a mut S); - - impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S> - where - S: SerializeMap, - { - fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> { - self.0 - .serialize_entry(&key, &value) - .map_err(|_| Error::msg("failed to serialize map entry"))?; - Ok(()) - } - } - - let mut map = serializer.serialize_map(Some(self.count()))?; - - self.visit(&mut SerializerVisitor(&mut map)) - .map_err(|_| S::Error::custom("failed to visit key-values"))?; - - map.end() - } - } - - impl Serialize for AsList - where - T: Source, - { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - struct SerializerVisitor<'a, S>(&'a mut S); - - impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S> - where - S: SerializeSeq, - { - fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> { - self.0 - .serialize_element(&(key, value)) - .map_err(|_| Error::msg("failed to serialize seq entry"))?; - Ok(()) - } - } - - let mut seq = serializer.serialize_seq(Some(self.count()))?; - - self.visit(&mut SerializerVisitor(&mut seq)) - .map_err(|_| S::Error::custom("failed to visit seq"))?; - - seq.end() - } - } - - #[cfg(test)] - mod tests { - use super::*; - use crate::kv::source; - use serde::Serialize; - - #[test] - fn derive_serialize() { - #[derive(Serialize)] - pub struct MyRecordAsMap<'a> { - msg: &'a str, - #[serde(flatten)] - #[serde(with = "source::as_map")] - kvs: &'a dyn Source, - } - - #[derive(Serialize)] - pub struct MyRecordAsList<'a> { - msg: &'a str, - #[serde(flatten)] - #[serde(with = "source::as_list")] - kvs: &'a dyn Source, - } - } - } -} - #[cfg(test)] mod tests { use crate::kv::value::tests::Token; @@ -766,16 +453,4 @@ mod tests { let source = None::<(&str, i32)>; assert!(Source::get(&source, Key::from_str("a")).is_none()); } - - #[test] - fn as_map() { - let _ = crate::kv::source::as_map(("a", 1)); - let _ = crate::kv::source::as_map(&("a", 1) as &dyn Source); - } - - #[test] - fn as_list() { - let _ = crate::kv::source::as_list(("a", 1)); - let _ = crate::kv::source::as_list(&("a", 1) as &dyn Source); - } } From 0c80af3ab711ec630d50be1956042d284b88e0d5 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Tue, 29 Aug 2023 14:49:59 +0200 Subject: [PATCH 2/3] Remove ToValue for dyn fmt::{Debug,Display} and std::error::Error To support downcasting the Value::capture_* methods should be used. However with these ToValue implementations it's very easy to call to_value and call it a day, too easy as you lose the downcasting ability when you do. To prevent this gotcha remove these implenentations. --- src/kv/value.rs | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/src/kv/value.rs b/src/kv/value.rs index 352f965ea..5d401df6b 100644 --- a/src/kv/value.rs +++ b/src/kv/value.rs @@ -121,15 +121,6 @@ macro_rules! as_sval { /// assert_eq!(Some(42), value.to_i64()); /// ``` /// -/// ``` -/// # use std::fmt::Debug; -/// use log::kv::ToValue; -/// -/// let value = (&42i32 as &dyn Debug).to_value(); -/// -/// assert_eq!(None, value.to_i64()); -/// ``` -/// /// ## Using the standard `From` trait /// /// Standard types that implement `ToValue` also implement `From`. @@ -376,25 +367,6 @@ impl<'v> fmt::Display for Value<'v> { } } -impl ToValue for dyn fmt::Debug { - fn to_value(&self) -> Value { - Value::from_dyn_debug(self) - } -} - -impl ToValue for dyn fmt::Display { - fn to_value(&self) -> Value { - Value::from_dyn_display(self) - } -} - -#[cfg(feature = "kv_unstable_std")] -impl ToValue for dyn std::error::Error + 'static { - fn to_value(&self) -> Value { - Value::from_dyn_error(self) - } -} - #[cfg(feature = "kv_unstable_serde")] impl<'v> serde::Serialize for Value<'v> { fn serialize(&self, s: S) -> Result From e6b6bde8e8adea31553762958a08f54e0c6fdcde Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Tue, 29 Aug 2023 14:52:08 +0200 Subject: [PATCH 3/3] Remove Key::to_borrowed_str Key::as_str can be used instead. --- src/kv/key.rs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/kv/key.rs b/src/kv/key.rs index 971c866b9..858ec493a 100644 --- a/src/kv/key.rs +++ b/src/kv/key.rs @@ -48,12 +48,6 @@ impl<'k> Key<'k> { pub fn as_str(&self) -> &str { self.key } - - /// Try get a string borrowed for the `'k` lifetime from this key. - pub fn to_borrowed_str(&self) -> Option<&'k str> { - // NOTE: This API leaves room for keys to be owned - Some(self.key) - } } impl<'k> fmt::Display for Key<'k> {