Support converting Value into Debug (#34)

.travis.yml

@@ -11,6 +11,7 @@ matrix:
     - rust: beta
       script:
       - ./ci/travis.sh
+      - cargo test -p sval_fmt_tests
     - rust: stable
       script:
-      - ./ci/travis.sh
+      - ./ci/travis.sh

Cargo.toml

@@ -1,7 +1,8 @@
 [workspace]
 members = [
     "derive",
-    "tests",
+    "tests/serde",
+    "tests/fmt",
 
     "json",
     "json/benches",
@@ -25,7 +26,7 @@ keywords = ["serialization", "no_std"]
 categories = ["encoding", "no-std"]
 
 [package.metadata.docs.rs]
-features = ["derive", "serde", "test"]
+features = ["derive", "serde", "fmt", "test"]
 
 [badges]
 travis-ci = { repository = "sval-rs/sval" }
@@ -44,6 +45,9 @@ derive = ["sval_derive"]
 # that can be inspected in tests
 test = ["std"]
 
+# Support integration with `std::fmt`
+fmt = []
+
 # Support integration with `serde`
 serde = ["std", "serde_lib/std"]
 

README.md

@@ -122,3 +122,22 @@ struct MyData {
     props: serde_json::Map<String, serde_json::Value>,
 }
 ```
+
+## To integrate with `std::fmt`
+
+`sval` can provide a compatible `Debug` implementation for any `sval::Value`. Add the `fmt` feature to `sval` to enable it:
+
+```toml
+[dependencies.sval]
+features = ["fmt"]
+```
+
+Use the `to_debug` function to turn any `sval::Value` into a `std::fmt::Debug`:
+
+```rust
+fn with_value(value: impl Value) {
+    dbg!(sval::fmt::to_debug(&value));
+
+    ..
+}
+```

ci/travis.sh

@@ -9,6 +9,9 @@ cargo test
 printf "\n\n---- sval with std ----\n\n"
 cargo test --features std
 
+printf "\n\n---- sval with fmt ----\n\n"
+cargo test --features fmt
+
 printf "\n\n---- sval with serde ----\n\n"
 cargo test --features serde
 
@@ -25,5 +28,9 @@ cargo test --features std
 popd
 
 # other builds
+# Benches are checked in the `nightly` build
+# Format consistency is checked in the `beta` build
 printf "\n\n---- integration tests ----\n\n"
-cargo test --all --exclude sval_json_benches
+cargo test --all \
+  --exclude sval_json_benches \
+  --exclude sval_fmt_tests

json/src/lib.rs

@@ -15,14 +15,17 @@ extern crate std;
 extern crate core as std;
 
 mod fmt;
-pub use self::fmt::{Formatter, to_fmt};
+pub use self::fmt::{
+    to_fmt,
+    Formatter,
+};
 
 #[cfg(feature = "std")]
 mod std_support;
 
 #[cfg(feature = "std")]
 pub use self::std_support::{
-    Writer,
     to_string,
     to_writer,
+    Writer,
 };

json/src/std_support.rs

@@ -1,4 +1,7 @@
-use sval::stream::{self, Stream};
+use sval::stream::{
+    self,
+    Stream,
+};
 
 use crate::std::string::String;
 use crate::{

src/collect/value.rs

@@ -18,10 +18,7 @@ pub(crate) struct Value<'a> {
 impl<'a> Value<'a> {
     #[inline]
     pub(crate) fn new(value: &'a impl value::Value, stack: &'a mut DebugStack) -> Self {
-        Value {
-            stack,
-            value,
-        }
+        Value { stack, value }
     }
 
     /**

src/error.rs

@@ -61,6 +61,12 @@ impl fmt::Display for ErrorInner {
     }
 }
 
+impl From<Error> for fmt::Error {
+    fn from(_: Error) -> fmt::Error {
+        fmt::Error
+    }
+}
+
 #[cfg(not(feature = "std"))]
 mod no_std_support {
     use super::*;

src/fmt/mod.rs

@@ -0,0 +1,49 @@
+/*!
+Integration between `sval` and `std::fmt`.
+
+# From `sval` to `std::fmt`
+
+A type that implements [`sval::Value`](../value/trait.Value.html) can be converted into
+a type that implements [`std::fmt::Debug`]:
+
+```
+# struct MyValue;
+# impl sval::value::Value for MyValue {
+#     fn stream(&self, stream: &mut sval::value::Stream) -> Result<(), sval::value::Error> {
+#         unimplemented!()
+#     }
+# }
+# let my_value = MyValue;
+let my_debug = sval::fmt::to_debug(my_value);
+```
+*/
+
+use crate::{
+    std::fmt::{
+        self,
+        Debug,
+        Formatter,
+    },
+    Value,
+};
+
+mod to_debug;
+
+/**
+Convert a [`Value`] into a [`Debug`].
+
+The formatted value is not guaranteed to be exactly the same as
+a `Debug` implementation that might exist on the type.
+
+This method doesn't need to allocate or perform any buffering.
+*/
+pub fn to_debug(value: impl Value) -> impl Debug {
+    self::to_debug::ToDebug(value)
+}
+
+/**
+Format a [`Value`] using the given [`Formatter`].
+*/
+pub fn debug(value: impl Value, f: &mut Formatter) -> fmt::Result {
+    to_debug(value).fmt(f)
+}