Merge pull request #171 from sval-rs/fix/flatten-enum-end

Fix a bug ending enums in flattened values

flatten/src/flattener.rs

@@ -10,6 +10,7 @@ pub(crate) struct Flattener<'sval, S> {
     state: FlattenerState<'sval>,
 }
 
+#[derive(Debug)]
 struct FlattenerState<'sval> {
     index_alloc: IndexAllocator,
     key_buf: LabelBuf<'sval>,
@@ -379,7 +380,7 @@ impl<'sval, S: Flatten<'sval>> Stream<'sval> for Flattener<'sval, S> {
         self.value_at_root(
             |_, _| Ok(()),
             |buf| buf.enum_end(tag, label, index),
-            |stream| stream.enum_begin(tag, label, index),
+            |stream| stream.enum_end(tag, label, index),
         )
     }
 

flatten/src/index.rs

@@ -1,5 +1,6 @@
 use sval::Index;
 
+#[derive(Debug)]
 pub(crate) struct IndexAllocator {
     initial_offset: isize,
     current_offset: isize,

flatten/src/label.rs

@@ -13,6 +13,7 @@ impl<'a, 'sval, S: LabelStream<'sval> + ?Sized> LabelStream<'sval> for &'a mut S
     }
 }
 
+#[derive(Debug)]
 pub(crate) enum LabelBuf<'sval> {
     Empty,
     Text(TextBuf<'sval>),

flatten/src/record_tuple.rs

@@ -402,6 +402,73 @@ mod tests {
         );
     }
 
+    #[test]
+    fn flatten_nested_enum() {
+        #[derive(Value)]
+        struct Inner {
+            b: ReallyInner,
+        }
+
+        #[derive(Value)]
+        struct ReallyInner {
+            b1: ReallyReallyInner,
+        }
+
+        #[derive(Value)]
+        #[allow(dead_code)]
+        enum ReallyReallyInner {
+            #[sval(label = "b")]
+            A(i32),
+            B {
+                b: i32,
+                c: i32,
+            },
+            C(i32, i32),
+        }
+
+        sval_test::assert_tokens(
+            &Outer {
+                a: 1,
+                i: Inner {
+                    b: ReallyInner {
+                        b1: ReallyReallyInner::B { b: 42, c: 43 },
+                    },
+                },
+                d: 4,
+            },
+            {
+                use sval_test::Token::*;
+
+                &[
+                    RecordTupleBegin(None, Some(Label::new("Outer")), None, None),
+                    RecordTupleValueBegin(None, Label::new("a"), Index::new(0)),
+                    I32(1),
+                    RecordTupleValueEnd(None, Label::new("a"), Index::new(0)),
+                    RecordTupleValueBegin(None, Label::new("b"), Index::new(1)),
+                    RecordTupleBegin(None, Some(Label::new("ReallyInner")), None, Some(1)),
+                    RecordTupleValueBegin(None, Label::new("b1"), Index::new(0)),
+                    EnumBegin(None, Some(Label::new("ReallyReallyInner")), None),
+                    RecordTupleBegin(None, Some(Label::new("B")), Some(Index::new(1)), Some(2)),
+                    RecordTupleValueBegin(None, Label::new("b"), Index::new(0)),
+                    I32(42),
+                    RecordTupleValueEnd(None, Label::new("b"), Index::new(0)),
+                    RecordTupleValueBegin(None, Label::new("c"), Index::new(1)),
+                    I32(43),
+                    RecordTupleValueEnd(None, Label::new("c"), Index::new(1)),
+                    RecordTupleEnd(None, Some(Label::new("B")), Some(Index::new(1))),
+                    EnumEnd(None, Some(Label::new("ReallyReallyInner")), None),
+                    RecordTupleValueEnd(None, Label::new("b1"), Index::new(0)),
+                    RecordTupleEnd(None, Some(Label::new("ReallyInner")), None),
+                    RecordTupleValueEnd(None, Label::new("b"), Index::new(1)),
+                    RecordTupleValueBegin(None, Label::new("d"), Index::new(2)),
+                    I32(4),
+                    RecordTupleValueEnd(None, Label::new("d"), Index::new(2)),
+                    RecordTupleEnd(None, Some(Label::new("Outer")), None),
+                ]
+            },
+        );
+    }
+
     #[test]
     fn flatten_nested() {
         #[derive(Value)]

src/data/binary.rs

@@ -1,4 +1,4 @@
-use crate::{tags, Result, Stream, Value, std::fmt};
+use crate::{std::fmt, tags, Result, Stream, Value};
 
 /**
 An adapter that streams a slice of 8bit unsigned integers as binary.

src/data/map.rs

@@ -1,4 +1,4 @@
-use crate::{Result, Stream, Value, std::fmt};
+use crate::{std::fmt, Result, Stream, Value};
 
 /**
 An adapter that streams a slice of key-value pairs as a map.