change target info to json and display them neatly

xtask/Cargo.toml

@@ -18,3 +18,4 @@ serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.8"
 serde_json = "1.0"
 once_cell = "1.12"
+rayon = { version = "1", optional = true }

xtask/src/target_info.rs

@@ -6,6 +6,9 @@ use std::{
 
 use clap::Args;
 use cross::CommandExt;
+use serde::Deserialize;
+
+use crate::util::ImageTarget;
 
 // Store raw text data in the binary so we don't need a data directory
 // when extracting all targets, or running our target info script.
@@ -63,14 +66,13 @@ fn image_info(
     tag: &str,
     verbose: bool,
     has_test: bool,
-) -> cross::Result<()> {
+) -> cross::Result<TargetInfoOutput> {
     if !tag.starts_with("local") {
         pull_image(engine, image, verbose)?;
     }
 
     let mut command = Command::new(engine);
     command.arg("run");
-    command.arg("-it");
     command.arg("--rm");
     command.args(&["-e", &format!("TARGET={}", target.triplet)]);
     if has_test {
@@ -79,11 +81,111 @@ fn image_info(
     command.arg(image);
     command.args(&["bash", "-c", TARGET_INFO_SCRIPT]);
 
-    if !verbose {
-        // capture stderr to avoid polluting table
-        command.stderr(Stdio::null());
+    serde_json::from_str(&command.run_and_get_stdout(verbose)?).map_err(Into::into)
+}
+
+#[derive(Debug, Deserialize)]
+struct TargetInfoOutput {
+    pub libc: Version,
+    pub cc: Version,
+    pub cxx: Truthy,
+    pub qemu: Version,
+    pub has_test: Truthy,
+    pub libc_is_newlib: Truthy,
+    pub libc_os: Truthy,
+    pub bionic: Truthy,
+}
+
+impl TargetInfoOutput {
+    pub fn flags(&self) -> String {
+        let mut string = String::new();
+
+        if self.libc_is_newlib.is_yes() {
+            string.push_str("[4]")
+        }
+        if self.libc_os.is_yes() {
+            string.push_str("[3]")
+        }
+        if self.bionic.is_yes() {
+            string.push_str("[1]")
+        }
+
+        if !string.is_empty() {
+            string.insert(0, ' ');
+        }
+        string
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(from = "&str")]
+pub enum Version {
+    NotApplicable,
+    Version(String),
+}
+
+impl std::fmt::Display for Version {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Version::NotApplicable => f.pad("N/A"),
+            Version::Version(v) => f.pad(v),
+        }
+    }
+}
+
+impl From<&str> for Version {
+    fn from(version: &str) -> Self {
+        match version {
+            "" => Version::NotApplicable,
+            v => Version::Version(v.to_string()),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, PartialEq, Eq)]
+#[serde(from = "&str")]
+pub enum Truthy {
+    Yes,
+    No,
+}
+
+impl Truthy {
+    /// Returns `true` if the truthy is [`Yes`].
+    ///
+    /// [`Yes`]: Truthy::Yes
+    #[must_use]
+    pub fn is_yes(&self) -> bool {
+        matches!(self, Self::Yes)
+    }
+}
+
+impl std::fmt::Display for Truthy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Truthy::Yes => f.pad("✓"),
+            Truthy::No => f.pad(""),
+        }
     }
-    command.run(verbose, false).map_err(Into::into)
+}
+
+impl From<&str> for Truthy {
+    fn from(version: &str) -> Self {
+        match version {
+            "" => Truthy::No,
+            _ => Truthy::Yes,
+        }
+    }
+}
+
+fn calc_width<'a>(
+    iter: impl Iterator<Item = &'a cross::Result<(ImageTarget, TargetInfoOutput)>>,
+    f: impl Fn(&'a ImageTarget, &'a TargetInfoOutput) -> usize,
+) -> usize {
+    iter.filter_map(|r| r.as_ref().ok())
+        .map(|(target, info)| f(target, info))
+        .max()
+        .unwrap_or_default()
+        + 2
 }
 
 pub fn target_info(
@@ -111,14 +213,53 @@ pub fn target_info(
             .collect();
     }
 
-    for target in targets {
+    let process = |target: &ImageTarget| {
         let image = target.image_name(&format_repo(&registry, &repository), &tag);
         let has_test = test_map
-            .get(&target)
+            .get(target)
             .cloned()
             .ok_or_else(|| eyre::eyre!("invalid target name {}", target))?;
-        image_info(engine, &target, &image, &tag, verbose, has_test)?;
+        eprintln!("doing {target}");
+        match image_info(engine, target, &image, &tag, verbose, has_test) {
+            Ok(r) => Ok((target.clone(), r)),
+            Err(e) => Err(eyre::eyre!("target {target} failed with: {e}")),
+        }
+    };
+
+    let results: Vec<_>;
+    #[cfg(feature = "rayon")]
+    {
+        use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+        results = targets.par_iter().map(process).collect();
+    }
+
+    #[cfg(not(feature = "rayon"))]
+    {
+        results = targets.into_iter().map(|ref t| process(t)).collect();
     }
 
+    let t_w = calc_width(results.iter(), |t, info| {
+        t.alt().len() + info.flags().len() + 2
+    });
+    let libc_w = calc_width(results.iter(), |_, info| info.libc.to_string().len() + 2);
+    let cc_w = calc_width(results.iter(), |_, info| info.cc.to_string().len() + 2);
+    let qemu_w = calc_width(results.iter(), |_, info| info.qemu.to_string().len() + 2);
+    results.into_iter().filter_map(Result::ok).for_each(|(
+        target,
+        ref info @ TargetInfoOutput {
+            ref libc,
+            ref cc,
+            ref cxx,
+            ref qemu,
+            ref has_test,
+            ..
+        },
+    )| {
+        println!(
+            "|{target: >t_w$} | {libc: <libc_w$}| {cc: <cc_w$}|{cxx: ^5}| {qemu: <qemu_w$}|{has_test: ^5}|",
+            target = format!("`{}`{}", target.alt(), info.flags())
+        )
+    });
+
     Ok(())
 }