feat: Check for wasm32-unknown-unknown in sysroot

First check if wasm32-unknown-unknown is present in rustc's
sysroot and if it is, then we're fine. Otherwise check if we're using
rustup and add the wasm32 target and if we're not using rustup, then
bail with an error stating that the wasm32 target couldn't be found.

Cargo.toml

@@ -34,7 +34,6 @@ siphasher = "0.2.3"
 structopt = "0.2"
 toml = "0.4"
 which = "2.0.0"
-tempfile = "3.0"
 binary-install = { version = "0.0.1", path = "./binary-install" }
 walkdir = "2"
 

src/build.rs

@@ -4,11 +4,12 @@ use child;
 use command::build::BuildProfile;
 use emoji;
 use failure::{Error, ResultExt};
+use log::info;
 use progressbar::Step;
 use std::path::Path;
-use std::process::Command;
+use std::process::{Command, Stdio};
 use std::str;
-use tempfile;
+use std::string::FromUtf8Error;
 use PBAR;
 
 /// Ensure that `rustc` is present and that it is >= 1.30.0
@@ -50,35 +51,88 @@ fn rustc_minor_version() -> Option<u32> {
     otry!(pieces.next()).parse().ok()
 }
 
-/// Ensure that `rustup` has the `wasm32-unknown-unknown` target installed for
+/// Get rustc's sysroot as a String
-/// current toolchain
+fn get_rustc_sysroot() -> Result<String, FromUtf8Error> {
-pub fn rustup_add_wasm_target(step: &Step) -> Result<(), Error> {
+    String::from_utf8(
-    let msg = format!("{}Adding WASM target...", emoji::TARGET);
+        Command::new("rustc")
-    PBAR.step(step, &msg);
+            .args(&["--print", "sysroot"])
+            .stdout(Stdio::piped())
+            .output()
+            .unwrap()
+            .stdout,
+    )
+}
+
+/// Checks if the wasm32-unknown-unknown is present in rustc's sysroot.
+fn is_wasm32_target_in_sysroot(sysroot: &str) -> Result<bool, Error> {
+    let wasm32_target = "wasm32-unknown-unknown";
+
+    info!("Looking for {} in {}", wasm32_target, sysroot);
+
+    let rustlib_path = &format!("{}/lib/rustlib", sysroot.replace("\n", ""));
+
+    let ls_command = Command::new("ls")
+        .arg(rustlib_path)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()?;
+
+    let grep_command_status = Command::new("grep")
+        .args(&["-x", wasm32_target])
+        .stdin(ls_command.stdout.unwrap())
+        .status();
+
+    match grep_command_status {
+        Ok(status) if status.success() => {
+            info!("Found {} in {}", wasm32_target, sysroot);
+            Ok(true)
+        }
+        _ => {
+            info!("Failed to find {} in {}", wasm32_target, sysroot);
+            Ok(false)
+        }
+    }
+}
+
+fn check_wasm32_target() -> Result<bool, Error> {
+    let sysroot = get_rustc_sysroot()?;
 
-    // Checking wether we can already compile to wasm with the rustc
+    // If wasm32-unknown-unknown already exists we're ok.
-    // we have in scope.
+    match is_wasm32_target_in_sysroot(&sysroot) {
-    let dir = tempfile::TempDir::new()?;
+        Ok(true) => Ok(true),
-    let p = dir.path().join("main.rs");
+        // If it doesn't exist, then we need to check if we're using rustup.
-    {
+        _ => {
-        let mut f = File::create(&p)?;
+            // If sysroot contains .rustup, then we can assume we're using rustup
-        writeln!(f, "fn main(){{}}")?;
+            // and use rustup to add the wasm32-unknown-unknown target.
-    }
+            if sysroot.contains(".rustup") {
-    match Command::new("rustc")
+                rustup_add_wasm_target()
-        .arg("--target")
+            } else {
-        .arg("wasm32-unknown-unknown")
+                Ok(false)
-        .arg(p.to_str().unwrap())
+            }
-        .status()
+        }
-    {
+    }
-        Ok(ref e) if e.success() => return Ok(()),
+}
-        _ => {}
+
-    }
+/// Add wasm32-unknown-unknown using `rustup`.
-
+fn rustup_add_wasm_target() -> Result<bool, Error> {
-    // If not, using rustup to add it.
     let mut cmd = Command::new("rustup");
     cmd.arg("target").arg("add").arg("wasm32-unknown-unknown");
     child::run(cmd, "rustup").context("Adding the wasm32-unknown-unknown target with rustup")?;
-    Ok(())
+
+    Ok(true)
+}
+
+/// Ensure that `rustup` has the `wasm32-unknown-unknown` target installed for
+/// current toolchain
+pub fn check_for_wasm32_target(step: &Step) -> Result<(), Error> {
+    let msg = format!("{}Checking for WASM target...", emoji::TARGET);
+    PBAR.step(step, &msg);
+
+    // Check if wasm32 target is present, otherwise bail.
+    match check_wasm32_target() {
+        Ok(true) => Ok(()),
+        _ => bail!("wasm32-unknown-unknown target not found!"),
+    }
 }
 
 /// Run `cargo build` targetting `wasm32-unknown-unknown`.

src/command/build.rs

@@ -236,7 +236,7 @@ impl Build {
             BuildMode::Normal => steps![
                 step_check_rustc_version,
                 step_check_crate_config,
-                step_add_wasm_target,
+                step_check_for_wasm_target,
                 step_build_wasm,
                 step_create_dir,
                 step_copy_readme,
@@ -281,10 +281,10 @@ impl Build {
         Ok(())
     }
 
-    fn step_add_wasm_target(&mut self, step: &Step) -> Result<(), Error> {
+    fn step_check_for_wasm_target(&mut self, step: &Step) -> Result<(), Error> {
-        info!("Adding wasm-target...");
+        info!("Checking for wasm-target...");
-        build::rustup_add_wasm_target(step)?;
+        build::check_for_wasm32_target(step)?;
-        info!("Adding wasm-target was successful.");
+        info!("Checking for wasm-target was successful.");
         Ok(())
     }
 

src/command/test.rs

@@ -196,7 +196,7 @@ impl Test {
         match self.mode {
             BuildMode::Normal => steps![
                 step_check_rustc_version,
-                step_add_wasm_target,
+                step_check_for_wasm_target,
                 step_build_tests,
                 step_install_wasm_bindgen,
                 step_test_node if self.node,
@@ -208,7 +208,7 @@ impl Test {
                 step_test_safari if self.safari,
             ],
             BuildMode::Force => steps![
-                step_add_wasm_target,
+                step_check_for_wasm_target,
                 step_build_tests,
                 step_install_wasm_bindgen,
                 step_test_node if self.node,
@@ -240,9 +240,9 @@ impl Test {
         Ok(())
     }
 
-    fn step_add_wasm_target(&mut self, step: &Step) -> Result<(), Error> {
+    fn step_check_for_wasm_target(&mut self, step: &Step) -> Result<(), Error> {
         info!("Adding wasm-target...");
-        build::rustup_add_wasm_target(step)?;
+        build::check_for_wasm32_target(step)?;
         info!("Adding wasm-target was successful.");
         Ok(())
     }

src/lib.rs

@@ -23,7 +23,6 @@ extern crate structopt;
 extern crate binary_install;
 extern crate dialoguer;
 extern crate log;
-extern crate tempfile;
 extern crate toml;
 extern crate walkdir;