Handwrite a better Debug for Value

src/value/debug.rs

@@ -0,0 +1,46 @@
+use crate::value::{Number, Value};
+use std::fmt::{self, Debug, Display};
+
+impl Debug for Value {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Value::Null => formatter.write_str("Null"),
+            Value::Bool(boolean) => write!(formatter, "Bool({})", boolean),
+            Value::Number(number) => write!(formatter, "Number({})", number),
+            Value::String(string) => write!(formatter, "String({:?})", string),
+            Value::Sequence(sequence) => {
+                formatter.write_str("Sequence ")?;
+                formatter.debug_list().entries(sequence).finish()
+            }
+            Value::Mapping(mapping) => {
+                formatter.write_str("Mapping ")?;
+                let mut debug = formatter.debug_map();
+                for (k, v) in mapping {
+                    let tmp;
+                    debug.entry(
+                        match k {
+                            Value::Bool(boolean) => boolean,
+                            Value::Number(number) => {
+                                tmp = DisplayNumber(number);
+                                &tmp
+                            }
+                            Value::String(string) => string,
+                            _ => k,
+                        },
+                        v,
+                    );
+                }
+                debug.finish()
+            }
+            Value::Tagged(tagged) => Debug::fmt(tagged, formatter),
+        }
+    }
+}
+
+struct DisplayNumber<'a>(&'a Number);
+
+impl<'a> Debug for DisplayNumber<'a> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(self.0, formatter)
+    }
+}

src/value/mod.rs

@@ -1,6 +1,7 @@
 //! The Value enum, a loosely typed way of representing any valid YAML value.
 
 mod de;
+mod debug;
 mod from;
 mod index;
 mod partial_eq;
@@ -20,7 +21,7 @@ pub use self::tagged::{Tag, TaggedValue};
 pub use crate::number::Number;
 
 /// Represents any valid YAML value.
-#[derive(Clone, PartialEq, PartialOrd, Debug)]
+#[derive(Clone, PartialEq, PartialOrd)]
 pub enum Value {
     /// Represents a YAML null value.
     Null,

tests/test_value.rs

@@ -93,3 +93,41 @@ fn test_merge() {
         assert_eq!(value[4], value[i]);
     }
 }
+
+#[test]
+fn test_debug() {
+    let yaml = indoc! {"
+        Null: ~
+        Bool: true
+        Number: 1
+        String: ...
+        Sequence:
+          - true
+        EmptySequence: []
+        EmptyMapping: {}
+        Tagged: !tag true
+    "};
+
+    let value: Value = serde_yaml::from_str(yaml).unwrap();
+    let debug = format!("{:#?}", value);
+
+    let expected = indoc! {r#"
+        Mapping {
+            "Null": Null,
+            "Bool": Bool(true),
+            "Number": Number(1),
+            "String": String("..."),
+            "Sequence": Sequence [
+                Bool(true),
+            ],
+            "EmptySequence": Sequence [],
+            "EmptyMapping": Mapping {},
+            "Tagged": TaggedValue {
+                tag: !tag,
+                value: Bool(true),
+            },
+        }"#
+    };
+
+    assert_eq!(debug, expected);
+}