Coordinate wasm-bindgen versions.

Author: data-pup

Cargo.lock

@@ -23,6 +23,7 @@ slog-term = "2.4"
 slog-async = "2.3"
 structopt = "0.2"
 toml = "0.4"
+which = "2.0.0"
 
 [dev-dependencies]
 copy_dir = "0.1.2"

Cargo.toml

@@ -3,26 +3,57 @@
 use emoji;
 use error::Error;
 use progressbar::Step;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
+use which::which;
 use PBAR;
 
 /// Install the `wasm-bindgen` CLI with `cargo install`.
-pub fn cargo_install_wasm_bindgen(step: &Step) -> Result<(), Error> {
+pub fn cargo_install_wasm_bindgen(
+    path: &Path,
+    version: &str,
+    install_permitted: bool,
+    step: &Step,
+) -> Result<(), Error> {
+    // Determine if the `wasm-bindgen` dependency is already met for the given mode.
+    let dependency_met = if let Some(bindgen_path) = wasm_bindgen_path_str(path) {
+        wasm_bindgen_version_check(&bindgen_path, version).unwrap_or_else(|_| false)
+    } else {
+        false
+    };
+
+    // If the `wasm-bindgen` dependency is already met, print a message and return.
+    if dependency_met {
+        let msg = format!("{}WASM-bindgen already installed...", emoji::DOWN_ARROW);
+        PBAR.step(step, &msg);
+        return Ok(());
+    }
+
+    // If the `wasm-bindgen` dependency was not met, and installs are not
+    // permitted, return a configuration error.
+    if !install_permitted {
+        return Error::crate_config("WASM-bindgen is not installed!");
+        // FIXUP: This error message can be improved.
+    }
+
     let msg = format!("{}Installing WASM-bindgen...", emoji::DOWN_ARROW);
     PBAR.step(step, &msg);
     let output = Command::new("cargo")
         .arg("install")
-        .arg("wasm-bindgen-cli")
         .arg("--force")
+        .arg("wasm-bindgen-cli")
+        .arg("--version")
+        .arg(version)
+        .arg("--root")
+        .arg(path)
         .output()?;
     if !output.status.success() {
+        let message = "Installing wasm-bindgen failed".to_string();
         let s = String::from_utf8_lossy(&output.stderr);
-        if s.contains("already exists") {
-            PBAR.info("wasm-bindgen already installed");
-            return Ok(());
-        }
-        Error::cli("Installing wasm-bindgen failed", s)
+        Err(Error::Cli {
+            message,
+            stderr: s.to_string(),
+        })
     } else {
         Ok(())
     }
@@ -42,33 +73,88 @@ pub fn wasm_bindgen_build(
     PBAR.step(step, &msg);
     let binary_name = name.replace("-", "_");
     let release_or_debug = if debug { "debug" } else { "release" };
-    let wasm_path = format!(
-        "target/wasm32-unknown-unknown/{}/{}.wasm",
-        release_or_debug, binary_name
-    );
-    let dts_arg = if disable_dts == false {
-        "--typescript"
-    } else {
-        "--no-typescript"
-    };
 
-    let target_arg = match target {
-        "nodejs" => "--nodejs",
-        _ => "--browser",
-    };
+    if let Some(wasm_bindgen_path_str) = wasm_bindgen_path_str(path) {
+        let wasm_path = format!(
+            "target/wasm32-unknown-unknown/{}/{}.wasm",
+            release_or_debug, binary_name
+        );
+        let dts_arg = if disable_dts == false {
+            "--typescript"
+        } else {
+            "--no-typescript"
+        };
+        let target_arg = match target {
+            "nodejs" => "--nodejs",
+            _ => "--browser",
+        };
+        let bindgen_path = Path::new(&wasm_bindgen_path_str);
+        let output = Command::new(bindgen_path)
+            .current_dir(path)
+            .arg(&wasm_path)
+            .arg("--out-dir")
+            .arg("./pkg")
+            .arg(dts_arg)
+            .arg(target_arg)
+            .output()?;
+        if !output.status.success() {
+            let s = String::from_utf8_lossy(&output.stderr);
+            Error::cli("wasm-bindgen failed to execute properly", s)
+        } else {
+            Ok(())
+        }
+    } else {
+        Error::crate_config("Could not find `wasm-bindgen`")
+    }
+}
 
-    let output = Command::new("wasm-bindgen")
-        .current_dir(path)
-        .arg(&wasm_path)
-        .arg("--out-dir")
-        .arg("./pkg")
-        .arg(dts_arg)
-        .arg(target_arg)
-        .output()?;
-    if !output.status.success() {
+/// Check if the `wasm-bindgen` dependency is locally satisfied.
+fn wasm_bindgen_version_check(bindgen_path: &PathBuf, dep_version: &str) -> Result<bool, Error> {
+    let wasm_bindgen = Path::new(bindgen_path);
+    let output = Command::new(wasm_bindgen).arg("--version").output()?;
+    if output.status.success() {
+        let s = String::from_utf8_lossy(&output.stdout);
+        let installed_version = s.trim(); // FIXUP: Trim this more thoroughly?
+        Ok(installed_version == dep_version)
+    } else {
+        // FIXUP: This error message can be improved.
+        let message = String::from("Could not find version of local wasm-bindgen");
         let s = String::from_utf8_lossy(&output.stderr);
-        Error::cli("wasm-bindgen failed to execute properly", s)
+        Err(Error::Cli {
+            message,
+            stderr: s.to_string(),
+        })
+    }
+}
+
+/// Return a string to `wasm-bindgen`, if it exists for the given mode.
+fn wasm_bindgen_path_str(crate_path: &Path) -> Option<PathBuf> {
+    if let res @ Some(_) = local_wasm_bindgen_path_str(crate_path) {
+        res
+    } else if let res @ Some(_) = global_wasm_bindgen_path_str() {
+        res
     } else {
-        Ok(())
+        None
+    }
+}
+
+/// Return a string containing the path to the local `wasm-bindgen`, if it exists.
+fn local_wasm_bindgen_path_str(crate_path: &Path) -> Option<PathBuf> {
+    let mut path = crate_path.to_path_buf();
+    path.push("bin");
+    path.push("wasm-bindgen");
+    if path.is_file() {
+        Some(path)
+    } else {
+        None
+    }
+}
+
+/// Return a string containing the path to the global `wasm-bindgen`, if it exists.
+fn global_wasm_bindgen_path_str() -> Option<PathBuf> {
+    if let Ok(path) = which("wasm-bindgen") {
+        Some(path)
+    } else {
+        None
     }
 }

src/bindgen.rs

@@ -19,6 +19,7 @@ pub(crate) struct Build {
     pub disable_dts: bool,
     pub target: String,
     pub debug: bool,
+    pub mode: BuildMode,
     // build_config: Option<BuildConfig>,
     pub crate_name: String,
 }
@@ -71,21 +72,27 @@ impl Build {
     pub fn try_from_opts(build_opts: BuildOptions) -> Result<Self, Error> {
         let crate_path = set_crate_path(build_opts.path);
         let crate_name = manifest::get_crate_name(&crate_path)?;
+        let mode = match build_opts.mode.as_str() {
+            "no-install" => BuildMode::Noinstall,
+            "normal" => BuildMode::Normal,
+            _ => BuildMode::Normal,
+        };
         // let build_config = manifest::xxx(&crate_path).xxx();
         Ok(Build {
             crate_path,
             scope: build_opts.scope,
             disable_dts: build_opts.disable_dts,
             target: build_opts.target,
             debug: build_opts.debug,
+            mode,
             // build_config,
             crate_name,
         })
     }
 
     /// Execute this `Build` command.
-    pub fn run(&mut self, log: &Logger, mode: &BuildMode) -> Result<(), Error> {
-        let process_steps = Build::get_process_steps(mode);
+    pub fn run(&mut self, log: &Logger) -> Result<(), Error> {
+        let process_steps = Build::get_process_steps(&self.mode);
 
         let mut step_counter = Step::new(process_steps.len());
 
@@ -213,8 +220,19 @@ impl Build {
     }
 
     fn step_install_wasm_bindgen(&mut self, step: &Step, log: &Logger) -> Result<(), Error> {
+        info!(&log, "Identifying WASM-bindgen dependency...");
+        let bindgen_version = manifest::get_wasm_bindgen_version(&self.crate_path)?;
         info!(&log, "Installing wasm-bindgen-cli...");
-        bindgen::cargo_install_wasm_bindgen(step)?;
+        let install_permitted = match self.mode {
+            BuildMode::Normal => true,
+            BuildMode::Noinstall => false,
+        };
+        bindgen::cargo_install_wasm_bindgen(
+            &self.crate_path,
+            &bindgen_version,
+            install_permitted,
+            step,
+        )?;
         info!(&log, "Installing wasm-bindgen-cli was successful.");
 
         info!(&log, "Getting the crate name from the manifest...");

src/command/build.rs

@@ -6,7 +6,7 @@ mod pack;
 mod publish;
 pub mod utils;
 
-use self::build::{Build, BuildMode, BuildOptions};
+use self::build::{Build, BuildOptions};
 use self::login::login;
 use self::pack::pack;
 use self::publish::publish;
@@ -79,12 +79,7 @@ pub fn run_wasm_pack(command: Command, log: &Logger) -> result::Result<(), Error
     let status = match command {
         Command::Build(build_opts) => {
             info!(&log, "Running build command...");
-            let build_mode = match build_opts.mode.as_str() {
-                "no-install" => BuildMode::Noinstall,
-                "normal" => BuildMode::Normal,
-                _ => BuildMode::Normal,
-            };
-            Build::try_from_opts(build_opts).and_then(|mut b| b.run(&log, &build_mode))
+            Build::try_from_opts(build_opts).and_then(|mut b| b.run(&log))
         }
         Command::Pack { path } => {
             info!(&log, "Running pack command...");

src/command/mod.rs

@@ -19,6 +19,7 @@ extern crate slog;
 extern crate slog_async;
 extern crate slog_term;
 extern crate toml;
+extern crate which;
 
 pub mod bindgen;
 pub mod build;

src/lib.rs

@@ -199,6 +199,9 @@ fn check_wasm_bindgen(path: &Path) -> Result<(), Error> {
         "Ensure that you have \"{}\" as a dependency in your Cargo.toml file:\n[dependencies]\nwasm-bindgen = \"0.2\"",
         style("wasm-bindgen").bold().dim()
     ))
+    // FIXUP: Use the `get_wasm_bindgen_version` function for this?
+    // let _ = get_wasm_bindgen_version(path)?;
+    // Ok(())
 }
 
 fn check_crate_type(path: &Path) -> Result<(), Error> {
@@ -212,3 +215,29 @@ fn check_crate_type(path: &Path) -> Result<(), Error> {
       "crate-type must be cdylib to compile to wasm32-unknown-unknown. Add the following to your Cargo.toml file:\n\n[lib]\ncrate-type = [\"cdylib\"]"
     )
 }
+
+/// Get the version of `wasm-bindgen` specified as a dependency.
+pub fn get_wasm_bindgen_version(path: &Path) -> Result<String, Error> {
+    if let Some(deps) = read_cargo_toml(path)?.dependencies {
+        match deps.get("wasm_bindgen") {
+            Some(CargoDependency::Simple(version)) => Ok(version.clone()),
+            Some(CargoDependency::Detailed(_)) => {
+                // FIXUP? Is this correct?
+                let msg = format!(
+                    "\"{}\" dependency is missing its version number",
+                    style("wasm-bindgen").bold().dim()
+                );
+                Err(Error::CrateConfig { message: msg })
+            }
+            None => {
+                let message = format!(
+                    "Ensure that you have \"{}\" as a dependency in your Cargo.toml file:\n[dependencies]\nwasm-bindgen = \"0.2\"",
+                    style("wasm-bindgen").bold().dim());
+                Err(Error::CrateConfig { message })
+            }
+        }
+    } else {
+        let message = String::from("Could not find crate dependencies");
+        Err(Error::CrateConfig { message })
+    }
+}