refactor: Use PBAR.warn and a struct for versions

As mentioned in #409, some comments mentioned to use `?`
over calling `.unwrap()` and to use a struct
instead of two Strings. This PR leverages `?` and a new struct called
`WasmPackVersion` with a `local` and `latest` field. This PR also
uses `PBAR.warn(warning_msg)` instead of `println!(warning_msg)`
to print the warning message.

src/build/mod.rs

@@ -12,6 +12,16 @@ use PBAR;
 
 pub mod wasm_target;
 
+/// Used when comparing the currently installed
+/// wasm-pack version with the latest on crates.io.
+pub struct WasmPackVersion {
+    /// The currently installed wasm-pack version.
+    pub local: String,
+    /// The latest version of wasm-pack that's released at
+    /// crates.io.
+    pub latest: String,
+}
+
 /// Ensure that `rustc` is present and that it is >= 1.30.0
 pub fn check_rustc_version() -> Result<String, Error> {
     let local_minor_version = rustc_minor_version();
@@ -50,12 +60,12 @@ fn rustc_minor_version() -> Option<u32> {
 }
 
 /// Checks and returns local and latest versions of wasm-pack
-pub fn check_wasm_pack_versions() -> Result<(String, String), Error> {
+pub fn check_wasm_pack_versions() -> Result<WasmPackVersion, Error> {
     match wasm_pack_local_version() {
         Some(local) => {
             match Crate::return_wasm_pack_latest_version() {
-                Some(latest) => Ok((local, latest)),
+                Some(latest) => Ok(WasmPackVersion {local, latest}),
-                None => Ok((local, "".to_string()))
+                None => Ok(WasmPackVersion {local, latest: "".to_string()})
             }
         },
         None => bail!("We can't figure out what your wasm-pack version is, make sure the installation path is correct.")

src/command/build.rs

@@ -255,12 +255,6 @@ impl Build {
         Ok(())
     }
 
-    /// Returns local and latest wasm-pack versions.
-    pub fn return_wasm_pack_versions() -> Result<(String, String), Error> {
-        let (local, latest) = build::check_wasm_pack_versions()?;
-        Ok((local, latest))
-    }
-
     fn get_process_steps(mode: BuildMode) -> Vec<(&'static str, BuildStep)> {
         macro_rules! steps {
             ($($name:ident),+) => {

src/main.rs

@@ -13,17 +13,24 @@ use std::panic;
 use std::sync::mpsc;
 use std::thread;
 use structopt::StructOpt;
-use wasm_pack::command::build::Build;
+use wasm_pack::{
-use wasm_pack::{command::run_wasm_pack, Cli};
+    build::{self, WasmPackVersion},
+    command::run_wasm_pack,
+    Cli, PBAR,
+};
 
 mod installer;
 
-fn background_check_for_updates() -> mpsc::Receiver<(String, String)> {
+fn background_check_for_updates() -> mpsc::Receiver<WasmPackVersion> {
     let (sender, receiver) = mpsc::channel();
+
     let _detached_thread = thread::spawn(move || {
-        if let Ok((local, latest)) = Build::return_wasm_pack_versions() {
+        if let Ok(wasm_pack_version) = build::check_wasm_pack_versions() {
-            if !local.is_empty() && !latest.is_empty() && local != latest {
+            if !wasm_pack_version.local.is_empty()
-                sender.send((local, latest)).unwrap();
+                && !wasm_pack_version.latest.is_empty()
+                && wasm_pack_version.local != wasm_pack_version.latest
+            {
+                let _ = sender.send(wasm_pack_version);
             }
         }
     });
@@ -46,7 +53,7 @@ fn main() {
 }
 
 fn run() -> Result<(), failure::Error> {
-    let update_available = background_check_for_updates();
+    let wasm_pack_version = background_check_for_updates();
 
     // Deprecate `init`
     if let Some("init") = env::args().nth(1).as_ref().map(|arg| arg.as_str()) {
@@ -69,9 +76,9 @@ fn run() -> Result<(), failure::Error> {
     let args = Cli::from_args();
     run_wasm_pack(args.cmd)?;
 
-    if let Ok(update_available) = update_available.try_recv() {
+    if let Ok(wasm_pack_version) = wasm_pack_version.try_recv() {
-        println!("There's a newer version of wasm-pack available, the new version is: {}, you are using: {}. \
+        PBAR.warn(&format!("There's a newer version of wasm-pack available, the new version is: {}, you are using: {}. \
-            To update, navigate to: https://rustwasm.github.io/wasm-pack/installer/", update_available.1, update_available.0);
+            To update, navigate to: https://rustwasm.github.io/wasm-pack/installer/", wasm_pack_version.latest, wasm_pack_version.local));
     }
 
     Ok(())

src/manifest/mod.rs

@@ -19,10 +19,10 @@ use failure::{Error, ResultExt};
 use serde::{self, Deserialize};
 use serde_json;
 use std::collections::BTreeSet;
+use std::env;
 use std::io::Write;
 use strsim::levenshtein;
 use toml;
-use which;
 use PBAR;
 
 const WASM_PACK_METADATA_KEY: &str = "package.metadata.wasm-pack";
@@ -143,55 +143,57 @@ impl Crate {
     /// Returns latest wasm-pack version
     pub fn return_wasm_pack_latest_version() -> Option<String> {
         let current_time = chrono::offset::Local::now();
-        Crate::return_wasm_pack_file().and_then(|contents| {
+
-            let last_updated = Crate::return_stamp_file_value(&contents, "created")
+        Self::return_wasm_pack_file()
-                .and_then(|t| Some(DateTime::parse_from_str(t.as_str(), "%+").unwrap()));
+            .and_then(|contents| {
-            let version = Crate::return_stamp_file_value(&contents, "version").and_then(|v| {
+                let last_updated = Self::return_stamp_file_value(&contents, "created")
-                if current_time
+                    .and_then(|t| DateTime::parse_from_str(t.as_str(), "%+").ok());
-                    .signed_duration_since(last_updated.unwrap())
+
-                    .num_hours()
+                Self::return_stamp_file_value(&contents, "version").and_then(|v| {
-                    > 24
+                    last_updated.and_then(|last_updated| {
-                {
+                        if current_time.signed_duration_since(last_updated).num_hours() > 24 {
-                    return Crate::return_api_call_result(current_time);
+                            Self::return_api_call_result(current_time)
                         } else {
-                    return Some(v);
+                            Some(v)
                         }
-            });
+                    })
-            version
+                })
-        });
+            })
-        return Crate::return_api_call_result(current_time);
+            .map_or(Self::return_api_call_result(current_time), |value| {
+                Some(value)
+            })
     }
 
     fn return_api_call_result(current_time: DateTime<offset::Local>) -> Option<String> {
-        Crate::return_latest_wasm_pack_version().and_then(|v| {
+        Self::return_latest_wasm_pack_version().and_then(|v| {
-            Crate::override_stamp_file(current_time, &v);
+            Self::override_stamp_file(current_time, &v).ok();
             Some(v)
         })
     }
 
-    fn override_stamp_file(current_time: DateTime<offset::Local>, version: &String) {
+    fn override_stamp_file(
-        if let Ok(path) = which::which("wasm-pack") {
+        current_time: DateTime<offset::Local>,
-            let file = fs::OpenOptions::new()
+        version: &String,
+    ) -> Result<(), failure::Error> {
+        let path = env::current_exe()?;
+
+        let mut file = fs::OpenOptions::new()
             .read(true)
             .write(true)
             .append(true)
             .create(true)
-                .open(path.with_extension("stamp"));
+            .open(path.with_extension("stamp"))?;
 
-            if let Ok(()) = file.as_ref().unwrap().set_len(0) {
+        file.set_len(0)?;
-                if let Err(_) = write!(
+
-                    file.unwrap(),
+        write!(file, "created {:?}\nversion {}", current_time, version)?;
-                    "created {:?}\nversion {}",
+
-                    current_time,
+        Ok(())
-                    version
-                ) {}
-            }
-        }
     }
 
     /// Return stamp file where metadata is stored.
     fn return_wasm_pack_file() -> Option<String> {
-        if let Ok(path) = which::which("wasm-pack") {
+        if let Ok(path) = env::current_exe() {
             if let Ok(file) = fs::read_to_string(path.with_extension("stamp")) {
                 return Some(file);
             }
@@ -201,7 +203,7 @@ impl Crate {
 
     /// Returns wasm-pack latest version (if it's received) by executing check_wasm_pack_latest_version function.
     fn return_latest_wasm_pack_version() -> Option<String> {
-        if let Ok(crt) = Crate::check_wasm_pack_latest_version() {
+        if let Ok(crt) = Self::check_wasm_pack_latest_version() {
             return Some(crt.crt.max_version);
         }
         None