Adding in log-level flag; also changing quiet to silence all stdout

src/build/mod.rs

@@ -85,8 +85,14 @@ pub fn cargo_build_wasm(
 ) -> Result<(), Error> {
     let msg = format!("{}Compiling to Wasm...", emoji::CYCLONE);
     PBAR.info(&msg);
+
     let mut cmd = Command::new("cargo");
     cmd.current_dir(path).arg("build").arg("--lib");
+
+    if PBAR.quiet() {
+        cmd.arg("--quiet");
+    }
+
     match profile {
         BuildProfile::Profiling => {
             // Once there are DWARF debug info consumers, force enable debug
@@ -104,6 +110,7 @@ pub fn cargo_build_wasm(
             // debug info by default.
         }
     }
+
     cmd.arg("--target").arg("wasm32-unknown-unknown");
     cmd.args(extra_options);
     child::run(cmd, "cargo build").context("Compiling your crate to WebAssembly failed")?;
@@ -116,11 +123,19 @@ pub fn cargo_build_wasm(
 /// wasm-bindgen-cli to use when running tests.
 pub fn cargo_build_wasm_tests(path: &Path, debug: bool) -> Result<(), Error> {
     let mut cmd = Command::new("cargo");
+
     cmd.current_dir(path).arg("build").arg("--tests");
+
+    if PBAR.quiet() {
+        cmd.arg("--quiet");
+    }
+
     if !debug {
         cmd.arg("--release");
     }
+
     cmd.arg("--target").arg("wasm32-unknown-unknown");
+
     child::run(cmd, "cargo build").context("Compilation of your program failed")?;
     Ok(())
 }

src/install/mod.rs

@@ -210,6 +210,10 @@ pub fn cargo_install(
         .arg("--root")
         .arg(&tmp);
 
+    if PBAR.quiet() {
+        cmd.arg("--quiet");
+    }
+
     let context = format!("Installing {} with cargo", tool);
     child::run(cmd, "cargo install").context(context)?;
 

src/lib.rs

@@ -44,7 +44,7 @@ pub mod target;
 pub mod test;
 pub mod wasm_opt;
 
-use progressbar::ProgressOutput;
+use progressbar::{LogLevel, ProgressOutput};
 
 /// The global progress bar and user-facing message output.
 pub static PBAR: ProgressOutput = ProgressOutput::new();
@@ -63,4 +63,8 @@ pub struct Cli {
     #[structopt(long = "quiet")]
     /// Silences wasm-pack warnings.
     pub quiet: bool,
+
+    #[structopt(long = "log-level", default_value = "info")]
+    /// The maximum level of messages that should be logged by wasm-pack. [possible values: info, warn, error]
+    pub log_level: LogLevel,
 }

src/main.rs

@@ -77,9 +77,10 @@ fn run() -> Result<(), failure::Error> {
 
     let args = Cli::from_args();
 
+    PBAR.set_log_level(args.log_level);
+
     if args.quiet {
         PBAR.set_quiet(true);
-        log::set_max_level(log::LevelFilter::Error);
     }
 
     run_wasm_pack(args.cmd)?;

src/progressbar.rs

@@ -2,11 +2,38 @@
 
 use console::style;
 use emoji;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
+
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+/// The maximum log level for wasm-pack
+// The ordering is important: the least verbose must be at
+// the top and the most verbose at the bottom
+pub enum LogLevel {
+    /// Logs only error
+    Error,
+    /// Logs only warn and error
+    Warn,
+    /// Logs everything
+    Info,
+}
+
+impl std::str::FromStr for LogLevel {
+    type Err = failure::Error;
+    fn from_str(s: &str) -> Result<Self, failure::Error> {
+        match s {
+            "error" => Ok(LogLevel::Error),
+            "warn" => Ok(LogLevel::Warn),
+            "info" => Ok(LogLevel::Info),
+            _ => bail!("Unknown log-level: {}", s),
+        }
+    }
+}
 
 /// Synchronized progress bar and status message printing.
 pub struct ProgressOutput {
     quiet: AtomicBool,
+    log_level: AtomicU8,
 }
 
 impl ProgressOutput {
@@ -14,6 +41,7 @@ impl ProgressOutput {
     pub const fn new() -> Self {
         Self {
             quiet: AtomicBool::new(false),
+            log_level: AtomicU8::new(LogLevel::Info as u8),
         }
     }
 
@@ -22,18 +50,29 @@ impl ProgressOutput {
         eprintln!("{}", message);
     }
 
-    fn quiet(&self) -> bool {
+    /// Returns whether it should silence stdout or not
+    pub fn quiet(&self) -> bool {
         self.quiet.load(Ordering::SeqCst)
     }
 
-    /// Sets whether it should silence warnings or not
+    /// Causes it to silence stdout
     pub fn set_quiet(&self, quiet: bool) {
         self.quiet.store(quiet, Ordering::SeqCst);
     }
 
+    /// Returns whether the specified log level is enabled or not
+    pub fn is_log_enabled(&self, level: LogLevel) -> bool {
+        (level as u8) <= self.log_level.load(Ordering::SeqCst)
+    }
+
+    /// Sets the log level for wasm-pack
+    pub fn set_log_level(&self, log_level: LogLevel) {
+        self.log_level.store(log_level as u8, Ordering::SeqCst);
+    }
+
     /// Add an informational message.
     pub fn info(&self, message: &str) {
-        if !self.quiet() {
+        if !self.quiet() && self.is_log_enabled(LogLevel::Info) {
             let info = format!("{}: {}", style("[INFO]").bold().dim(), message,);
             self.message(&info);
         }
@@ -41,7 +80,7 @@ impl ProgressOutput {
 
     /// Add a warning message.
     pub fn warn(&self, message: &str) {
-        if !self.quiet() {
+        if !self.quiet() && self.is_log_enabled(LogLevel::Warn) {
             let warn = format!(
                 "{} {}: {}",
                 emoji::WARN,
@@ -54,13 +93,15 @@ impl ProgressOutput {
 
     /// Add an error message.
     pub fn error(&self, message: &str) {
-        let err = format!(
-            "{} {}: {}",
-            emoji::ERROR,
-            style("[ERR]").bold().dim(),
-            message
-        );
-        self.message(&err);
+        if self.is_log_enabled(LogLevel::Error) {
+            let err = format!(
+                "{} {}: {}",
+                emoji::ERROR,
+                style("[ERR]").bold().dim(),
+                message
+            );
+            self.message(&err);
+        }
     }
 }
 

src/test/mod.rs

@@ -2,6 +2,7 @@
 
 pub mod webdriver;
 
+use crate::PBAR;
 use child;
 use failure::{self, ResultExt};
 use std::ffi::OsStr;
@@ -22,13 +23,22 @@ where
     V: AsRef<OsStr>,
 {
     let mut cmd = Command::new("cargo");
+
     cmd.envs(envs);
     cmd.current_dir(path).arg("test");
+
+    if PBAR.quiet() {
+        cmd.arg("--quiet");
+    }
+
     if release {
         cmd.arg("--release");
     }
+
     cmd.arg("--target").arg("wasm32-unknown-unknown");
+
     cmd.args(extra_options);
+
     child::run(cmd, "cargo test").context("Running Wasm tests with wasm-bindgen-test failed")?;
 
     // NB: `child::run` took care of ensuring that test output gets printed.