Use strong-xml instead of serde and generalize frontend

Cargo.toml

@@ -26,13 +26,12 @@ exclude = [
 [features]
 default = ["textwrap"]
 
-[dependencies.serde]
-version = "1"
-features = ["derive"]
+[dependencies.strong-xml]
+version = "0.6"
 
-[dependencies.serde-xml-rs]
-version = "0.5"
-default-features = false
+[dependencies.strum]
+version = "0.24"
+features = ["derive"]
 
 [dependencies.colored]
 version = "2"

src/main.rs

@@ -24,24 +24,20 @@ mod valgrind;
 use colored::Colorize as _;
 use std::env;
 use std::process;
+use valgrind::xml;
 
 /// Nicely format the errors in the valgrind output, if there are any.
-fn display_error(errors: &[valgrind::xml::Error]) {
+fn display_error(errors: &[xml::Error]) {
     // format the output in a helpful manner
     for error in errors {
-        eprintln!(
-            "{:>12} leaked {} in {} block{}",
-            "Error".red().bold(),
-            bytesize::to_string(error.resources.bytes as _, true),
-            error.resources.blocks,
-            if error.resources.blocks == 1 { "" } else { "s" }
-        );
-        let mut info = Some("Info".cyan().bold());
-        error
-            .stack_trace
-            .frames
-            .iter()
-            .for_each(|frame| eprintln!("{:>12} at {}", info.take().unwrap_or_default(), frame));
+        eprintln!("{:>12} {}", "Error".red().bold(), error.description);
+        display_backtrace(&error.stack_trace);
+        for extra in &error.extra {
+            match extra {
+                xml::ErrorExtra::AuxWhat(s) => eprintln!("{:>12} {}", "Info".cyan().bold(), s),
+                xml::ErrorExtra::StackTrace(stack) => display_backtrace(stack),
+            }
+        }
     }
 
     let total: usize = errors.iter().map(|error| error.resources.bytes).sum();
@@ -52,6 +48,14 @@ fn display_error(errors: &[valgrind::xml::Error]) {
     );
 }
 
+/// Display a backtrace provided by valgrind.
+fn display_backtrace(backtrace: &xml::Stack) {
+    backtrace
+        .frames
+        .iter()
+        .for_each(|frame| eprintln!("{:>12} at {}", "", frame));
+}
+
 fn main() {
     panic::replace_hook();
 
@@ -90,10 +94,7 @@ fn main() {
         let command = env::args_os().skip(1);
 
         let exit_code = match valgrind::execute(command) {
-            Ok(valgrind::xml::Output {
-                errors: Some(errors),
-                ..
-            }) => {
+            Ok(xml::Output { errors, .. }) if !errors.is_empty() => {
                 display_error(&errors);
                 127
             }

src/valgrind/mod.rs

@@ -2,11 +2,11 @@
 
 pub mod xml;
 
-use serde::Deserialize;
 use std::net::{SocketAddr, TcpListener};
 use std::process::Command;
 use std::{env, fmt, io::Read};
 use std::{ffi::OsStr, process::Stdio};
+use strong_xml::{XmlError, XmlRead};
 
 /// Error type for valgrind-execution-related failures.
 #[derive(Debug)]
@@ -27,7 +27,7 @@ pub enum Error {
     ///
     /// This variant contains the inner deserialization error and the output of
     /// valgrind.
-    MalformedOutput(serde_xml_rs::Error, Vec<u8>),
+    MalformedOutput(XmlError, Vec<u8>),
 }
 
 impl std::error::Error for Error {}
@@ -85,26 +85,12 @@ where
         listener
             .read_to_end(&mut output)
             .map_err(|_| Error::SocketConnection)?;
-        let xml: xml::Output = xml::Output::deserialize(
-            &mut serde_xml_rs::Deserializer::new_from_reader(&*output)
-                .non_contiguous_seq_elements(true),
-        )
-        .map(|output_: xml::Output| {
-            let mut output = output_;
-            if let Some(err) = output.errors {
-                let new_err: Vec<xml::Error> = err
-                    .into_iter()
-                    .filter(|e| e.resources.bytes > 0 || e.resources.blocks > 0)
-                    .collect();
-                if new_err.is_empty() {
-                    output.errors = None;
-                } else {
-                    output.errors = Some(new_err);
-                }
-            }
-            output
-        })
-        .map_err(|e| Error::MalformedOutput(e, output))?;
+        let output_str = match std::str::from_utf8(&output) {
+            Ok(s) => s,
+            Err(e) => return Err(Error::MalformedOutput(XmlError::Utf8(e), output))?,
+        };
+        let xml: xml::Output =
+            xml::Output::from_str(output_str).map_err(|e| Error::MalformedOutput(e, output))?;
         Ok(xml)
     });