port to stable versions of value-bag and sval

Cargo.toml

@@ -54,12 +54,13 @@ kv_unstable_serde = ["kv_unstable_std", "value-bag/serde", "serde"]
 
 [dependencies]
 serde = { version = "1.0", optional = true, default-features = false }
-sval = { version = "=1.0.0-alpha.5", optional = true, default-features = false }
-value-bag = { version = "=1.0.0-alpha.9", optional = true, default-features = false }
+sval = { version = "2.0", optional = true, default-features = false }
+value-bag = { version = "1.0", optional = true, default-features = false }
 
 [dev-dependencies]
 rustversion = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_test = "1.0"
-sval = { version = "=1.0.0-alpha.5", features = ["derive"] }
-value-bag = { version = "=1.0.0-alpha.9", features = ["test"] }
+sval = { version = "2.0" }
+sval_derive = { version = "2.0" }
+value-bag = { version = "1.0", features = ["test"] }

src/kv/key.rs

@@ -48,6 +48,12 @@ 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> {
@@ -99,10 +105,10 @@ mod sval_support {
 
     extern crate sval;
 
-    use self::sval::value::{self, Value};
+    use self::sval::Value;
 
     impl<'a> Value for Key<'a> {
-        fn stream(&self, stream: &mut value::Stream) -> value::Result {
+        fn stream<'sval, S: sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut S) -> sval::Result {
             self.key.stream(stream)
         }
     }

src/kv/source.rs

@@ -460,74 +460,83 @@ where
 mod sval_support {
     use super::*;
 
-    use self::sval::value;
-
-    impl<S> value::Value for AsMap<S>
+    impl<S> self::sval::Value for AsMap<S>
     where
         S: Source,
     {
-        fn stream(&self, stream: &mut value::Stream) -> value::Result {
-            struct StreamVisitor<'a, 'b>(&'a mut value::Stream<'b>);
+        fn stream<'sval, SV: self::sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut SV) -> self::sval::Result {
+            struct StreamVisitor<'a, V: ?Sized>(&'a mut V);
 
-            impl<'a, 'b, 'kvs> Visitor<'kvs> for StreamVisitor<'a, 'b> {
+            impl<'a, 'kvs, V: self::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(key)
-                        .map_err(|_| Error::msg("failed to stream map key"))?;
-                    self.0
-                        .map_value(value)
-                        .map_err(|_| Error::msg("failed to stream map value"))?;
+                    self.0.map_key_begin().map_err(|_| Error::msg("failed to stream map key"))?;
+                    if let Some(key) = key.to_borrowed_str() {
+                        self.0.value(key).map_err(|_| Error::msg("failed to stream map key"))?;
+                    } else {
+                        self.0.value_computed(key.as_str()).map_err(|_| Error::msg("failed to stream map key"))?;
+                    }
+                    self.0.map_key_end().map_err(|_| Error::msg("failed to stream map key"))?;
+
+                    // TODO: Need to borrow this here
+                    self.0.map_value_begin().map_err(|_| Error::msg("failed to stream map value"))?;
+                    self.0.value_computed(&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(|_| self::sval::Error::msg("failed to begin map"))?;
+                .map_err(|_| self::sval::Error::new())?;
 
             self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| self::sval::Error::msg("failed to visit key-values"))?;
+                .map_err(|_| self::sval::Error::new())?;
 
             stream
                 .map_end()
-                .map_err(|_| self::sval::Error::msg("failed to end map"))
+                .map_err(|_| self::sval::Error::new())
         }
     }
 
-    impl<S> value::Value for AsList<S>
+    impl<S> self::sval::Value for AsList<S>
     where
         S: Source,
     {
-        fn stream(&self, stream: &mut value::Stream) -> value::Result {
-            struct StreamVisitor<'a, 'b>(&'a mut value::Stream<'b>);
+        fn stream<'sval, SV: self::sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut SV) -> self::sval::Result {
+            struct StreamVisitor<'a, V: ?Sized>(&'a mut V);
 
-            impl<'a, 'b, 'kvs> Visitor<'kvs> for StreamVisitor<'a, 'b> {
+            impl<'a, 'kvs, V: self::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_elem((key, value))
-                        .map_err(|_| Error::msg("failed to stream seq entry"))?;
+                    // TODO: Need to borrow this here
+                    self.0.seq_value_begin().map_err(|_| Error::msg("failed to stream seq value"))?;
+                    self.0.value_computed(&(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(|_| self::sval::Error::msg("failed to begin seq"))?;
+                .map_err(|_| self::sval::Error::new())?;
 
             self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| self::sval::Error::msg("failed to visit key-values"))?;
+                .map_err(|_| self::sval::Error::new())?;
 
             stream
                 .seq_end()
-                .map_err(|_| self::sval::Error::msg("failed to end seq"))
+                .map_err(|_| self::sval::Error::new())
         }
     }
 
     #[cfg(test)]
     mod tests {
+        extern crate sval_derive;
+
         use super::*;
 
-        use self::sval::Value;
+        use self::sval_derive::Value;
 
         use crate::kv::source;
 

src/kv/value.rs

@@ -71,7 +71,7 @@ macro_rules! as_serde {
     };
 }
 
-/// Get a value from a type implementing `sval::value::Value`.
+/// Get a value from a type implementing `self::sval::value::Value`.
 #[cfg(feature = "kv_unstable_sval")]
 #[macro_export]
 macro_rules! as_sval {
@@ -197,21 +197,21 @@ impl<'v> Value<'v> {
     /// Get a value from a type implementing `serde::Serialize`.
     pub fn capture_serde<T>(value: &'v T) -> Self
     where
-        T: self::serde::Serialize + 'static,
+        T: serde::Serialize + 'static,
     {
         Value {
             inner: ValueBag::capture_serde1(value),
         }
     }
 
-    /// Get a value from a type implementing `sval::value::Value`.
+    /// Get a value from a type implementing `self::sval::value::Value`.
     #[cfg(feature = "kv_unstable_sval")]
     pub fn capture_sval<T>(value: &'v T) -> Self
     where
-        T: self::sval::value::Value + 'static,
+        T: self::sval::Value + 'static,
     {
         Value {
-            inner: ValueBag::capture_sval1(value),
+            inner: ValueBag::capture_sval2(value),
         }
     }
 
@@ -239,7 +239,7 @@ impl<'v> Value<'v> {
     #[cfg(feature = "kv_unstable_serde")]
     pub fn from_serde<T>(value: &'v T) -> Self
     where
-        T: self::serde::Serialize,
+        T: serde::Serialize,
     {
         Value {
             inner: ValueBag::from_serde1(value),
@@ -250,10 +250,10 @@ impl<'v> Value<'v> {
     #[cfg(feature = "kv_unstable_sval")]
     pub fn from_sval<T>(value: &'v T) -> Self
     where
-        T: self::sval::value::Value,
+        T: self::sval::Value,
     {
         Value {
-            inner: ValueBag::from_sval1(value),
+            inner: ValueBag::from_sval2(value),
         }
     }
 
@@ -279,14 +279,6 @@ impl<'v> Value<'v> {
         }
     }
 
-    /// Get a value from a type implementing `sval::value::Value`.
-    #[cfg(feature = "kv_unstable_sval")]
-    pub fn from_dyn_sval(value: &'v dyn self::sval::value::Value) -> Self {
-        Value {
-            inner: ValueBag::from_dyn_sval1(value),
-        }
-    }
-
     /// Get a value from an internal primitive.
     fn from_value_bag<T>(value: T) -> Self
     where
@@ -412,26 +404,19 @@ impl ToValue for dyn std::error::Error + 'static {
 }
 
 #[cfg(feature = "kv_unstable_serde")]
-impl<'v> self::serde::Serialize for Value<'v> {
+impl<'v> serde::Serialize for Value<'v> {
     fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
     where
-        S: self::serde::Serializer,
+        S: serde::Serializer,
     {
         self.inner.serialize(s)
     }
 }
 
 #[cfg(feature = "kv_unstable_sval")]
-impl<'v> self::sval::value::Value for Value<'v> {
-    fn stream(&self, stream: &mut self::sval::value::Stream) -> self::sval::value::Result {
-        self::sval::value::Value::stream(&self.inner, stream)
-    }
-}
-
-#[cfg(feature = "kv_unstable_sval")]
-impl ToValue for dyn self::sval::value::Value {
-    fn to_value(&self) -> Value {
-        Value::from_dyn_sval(self)
+impl<'v> self::sval::Value for Value<'v> {
+    fn stream<'sval, S: self::sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut S) -> self::sval::Result {
+        self::sval::Value::stream(&self.inner, stream)
     }
 }
 
@@ -465,6 +450,12 @@ impl ToValue for std::num::NonZeroI128 {
     }
 }
 
+impl<'v> From<ValueBag<'v>> for Value<'v> {
+    fn from(value: ValueBag<'v>) -> Self {
+        Value::from_value_bag(value)
+    }
+}
+
 impl<'v> From<&'v str> for Value<'v> {
     fn from(value: &'v str) -> Self {
         Value::from_value_bag(value)
@@ -650,7 +641,7 @@ pub trait Visit<'v> {
     /// This is the only required method on `Visit` and acts as a fallback for any
     /// more specific methods that aren't overridden.
     /// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,
-    /// or serialized using its `sval::Value` or `serde::Serialize` implementation.
+    /// or serialized using its `self::sval::Value` or `serde::Serialize` implementation.
     fn visit_any(&mut self, value: Value) -> Result<(), Error>;
 
     /// Visit an unsigned integer.
@@ -777,11 +768,11 @@ where
 pub(crate) mod tests {
     use super::*;
 
-    pub(crate) use super::value_bag::test::Token;
+    pub(crate) use super::value_bag::test::TestToken as Token;
 
     impl<'v> Value<'v> {
         pub(crate) fn to_token(&self) -> Token {
-            self.inner.to_token()
+            self.inner.to_test_token()
         }
     }