xtask: Streamline error handling

har7an · har7an · commit 0f0b41a3f455 · 2022-12-14T14:11:33.000+01:00
diff --git a/xtask/src/build.rs b/xtask/src/build.rs
@@ -54,7 +54,7 @@ pub fn build(sh: &Shell, flags: flags::Build) -> anyhow::Result<()> {
 
             if flags.release {
                 // Perform wasm-opt on plugin
-                wasm_opt_plugins(sh, plugin_name).with_context(err_context)?;
+                wasm_opt_plugin(sh, plugin_name).with_context(err_context)?;
             } else {
                 // Must copy plugins to zellij-utils, too!
                 let source = PathBuf::from(
@@ -82,7 +82,7 @@ pub fn build(sh: &Shell, flags: flags::Build) -> anyhow::Result<()> {
 /// for filenames ending with `.wasm`. For this to work the plugins must be built beforehand.
 // TODO: Should this panic if there is no plugin found? What should we do when only some plugins
 // have been built before?
-pub fn wasm_opt_plugins(sh: &Shell, plugin_name: &str) -> anyhow::Result<()> {
+pub fn wasm_opt_plugin(sh: &Shell, plugin_name: &str) -> anyhow::Result<()> {
     let err_context = || format!("failed to run 'wasm-opt' on plugin '{plugin_name}'");
 
     let wasm_opt = wasm_opt(sh).with_context(err_context)?;
@@ -102,11 +102,7 @@ pub fn wasm_opt_plugins(sh: &Shell, plugin_name: &str) -> anyhow::Result<()> {
     .join("release")
     .join(plugin_name)
     .with_extension("wasm");
-    //target_dir.push("wasm32-wasi");
-    //target_dir.push("release");
-    //plugin_name
-    //target_dir.push(plugin);
-    //
+
     if !plugin.is_file() {
         return Err(anyhow::anyhow!("No plugin found at '{}'", plugin.display()))
             .with_context(err_context);
@@ -115,7 +111,7 @@ pub fn wasm_opt_plugins(sh: &Shell, plugin_name: &str) -> anyhow::Result<()> {
         Some(name) => name,
         None => {
             return Err(anyhow::anyhow!(
-                "Couldn't read filename containing invalid unicode"
+                "couldn't read filename containing invalid unicode"
             ))
             .with_context(err_context)
         },
@@ -145,7 +141,7 @@ fn wasm_opt(_sh: &Shell) -> anyhow::Result<PathBuf> {
         Err(e) => {
             println!("!! 'wasm-opt' wasn't found but is needed for this build step.");
             println!("!! Please install it from here: https://github.com/WebAssembly/binaryen");
-            Err(e).context("Couldn't find 'wasm-opt' executable")
+            Err(e).context("couldn't find 'wasm-opt' executable")
         },
     }
 }
@@ -154,21 +150,19 @@ fn wasm_opt(_sh: &Shell) -> anyhow::Result<PathBuf> {
 //      mkdir -p ${root_dir}/assets/man
 //      mandown ${root_dir}/docs/MANPAGE.md 1 > ${root_dir}/assets/man/zellij.1
 pub fn manpage(sh: &Shell) -> anyhow::Result<()> {
-    let mandown = mandown(sh)?;
+    let err_context = "failed to generate manpage";
+
+    let mandown = mandown(sh).context(err_context)?;
 
     let project_root = crate::project_root();
     let asset_dir = &project_root.join("assets").join("man");
-    sh.create_dir(&asset_dir)
-        .context("Couldn't create asset dir for plugins")?;
+    sh.create_dir(&asset_dir).context(err_context)?;
     let _pd = sh.push_dir(asset_dir);
 
-    let text = cmd!(sh, "{mandown} {project_root}/docs/MANPAGE.md 1")
+    cmd!(sh, "{mandown} {project_root}/docs/MANPAGE.md 1")
         .read()
-        .context("Generating man pages failed")?;
-    sh.write_file("zellij.1", text)
-        .context("Writing man pages failed")?;
-
-    Ok(())
+        .and_then(|text| sh.write_file("zellij.1", text))
+        .context(err_context)
 }
 
 /// Get the path to a `mandown` executable.
diff --git a/xtask/src/format.rs b/xtask/src/format.rs
@@ -4,7 +4,7 @@ use anyhow::Context;
 use std::path::{Path, PathBuf};
 use xshell::{cmd, Shell};
 
-pub fn format(sh: &Shell, _flags: flags::Format) -> anyhow::Result<()> {
+pub fn format(sh: &Shell, flags: flags::Format) -> anyhow::Result<()> {
     let cargo = check_rustfmt()
         .and_then(|_| crate::cargo())
         .context("failed to run task 'format'")?;
@@ -17,8 +17,11 @@ pub fn format(sh: &Shell, _flags: flags::Format) -> anyhow::Result<()> {
         crate::status(&msg);
         println!("{}", msg);
 
-        cmd!(sh, "{cargo} fmt")
-            .run()
+        let mut cmd = cmd!(sh, "{cargo} fmt");
+        if flags.check {
+            cmd = cmd.arg("--check");
+        }
+        cmd.run()
             .with_context(|| format!("Failed to format '{subcrate}'"))?;
     }
     Ok(())
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
@@ -37,6 +37,7 @@
 // - publish-zellij: `cargo publish [tile, client, server, utils, tile-utils, zellij]`
 
 mod build;
+mod ci;
 mod clippy;
 mod dist;
 mod flags;
@@ -86,6 +87,7 @@ fn main() -> anyhow::Result<()> {
         flags::XtaskCmd::Make(flags) => pipelines::make(shell, flags),
         flags::XtaskCmd::Install(flags) => pipelines::install(shell, flags),
         flags::XtaskCmd::Run(flags) => pipelines::run(shell, flags),
+        flags::XtaskCmd::Ci(flags) => ci::main(shell, flags),
     }?;
 
     let elapsed = now.elapsed().as_secs();
@@ -116,7 +118,8 @@ pub fn status(msg: &str) {
 }
 
 fn deprecation_notice() -> anyhow::Result<()> {
-    Err(anyhow::anyhow!(" !!! cargo make has been deprecated by zellij !!!
+    Err(anyhow::anyhow!(
+        " !!! cargo make has been deprecated by zellij !!!
 
 Our build system is now `cargo xtask`. Don't worry, you won't have to install
 anything!
@@ -137,5 +140,6 @@ anything!
 | make install /path/to/binary    | xtask install /path/to/binary |
 | make publish                    | N/A                           |
 | make manpage                    | N/A                           |
-"))
+"
+    ))
 }
diff --git a/xtask/src/pipelines.rs b/xtask/src/pipelines.rs
@@ -15,18 +15,28 @@ use xshell::{cmd, Shell};
 /// - test
 /// - clippy
 pub fn make(sh: &Shell, flags: flags::Make) -> anyhow::Result<()> {
-    format::format(sh, flags::Format {})?;
-    build::build(
-        sh,
-        flags::Build {
-            release: flags.release,
-            no_plugins: false,
-            plugins_only: false,
-        },
-    )?;
-    test::test(sh, flags::Test { args: vec![] })?;
-    clippy::clippy(sh, flags::Clippy {})?;
-    Ok(())
+    let err_context = || format!("failed to run pipeline 'make' with args {flags:?}");
+
+    if flags.clean {
+        crate::cargo()
+            .and_then(|cargo| cmd!(sh, "{cargo} clean").run().map_err(anyhow::Error::new))
+            .with_context(err_context)?;
+    }
+
+    format::format(sh, flags::Format { check: false })
+        .and_then(|_| {
+            build::build(
+                sh,
+                flags::Build {
+                    release: flags.release,
+                    no_plugins: false,
+                    plugins_only: false,
+                },
+            )
+        })
+        .and_then(|_| test::test(sh, flags::Test { args: vec![] }))
+        .and_then(|_| clippy::clippy(sh, flags::Clippy {}))
+        .with_context(err_context)
 }
 
 /// Generate a runnable executable.
@@ -39,6 +49,8 @@ pub fn make(sh: &Shell, flags: flags::Make) -> anyhow::Result<()> {
 /// - [`manpage`](build::manpage)
 /// - Copy the executable to [target file](flags::Install::destination)
 pub fn install(sh: &Shell, flags: flags::Install) -> anyhow::Result<()> {
+    let err_context = || format!("failed to run pipeline 'install' with args {flags:?}");
+
     // Build and optimize plugins
     build::build(
         sh,
@@ -47,84 +59,85 @@ pub fn install(sh: &Shell, flags: flags::Install) -> anyhow::Result<()> {
             no_plugins: false,
             plugins_only: true,
         },
-    )?;
-
-    // Build the main executable
-    build::build(
-        sh,
-        flags::Build {
-            release: true,
-            no_plugins: true,
-            plugins_only: false,
-        },
-    )?;
-
-    // Generate man page
-    build::manpage(sh)?;
+    )
+    .and_then(|_| {
+        // Build the main executable
+        build::build(
+            sh,
+            flags::Build {
+                release: true,
+                no_plugins: true,
+                plugins_only: false,
+            },
+        )
+    })
+    .and_then(|_| {
+        // Generate man page
+        build::manpage(sh)
+    })
+    .with_context(err_context)?;
 
     // Copy binary to destination
     let destination = if flags.destination.is_absolute() {
-        flags.destination
+        flags.destination.clone()
     } else {
         std::env::current_dir()
             .context("Can't determine current working directory")?
-            .join(flags.destination)
+            .join(&flags.destination)
     };
     sh.change_dir(crate::project_root());
     sh.copy_file("target/release/zellij", &destination)
-        .with_context(|| format!("Failed to copy executable to '{}", destination.display()))?;
-    Ok(())
+        .with_context(err_context)
 }
 
 /// Run zellij debug build.
 pub fn run(sh: &Shell, flags: flags::Run) -> anyhow::Result<()> {
+    let err_context = || format!("failed to run pipeline 'run' with args {flags:?}");
+
     build::build(
         sh,
         flags::Build {
             release: false,
             no_plugins: false,
             plugins_only: true,
         },
-    )?;
-
-    crate::cargo()
-        .and_then(|cargo| {
-            cmd!(sh, "{cargo} run")
-                .args(flags.args)
-                .run()
-                .context("command failure")
-        })
-        .context("failed to run debug build")
+    )
+    .and_then(|_| crate::cargo())
+    .and_then(|cargo| {
+        cmd!(sh, "{cargo} run")
+            .args(&flags.args)
+            .run()
+            .map_err(anyhow::Error::new)
+    })
+    .with_context(err_context)
 }
 
 /// Bundle all distributable content to `target/dist`.
 ///
 /// This includes the optimized zellij executable from the [`install`] pipeline, the man page, the
 /// `.desktop` file and the application logo.
 pub fn dist(sh: &Shell, _flags: flags::Dist) -> anyhow::Result<()> {
+    let err_context = || format!("failed to run pipeline 'dist'");
+
     sh.change_dir(crate::project_root());
     if sh.path_exists("target/dist") {
-        sh.remove_path("target/dist")
-            .context("Failed to clean up dist directory")?;
+        sh.remove_path("target/dist").with_context(err_context)?;
     }
     sh.create_dir("target/dist")
-        .context("Failed to create dist directory")?;
-
-    install(
-        sh,
-        flags::Install {
-            destination: crate::project_root().join("./target/dist/zellij"),
-        },
-    )
-    .context("Failed to build zellij for distributing")?;
+        .map_err(anyhow::Error::new)
+        .and_then(|_| {
+            install(
+                sh,
+                flags::Install {
+                    destination: crate::project_root().join("./target/dist/zellij"),
+                },
+            )
+        })
+        .with_context(err_context)?;
 
     sh.create_dir("target/dist/man")
-        .context("Failed to create directory for man pages in dist folder")?;
-    sh.copy_file("assets/man/zellij.1", "target/dist/man/zellij.1")
-        .context("Failed to copy generated manpage to dist folder")?;
-    sh.copy_file("assets/zellij.desktop", "target/dist/zellij.desktop")
-        .context("Failed to copy zellij desktop file to dist folder")?;
-    sh.copy_file("assets/logo.png", "target/dist/logo.png")
-        .context("Failed to copy zellij logo to dist folder")?;
-    Ok(())
+        .and_then(|_| sh.copy_file("assets/man/zellij.1", "target/dist/man/zellij.1"))
+        .and_then(|_| sh.copy_file("assets/zellij.desktop", "target/dist/zellij.desktop"))
+        .and_then(|_| sh.copy_file("assets/logo.png", "target/dist/logo.png"))
+        .with_context(err_context)
 }
