Disable comments for NewType structs and Unit Variants

See cfrantz#6

Signed-off-by: Chris Frantz <[email protected]>

Author: cfrantz

src/json.rs

@@ -210,29 +210,15 @@ impl JsonEmitter {
             Document::Null => self.emit_null(w),
             Document::Compact(d) => self.emit_compact(w, d),
             Document::Fragment(ds) => {
-                match &ds[..] {
-                    // Currently, an enum unit-variant is the only place in the serializer where a
-                    // Fragment is constructed placing the comment after the node.  For this case,
-                    // we want to emit the variant name followed by the comment on the same line.
-                    [n, Document::Comment(c, f)] => {
-                        self.emit_node(w, n)?;
-                        if !self.compact && !self.comment.is_empty() {
-                            write!(w, " ")?;
-                            self.emit_comment(w, c, f)?;
-                        }
-                    }
-                    _ => {
-                        let mut prior_val = false;
-                        for d in ds {
-                            if prior_val {
-                                self.writeln(w, "")?;
-                                self.emit_indent(w)?;
-                            }
-                            self.emit_node(w, d)?;
-                            prior_val = d.has_value();
-                        }
+                let mut prior_val = false;
+                for d in ds {
+                    if prior_val {
+                        self.writeln(w, "")?;
+                        self.emit_indent(w)?;
                     }
-                };
+                    self.emit_node(w, d)?;
+                    prior_val = d.has_value();
+                }
                 Ok(())
             }
         }

src/ser.rs

@@ -204,11 +204,15 @@ impl<'s, 'a> ser::Serializer for &'s mut AnnotatedSerializer<'a> {
         variant: &'static str,
     ) -> Result<Self::Ok, Self::Error> {
         let node = self.serialize_str(variant)?;
-        if let Some(c) = self.comment(Some(variant), &MemberId::Variant) {
-            Ok(Document::Fragment(vec![node, c]))
-        } else {
-            Ok(node)
-        }
+        // TODO(serde-annotate#6): currently, placing a comment on a unit variant results in
+        // ugly (json) or bad (yaml) documents.  For now, omit comments on
+        // unit variants until we refactor comment emitting.
+        //if let Some(c) = self.comment(Some(variant), &MemberId::Variant) {
+        //    Ok(Document::Fragment(vec![c, node]))
+        //} else {
+        //    Ok(node)
+        //}
+        Ok(node)
     }
 
     fn serialize_newtype_struct<T>(
@@ -221,11 +225,15 @@ impl<'s, 'a> ser::Serializer for &'s mut AnnotatedSerializer<'a> {
     {
         let field = MemberId::Index(0);
         let node = self.serialize(value, self.annotate(None, &field))?;
-        if let Some(c) = self.comment(None, &field) {
-            Ok(Document::Fragment(vec![c, node]))
-        } else {
-            Ok(node)
-        }
+        // TODO(serde-annotate#6): currently, placing a comment on a newtype structs results in
+        // ugly (json) or bad (yaml) documents.  For now, omit comments on
+        // unit variants until we refactor comment emitting.
+        //if let Some(c) = self.comment(None, &field) {
+        //    Ok(Document::Fragment(vec![c, node]))
+        //} else {
+        //    Ok(node)
+        //}
+        Ok(node)
     }
 
     fn serialize_newtype_variant<T>(

src/yaml.rs

@@ -97,26 +97,15 @@ impl YamlEmitter {
             Document::Null => self.emit_null(w),
             Document::Compact(d) => self.emit_compact(w, d),
             Document::Fragment(ds) => {
-                match &ds[..] {
-                    [n, Document::Comment(c, f)] => {
-                        self.emit_node(w, n)?;
-                        if !self.compact {
-                            write!(w, " ")?;
-                            self.emit_comment(w, c, f)?;
-                        }
-                    }
-                    _ => {
-                        let mut prior_val = false;
-                        for d in ds {
-                            if prior_val {
-                                self.writeln(w, "")?;
-                                self.emit_indent(w)?;
-                            }
-                            self.emit_node(w, d)?;
-                            prior_val = d.has_value();
-                        }
+                let mut prior_val = false;
+                for d in ds {
+                    if prior_val {
+                        self.writeln(w, "")?;
+                        self.emit_indent(w)?;
                     }
-                };
+                    self.emit_node(w, d)?;
+                    prior_val = d.has_value();
+                }
                 Ok(())
             }
         }

tests/test_format.rs

@@ -263,12 +263,14 @@ enum NesAddress {
     Prg(#[annotate(format=hex)] u8, #[annotate(format=hex)] u16),
     #[annotate(format=compact, comment="NES CHR bank:address")]
     Chr(#[annotate(format=hex)] u8, #[annotate(format=hex)] u16),
+    // TODO(serde-annotate#6): Currently, we do not emit comments for unit variants.
     #[annotate(comment = "Bad Address")]
     Invalid,
 }
 
+// TODO(serde-annotate#6): Currently, we do not emit comments for newtype structs.
 #[derive(Serialize, Deserialize, Annotate, Debug, PartialEq)]
-struct CpuAddress(#[annotate(format=hex)] u16);
+struct CpuAddress(#[annotate(format=hex, comment="CPU Address")] u16);
 
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 struct Addresses {
@@ -339,7 +341,7 @@ fn test_nes_addresses() -> Result<()> {
             0xFFFC,
             0xFFFE
           ],
-          inv: "Invalid" // Bad Address
+          inv: "Invalid"
         }"#
     );
 
@@ -362,7 +364,7 @@ fn test_nes_addresses() -> Result<()> {
             - 0xFFFA
             - 0xFFFC
             - 0xFFFE
-          inv: Invalid # Bad Address"#
+          inv: Invalid"#
     );
 
     Ok(())