Merge pull request #90 from mgattozzi/compilation-abort

feat(refactor/early abort): Exit early on failure

Author: ashleygwilliams

src/bindgen.rs

@@ -1,24 +1,31 @@
+use PBAR;
 use console::style;
 use emoji;
+use failure::Error;
 use std::process::Command;
-use PBAR;
 
-pub fn cargo_install_wasm_bindgen() {
+pub fn cargo_install_wasm_bindgen() -> Result<(), Error> {
     let step = format!(
         "{} {}Installing WASM-bindgen...",
         style("[6/7]").bold().dim(),
         emoji::DOWN_ARROW
     );
     let pb = PBAR.message(&step);
-    let _output = Command::new("cargo")
+    let output = Command::new("cargo")
         .arg("install")
         .arg("wasm-bindgen")
-        .output()
-        .unwrap_or_else(|e| panic!("{} failed to execute process: {}", emoji::ERROR, e));
+        .output()?;
     pb.finish();
+    if !output.status.success() {
+        let s = String::from_utf8_lossy(&output.stderr);
+        PBAR.error("Installing wasm-bindgen failed");
+        bail!(format!("Details:\n{}", s));
+    } else {
+        Ok(())
+    }
 }
 
-pub fn wasm_bindgen_build(path: &str, name: &str) {
+pub fn wasm_bindgen_build(path: &str, name: &str) -> Result<(), Error> {
     let step = format!(
         "{} {}Running WASM-bindgen...",
         style("[7/7]").bold().dim(),
@@ -27,12 +34,18 @@ pub fn wasm_bindgen_build(path: &str, name: &str) {
     let pb = PBAR.message(&step);
     let binary_name = name.replace("-", "_");
     let wasm_path = format!("target/wasm32-unknown-unknown/release/{}.wasm", binary_name);
-    let _output = Command::new("wasm-bindgen")
+    let output = Command::new("wasm-bindgen")
         .current_dir(path)
         .arg(&wasm_path)
         .arg("--out-dir")
         .arg("./pkg")
-        .output()
-        .unwrap_or_else(|e| panic!("{} failed to execute process: {}", emoji::ERROR, e));
+        .output()?;
     pb.finish();
+    if !output.status.success() {
+        let s = String::from_utf8_lossy(&output.stderr);
+        PBAR.error("wasm-bindgen failed to execute properly");
+        bail!(format!("Details:\n{}", s));
+    } else {
+        Ok(())
+    }
 }

src/build.rs

@@ -1,9 +1,10 @@
+use PBAR;
 use console::style;
 use emoji;
+use failure::Error;
 use std::process::Command;
-use PBAR;
 
-pub fn rustup_add_wasm_target() {
+pub fn rustup_add_wasm_target() -> Result<(), Error> {
     let step = format!(
         "{} {}Adding WASM target...",
         style("[1/7]").bold().dim(),
@@ -14,21 +15,18 @@ pub fn rustup_add_wasm_target() {
         .arg("target")
         .arg("add")
         .arg("wasm32-unknown-unknown")
-        .output()
-        .unwrap_or_else(|e| panic!("{} failed to execute process: {}", emoji::ERROR, e));
+        .output()?;
     pb.finish();
     if !output.status.success() {
         let s = String::from_utf8_lossy(&output.stderr);
-
-        print!(
-            "{}  rustup_add_wasm_target failed and stderr was:\n{}",
-            emoji::ERROR,
-            s
-        );
+        PBAR.error("Adding the wasm32-unknown-unknown target failed");
+        bail!(format!("Details:\n{}", s));
+    } else {
+        Ok(())
     }
 }
 
-pub fn cargo_build_wasm(path: &str) {
+pub fn cargo_build_wasm(path: &str) -> Result<(), Error> {
     let step = format!(
         "{} {}Compiling to WASM...",
         style("[2/7]").bold().dim(),
@@ -41,16 +39,13 @@ pub fn cargo_build_wasm(path: &str) {
         .arg("--release")
         .arg("--target")
         .arg("wasm32-unknown-unknown")
-        .output()
-        .unwrap_or_else(|e| panic!("{} failed to execute process: {}", emoji::ERROR, e));
+        .output()?;
     pb.finish();
     if !output.status.success() {
         let s = String::from_utf8_lossy(&output.stderr);
-
-        print!(
-            "{}  cargo_build_wasm failed and stderr was:\n{}",
-            emoji::ERROR,
-            s
-        );
+        PBAR.error("Compilation of your program failed");
+        bail!(format!("Details:\n{}", s));
+    } else {
+        Ok(())
     }
 }

src/command.rs

@@ -1,3 +1,4 @@
+use PBAR;
 use bindgen;
 use build;
 use console::style;
@@ -6,12 +7,12 @@ use failure::Error;
 use indicatif::HumanDuration;
 use manifest;
 use npm;
+#[allow(unused)]
 use quicli::prelude::*;
 use readme;
 use std::fs;
 use std::result;
 use std::time::Instant;
-use PBAR;
 
 #[derive(Debug, StructOpt)]
 pub enum Command {
@@ -30,6 +31,24 @@ pub enum Command {
     Publish { path: Option<String> },
 }
 
+pub fn run_wasm_pack(command: Command) -> result::Result<(), Error> {
+    // Run the correct command based off input and store the result of it so that we can clear
+    // the progress bar then return it
+    let status = match command {
+        Command::Init { path, scope } => init(path, scope),
+        Command::Pack { path } => pack(path),
+        Command::Publish { path } => publish(path),
+    };
+
+    // Make sure we always clear the progress bar before we abort the program otherwise
+    // stderr and stdout output get eaten up and nothing will work. If this part fails
+    // to work and clear the progress bars then you're really having a bad day with your tools.
+    PBAR.done()?;
+
+    // Return the actual status of the program to the main function
+    status
+}
+
 // quicli::prelude::* imports a different result struct which gets
 // precedence over the std::result::Result, so have had to specify
 // the correct type here.
@@ -46,19 +65,19 @@ pub fn create_pkg_dir(path: &str) -> result::Result<(), Error> {
     Ok(())
 }
 
-pub fn init(path: Option<String>, scope: Option<String>) -> result::Result<(), Error> {
+fn init(path: Option<String>, scope: Option<String>) -> result::Result<(), Error> {
     let started = Instant::now();
 
     let crate_path = set_crate_path(path);
 
-    build::rustup_add_wasm_target();
-    build::cargo_build_wasm(&crate_path);
+    build::rustup_add_wasm_target()?;
+    build::cargo_build_wasm(&crate_path)?;
     create_pkg_dir(&crate_path)?;
     manifest::write_package_json(&crate_path, scope)?;
     readme::copy_from_crate(&crate_path)?;
-    bindgen::cargo_install_wasm_bindgen();
+    bindgen::cargo_install_wasm_bindgen()?;
     let name = manifest::get_crate_name(&crate_path)?;
-    bindgen::wasm_bindgen_build(&crate_path, &name);
+    bindgen::wasm_bindgen_build(&crate_path, &name)?;
     PBAR.one_off_message(&format!(
         "{} Done in {}",
         emoji::SPARKLE,
@@ -69,23 +88,22 @@ pub fn init(path: Option<String>, scope: Option<String>) -> result::Result<(), E
         emoji::PACKAGE,
         &crate_path
     ));
-    PBAR.done()?;
     Ok(())
 }
 
-pub fn pack(path: Option<String>) -> result::Result<(), Error> {
+fn pack(path: Option<String>) -> result::Result<(), Error> {
     let crate_path = set_crate_path(path);
 
-    npm::npm_pack(&crate_path);
-    println!("🎒  packed up your package!");
+    npm::npm_pack(&crate_path)?;
+    PBAR.one_off_message("🎒  packed up your package!");
     Ok(())
 }
 
-pub fn publish(path: Option<String>) -> result::Result<(), Error> {
+fn publish(path: Option<String>) -> result::Result<(), Error> {
     let crate_path = set_crate_path(path);
 
-    npm::npm_publish(&crate_path);
-    println!("💥  published your package!");
+    npm::npm_publish(&crate_path)?;
+    PBAR.one_off_message("💥  published your package!");
     Ok(())
 }
 

src/lib.rs

@@ -1,4 +1,5 @@
 extern crate console;
+#[macro_use]
 extern crate failure;
 extern crate indicatif;
 #[macro_use]

src/main.rs

@@ -5,17 +5,9 @@ extern crate indicatif;
 extern crate quicli;
 
 use quicli::prelude::*;
-use wasm_pack::command::{init, pack, publish, Command};
 use wasm_pack::Cli;
+use wasm_pack::command::run_wasm_pack;
 
-main!(|args: Cli, log_level: verbosity| match args.cmd {
-    Command::Init { path, scope } => {
-        init(path, scope)?;
-    }
-    Command::Pack { path } => {
-        pack(path)?;
-    }
-    Command::Publish { path } => {
-        publish(path)?;
-    }
+main!(|args: Cli, log_level: verbosity| {
+    run_wasm_pack(args.cmd)?;
 });

src/manifest.rs

@@ -1,12 +1,12 @@
 use std::fs::File;
 use std::io::prelude::*;
 
+use PBAR;
 use console::style;
 use emoji;
 use failure::Error;
 use serde_json;
 use toml;
-use PBAR;
 
 #[derive(Deserialize)]
 struct CargoManifest {

src/npm.rs

@@ -1,32 +1,33 @@
-use emoji;
+use PBAR;
+use failure::Error;
 use std::process::Command;
 
-pub fn npm_pack(path: &str) {
+pub fn npm_pack(path: &str) -> Result<(), Error> {
     let pkg_file_path = format!("{}/pkg", path);
     let output = Command::new("npm")
         .current_dir(pkg_file_path)
         .arg("pack")
-        .output()
-        .unwrap_or_else(|e| panic!("{} failed to execute process: {}", emoji::ERROR, e));
+        .output()?;
     if !output.status.success() {
         let s = String::from_utf8_lossy(&output.stderr);
-        print!("{}  npm_pack failed and stderr was:\n{}", emoji::ERROR, s);
+        PBAR.error("Packaging up your code failed");
+        bail!(format!("Details:\n{}", s));
+    } else {
+        Ok(())
     }
 }
 
-pub fn npm_publish(path: &str) {
+pub fn npm_publish(path: &str) -> Result<(), Error> {
     let pkg_file_path = format!("{}/pkg", path);
     let output = Command::new("npm")
         .current_dir(pkg_file_path)
         .arg("publish")
-        .output()
-        .unwrap_or_else(|e| panic!("{} failed to execute process: {}", emoji::ERROR, e));
+        .output()?;
     if !output.status.success() {
         let s = String::from_utf8_lossy(&output.stderr);
-        print!(
-            "{}  npm_publish failed and stderr was:\n{}",
-            emoji::ERROR,
-            s
-        );
+        PBAR.error("Publishing to npm failed");
+        bail!(format!("Details:\n{}", s));
+    } else {
+        Ok(())
     }
 }

src/readme.rs

@@ -2,8 +2,8 @@ use console::style;
 use failure::Error;
 use std::fs;
 
-use emoji;
 use PBAR;
+use emoji;
 
 pub fn copy_from_crate(path: &str) -> Result<(), Error> {
     let step = format!(