xtask: Major overhaul

Fix error printouts for examples,
Rename BuildAll -> Build
Rename Build -> ExampleBuild

Command interface changed, targets by defalt only v6 and v7

1 files changed, 132 insertions, 23 deletions

diff --git a/xtask/src/command.rs b/xtask/src/command.rs
index ed73b2d..07ecc84 100644
--- a/xtask/src/command.rs
+++ b/xtask/src/command.rs
@@ -1,11 +1,7 @@
-use crate::{debug, RunResult, Sizearguments, TestRunError};
+use crate::{debug, info, RunResult, Sizearguments, TestRunError};
 use core::fmt;
 use os_pipe::pipe;
-use std::{
-    fs::File,
-    io::Read,
-    process::{Command, Stdio},
-};
+use std::{fs::File, io::Read, process::Command};
 
 #[allow(dead_code)]
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -16,6 +12,8 @@ pub enum BuildMode {
 
 #[derive(Debug)]
 pub enum CargoCommand<'a> {
+    // For future embedded-ci
+    #[allow(dead_code)]
     Run {
         cargoarg: &'a Option<&'a str>,
         example: &'a str,
@@ -23,25 +21,47 @@ pub enum CargoCommand<'a> {
         features: Option<&'a str>,
         mode: BuildMode,
     },
-    Build {
+    Qemu {
         cargoarg: &'a Option<&'a str>,
         example: &'a str,
         target: &'a str,
         features: Option<&'a str>,
         mode: BuildMode,
     },
-    BuildAll {
+    ExampleBuild {
         cargoarg: &'a Option<&'a str>,
+        example: &'a str,
         target: &'a str,
         features: Option<&'a str>,
         mode: BuildMode,
     },
-    CheckAll {
+    ExampleCheck {
         cargoarg: &'a Option<&'a str>,
+        example: &'a str,
         target: &'a str,
         features: Option<&'a str>,
+        mode: BuildMode,
     },
-    Size {
+    Build {
+        cargoarg: &'a Option<&'a str>,
+        package: Vec<String>,
+        target: &'a str,
+        features: Option<&'a str>,
+        mode: BuildMode,
+    },
+    Check {
+        cargoarg: &'a Option<&'a str>,
+        package: Vec<String>,
+        target: &'a str,
+        features: Option<&'a str>,
+    },
+    Clippy {
+        cargoarg: &'a Option<&'a str>,
+        package: Vec<String>,
+        target: &'a str,
+        features: Option<&'a str>,
+    },
+    ExampleSize {
         cargoarg: &'a Option<&'a str>,
         example: &'a str,
         target: &'a str,
@@ -54,16 +74,21 @@ pub enum CargoCommand<'a> {
 impl<'a> CargoCommand<'a> {
     fn name(&self) -> &str {
         match self {
-            CargoCommand::Run { .. } => "run",
-            CargoCommand::Build { .. } => "build",
-            CargoCommand::Size { .. } => "size",
-            CargoCommand::BuildAll { .. } => "build",
-            CargoCommand::CheckAll { .. } => "check",
+            CargoCommand::Run { .. } | CargoCommand::Qemu { .. } => "run",
+            CargoCommand::ExampleCheck { .. } | CargoCommand::Check { .. } => "check",
+            CargoCommand::ExampleBuild { .. } | CargoCommand::Build { .. } => "build",
+            CargoCommand::ExampleSize { .. } => "size",
+            CargoCommand::Clippy { .. } => "clippy",
+            // TODO
+            // CargoCommand::Fmt { .. } => "fmt",
+            // CargoCommand::Test { .. } => "test",
+            // CargoCommand::Doc { .. } => "doc",
         }
     }
 
     pub fn args(&self) -> Vec<&str> {
         match self {
+            // For future embedded-ci, for now the same as Qemu
             CargoCommand::Run {
                 cargoarg,
                 example,
@@ -85,8 +110,9 @@ impl<'a> CargoCommand<'a> {
                 }
                 args
             }
-            CargoCommand::BuildAll {
+            CargoCommand::Qemu {
                 cargoarg,
+                example,
                 target,
                 features,
                 mode,
@@ -95,7 +121,7 @@ impl<'a> CargoCommand<'a> {
                 if let Some(cargoarg) = cargoarg {
                     args.extend_from_slice(&[cargoarg]);
                 }
-                args.extend_from_slice(&[self.name(), "--examples", "--target", target]);
+                args.extend_from_slice(&[self.name(), "--example", example, "--target", target]);
 
                 if let Some(feature) = features {
                     args.extend_from_slice(&["--features", feature]);
@@ -105,23 +131,100 @@ impl<'a> CargoCommand<'a> {
                 }
                 args
             }
-            CargoCommand::CheckAll {
+            CargoCommand::Build {
                 cargoarg,
+                package,
                 target,
                 features,
+                mode,
             } => {
                 let mut args = vec!["+nightly"];
                 if let Some(cargoarg) = cargoarg {
                     args.extend_from_slice(&[cargoarg]);
                 }
-                args.extend_from_slice(&[self.name(), "--examples", "--target", target]);
+
+                args.extend_from_slice(&[self.name(), "--target", target]);
+                if !package.is_empty() {
+                    for package in package {
+                        args.extend_from_slice(&["--package", package]);
+                    }
+                }
 
                 if let Some(feature) = features {
                     args.extend_from_slice(&["--features", feature]);
                 }
+                if let Some(flag) = mode.to_flag() {
+                    args.push(flag);
+                }
                 args
             }
-            CargoCommand::Build {
+            CargoCommand::Check {
+                cargoarg,
+                package,
+                target,
+                features,
+            } => {
+                let mut args = vec!["+nightly"];
+                if let Some(cargoarg) = cargoarg {
+                    args.extend_from_slice(&[cargoarg]);
+                }
+                args.extend_from_slice(&[self.name(), "--target", target]);
+                if !package.is_empty() {
+                    for package in package {
+                        args.extend_from_slice(&["--package", package]);
+                    }
+                }
+
+                if let Some(feature) = features {
+                    args.extend_from_slice(&["--features", feature]);
+                }
+                args
+            }
+            CargoCommand::Clippy {
+                cargoarg,
+                package,
+                target,
+                features,
+            } => {
+                let mut args = vec!["+nightly"];
+                if let Some(cargoarg) = cargoarg {
+                    args.extend_from_slice(&[cargoarg]);
+                }
+
+                args.extend_from_slice(&[self.name(), "--target", target]);
+                if !package.is_empty() {
+                    for package in package {
+                        args.extend_from_slice(&["--package", package]);
+                    }
+                }
+
+                if let Some(feature) = features {
+                    args.extend_from_slice(&["--features", feature]);
+                }
+                args
+            }
+            CargoCommand::ExampleBuild {
+                cargoarg,
+                example,
+                target,
+                features,
+                mode,
+            } => {
+                let mut args = vec!["+nightly"];
+                if let Some(cargoarg) = cargoarg {
+                    args.extend_from_slice(&[cargoarg]);
+                }
+                args.extend_from_slice(&[self.name(), "--example", example, "--target", target]);
+
+                if let Some(feature) = features {
+                    args.extend_from_slice(&["--features", feature]);
+                }
+                if let Some(flag) = mode.to_flag() {
+                    args.push(flag);
+                }
+                args
+            }
+            CargoCommand::ExampleCheck {
                 cargoarg,
                 example,
                 target,
@@ -142,7 +245,7 @@ impl<'a> CargoCommand<'a> {
                 }
                 args
             }
-            CargoCommand::Size {
+            CargoCommand::ExampleSize {
                 cargoarg,
                 example,
                 target,
@@ -202,13 +305,13 @@ impl fmt::Display for BuildMode {
 
 pub fn run_command(command: &CargoCommand) -> anyhow::Result<RunResult> {
     let (mut reader, writer) = pipe()?;
+    let (mut error_reader, error_writer) = pipe()?;
     debug!("👟 {} {}", command.command(), command.args().join(" "));
 
     let mut handle = Command::new(command.command())
         .args(command.args())
         .stdout(writer)
-        // Throw away stderr, TODO
-        .stderr(Stdio::null())
+        .stderr(error_writer)
         .spawn()?;
 
     // retrieve output and clean up
@@ -216,6 +319,12 @@ pub fn run_command(command: &CargoCommand) -> anyhow::Result<RunResult> {
     reader.read_to_string(&mut output)?;
     let exit_status = handle.wait()?;
 
+    let mut error_output = String::new();
+    error_reader.read_to_string(&mut error_output)?;
+    if !error_output.is_empty() {
+        info!("{error_output}");
+    }
+
     Ok(RunResult {
         exit_status,
         output,