sync the dumper code from sq

src/dump.rs

@@ -283,7 +283,7 @@ impl PacketDumper {
         Ok(())
     }
 
-    fn dump_packet(&self, output: &mut dyn io::Write, i: &str,
+    fn dump_packet(&self, mut output: &mut dyn io::Write, i: &str,
                   header: Option<&Header>, p: &Packet, map: Option<&Map>,
                   additional_fields: Option<&Vec<String>>)
                   -> Result<()> {
@@ -387,7 +387,7 @@ impl PacketDumper {
                     },
 
                     // crypto::mpi:Publickey is non-exhaustive
-                    _ => writeln!(output, "{}  Unknown variant", ii)?,
+                    u => writeln!(output, "{}Unknown variant: {:?}", ii, u)?,
                 }
             }
 
@@ -445,7 +445,7 @@ impl PacketDumper {
                                     },
 
                                     // crypto::mpi::SecretKeyMaterial is non-exhaustive.
-                                    _ => writeln!(output, "{}  Unknown variant", ii)?,
+                                    u => writeln!(output, "{}Unknown variant: {:?}", ii, u)?,
                                 }
                                 Ok(())
                             })?;
@@ -552,7 +552,7 @@ impl PacketDumper {
                         },
 
                         // crypto::mpi::Signature is non-exhaustive.
-                        _ => writeln!(output, "{}  Unknown variant", ii)?,
+                        u => writeln!(output, "{}Unknown variant: {:?}", ii, u)?,
                     }
                 }
             },
@@ -567,7 +567,11 @@ impl PacketDumper {
             },
 
             Trust(ref p) => {
-                writeln!(output, "{}  Value: {}", i, hex::encode(p.value()))?;
+                writeln!(output, "{}  Value:", i)?;
+                let mut hd = hex::Dumper::new(
+                    &mut output,
+                    self.indentation_for_hexdump(&format!("{}  ", i), 16));
+                hd.write_ascii(p.value())?;
             },
 
             UserID(ref u) => {
@@ -663,7 +667,7 @@ impl PacketDumper {
                         },
 
                         // crypto::mpi::Ciphertext is non-exhaustive.
-                        _ => writeln!(output, "{}  Unknown variant", ii)?,
+                        u => writeln!(output, "{}Unknown variant: {:?}", ii, u)?,
                     }
                 }
             },
@@ -702,7 +706,7 @@ impl PacketDumper {
                     },
 
                     // SKESK is non-exhaustive.
-                    _ => writeln!(output, "{}  Unknown variant", i)?,
+                    u => writeln!(output, "{}    Unknown variant: {:?}", i, u)?,
                 }
             },
 
@@ -726,7 +730,7 @@ impl PacketDumper {
             },
 
             // openpgp::Packet is non-exhaustive.
-            _ => writeln!(output, "{}  Unknown variant", i)?,
+            u => writeln!(output, "{}    Unknown variant: {:?}", i, u)?,
         }
 
         if let Some(fields) = additional_fields {
@@ -776,7 +780,7 @@ impl PacketDumper {
             Unknown { body, .. } => {
                 writeln!(output, "{}    {:?}{}:", i, s.tag(),
                          if s.critical() { " (critical)" } else { "" })?;
-                hexdump_unknown(output, body)?;
+                hexdump_unknown(output, body.as_slice())?;
             },
             SignatureCreationTime(t) =>
                 write!(output, "{}    Signature creation time: {}", i,
@@ -818,8 +822,24 @@ impl PacketDumper {
             },
             Issuer(ref is) =>
                 write!(output, "{}    Issuer: {}", i, is)?,
-            NotationData(ref n) =>
-                write!(output, "{}    Notation: {:?}", i, n)?,
+            NotationData(n) => if n.flags().human_readable() {
+                write!(output, "{}    Notation: {}", i, n)?;
+                if s.critical() {
+                    write!(output, " (critical)")?;
+                }
+                writeln!(output)?;
+            } else {
+                write!(output, "{}    Notation: {}", i, n.name())?;
+                let flags = format!("{:?}", n.flags());
+                if ! flags.is_empty() {
+                    write!(output, "{}", flags)?;
+                }
+                if s.critical() {
+                    write!(output, " (critical)")?;
+                }
+                writeln!(output)?;
+                hexdump_unknown(output, n.value())?;
+            },
             PreferredHashAlgorithms(ref h) =>
                 write!(output, "{}    Hash preferences: {}", i,
                        h.iter().map(|h| format!("{:?}", h))
@@ -864,13 +884,25 @@ impl PacketDumper {
                        .collect::<Vec<String>>().join(", "))?,
             IntendedRecipient(ref fp) =>
                 write!(output, "{}    Intended Recipient: {}", i, fp)?,
+            AttestedCertifications(digests) => {
+                write!(output, "{}    Attested Certifications:", i)?;
+                if digests.is_empty() {
+                    writeln!(output, " None")?;
+                } else {
+                    writeln!(output)?;
+                    for d in digests {
+                        writeln!(output, "{}      {}", i, hex::encode(d))?;
+                    }
+                }
+            },
 
             // SubpacketValue is non-exhaustive.
-            _ => writeln!(output, "{}  Unknown variant", i)?,
+            u => writeln!(output, "{}    Unknown variant: {:?}", i, u)?,
         }
 
         match s.value() {
             Unknown { .. } => (),
+            NotationData { .. } => (),
             EmbeddedSignature(ref sig) => {
                 if s.critical() {
                     write!(output, " (critical)")?;
@@ -928,7 +960,7 @@ impl PacketDumper {
             },
 
             // S2K is non-exhaustive
-            _ => writeln!(output, "{}  Unknown variant", i)?,
+            u => writeln!(output, "{}    Unknown variant: {:?}", i, u)?,
         }
         Ok(())
     }
@@ -936,7 +968,7 @@ impl PacketDumper {
     fn dump_mpis(&self, output: &mut dyn io::Write, i: &str,
                  chunks: &[&[u8]], keys: &[&str]) -> Result<()> {
         assert_eq!(chunks.len(), keys.len());
-        if chunks.len() == 0 {
+        if chunks.is_empty() {
             return Ok(());
         }