[WIP] Add support for running wasm-snip

Cargo.toml

@@ -32,6 +32,8 @@ tar = "0.4.16"
 toml = "0.4"
 which = "2.0.0"
 zip = "0.4.2"
+wasm-snip = { version = "0.1.3", default-features = false }
+parity-wasm = "0.27.0"
 
 [dev-dependencies]
 tempfile = "3"

src/command/build.rs

@@ -311,4 +311,20 @@ impl Build {
         info!(&log, "wasm bindings were built at {:#?}.", &self.out_dir);
         Ok(())
     }
+
+    fn set_run_wasm_snip(&mut self, step: &Step, log: &Logger) -> Result<(), Error> {
+        let msg = format!("{}Running WASM-opt...", emoji::RUNNER);
+        PBAR.step(step, &msg);
+
+        snip::set_run_wasm_snip(
+            // FIXME(csmoe) add wasm_snip_config() in build
+            self.wasm_snip_config(),
+        )?;
+        info!(
+            &log,
+            "wasm bindings were snipped at {:#?}.",
+            &self.crate_path.join("pkg")
+        );
+        Ok(())
+    }
 }

src/command/mod.rs

@@ -3,16 +3,25 @@
 pub mod build;
 mod login;
 mod pack;
+<<<<<<< HEAD
 /// Data structures and functions for publishing a package.
 pub mod publish;
 pub mod test;
+mod snip;
+||||||| merged common ancestors
+mod publish;
+mod snip;
+=======
+mod publish;
+>>>>>>> build(snip): hidde snip into build
 pub mod utils;
 
 use self::build::{Build, BuildOptions};
 use self::login::login;
 use self::pack::pack;
 use self::publish::{access::Access, publish};
 use self::test::{Test, TestOptions};
+use self::snip::{snip, SnipOpitons};
 use error::Error;
 use slog::Logger;
 use std::path::PathBuf;
@@ -81,6 +90,13 @@ pub enum Command {
     #[structopt(name = "test")]
     /// 👩‍🔬  test your wasm!
     Test(TestOptions),
+
+    #[structopt(name = "snip")]
+    /// Replace a wasm function with an `unreachable`.
+
+    #[structopt(name = "snip")]
+    /// Replace a wasm function with an `unreachable`.
+    Snip(SnipOptions),
 }
 
 /// Run a command with the given logger!
@@ -123,6 +139,10 @@ pub fn run_wasm_pack(command: Command, log: &Logger) -> result::Result<(), failu
             info!(&log, "Running test command...");
             Test::try_from_opts(test_opts).and_then(|t| t.run(&log))
         }
+        Command::Snip(opts) => {
+            info!(&log, "Running snip command...");
+            snip(opts)
+        }
     };
 
     match status {

src/error.rs

@@ -1,6 +1,9 @@
 //! Code related to error handling for wasm-pack
 use curl;
 use serde_json;
+use failure;
+use parity_wasm;
+use serde_json;
 use std::borrow::Cow;
 use std::io;
 use std::process::ExitStatus;
@@ -212,3 +215,23 @@ impl From<toml::de::Error> for Error {
         Error::SerdeToml(e)
     }
 }
+
+/// wasm-snip occurs error when trying to print out the result.
+impl From<parity_wasm::elements::Error> for Error {
+    fn from(error: parity_wasm::elements::Error) -> Self {
+        Error::Cli {
+            message: "There was an wasm-snip output Error".to_owned(),
+            stderr: format!("{}", error),
+        }
+    }
+}
+
+/// wasm-snip occurs error when working with inputs.
+impl From<failure::Error> for Error {
+    fn from(error: failure::Error) -> Self {
+        Error::Cli {
+            message: "There was an wasm-snip Error".to_owned(),
+            stderr: format!("{}", error),
+        }
+    }
+}

src/lib.rs

@@ -19,12 +19,14 @@ extern crate serde_json;
 extern crate structopt;
 #[macro_use]
 extern crate slog;
+extern crate parity_wasm;
 extern crate slog_async;
 extern crate slog_term;
 extern crate tar;
 extern crate toml;
 extern crate which;
 extern crate zip;
+extern crate wasm_snip;
 
 pub mod binaries;
 pub mod bindgen;
@@ -39,8 +41,13 @@ pub mod manifest;
 pub mod npm;
 pub mod progressbar;
 pub mod readme;
+<<<<<<< HEAD
 pub mod target;
 pub mod test;
+||||||| merged common ancestors
+=======
+pub mod snip;
+>>>>>>> build(snip): hidde snip into build
 
 use progressbar::ProgressOutput;
 

src/logger.rs

@@ -41,6 +41,7 @@ fn log_file_path(cmd: &Command) -> PathBuf {
         Command::Publish { path, access: _ } => path,
         Command::Test(test_opts) => &test_opts.path,
         Command::Login { .. } => &None,
+        Command::Snip(opts) => &opts.output,
     };
 
     // If the path exists attempt to use it, if not default to the current directory

src/snip.rs

@@ -0,0 +1,42 @@
+use error::Error;
+use parity_wasm::elements::{self, Serialize};
+use wasm_snip;
+
+#[derive(Clone, Debug, StructOpt)]
+pub struct WasmSnipConfig {
+    input: String,
+    #[structopt(long = "output", short = "o")]
+    pub(crate) output: Option<String>,
+    functions: Vec<String>,
+    #[structopt(long = "pattern", short = "p")]
+    patterns: Vec<String>,
+    #[structopt(long = "snip_rust_fmt_code")]
+    snip_rust_fmt_code: bool,
+    #[structopt(long = "snip_rust_panicking_code")]
+    snip_rust_panicking_code: bool,
+}
+
+impl Into<wasm_snip::Options> for WasmSnipConfig {
+    fn into(self) -> wasm_snip::Options {
+        wasm_snip::Options {
+            input: ::std::path::PathBuf::from(self.input),
+            functions: self.functions,
+            patterns: self.patterns,
+            snip_rust_fmt_code: self.snip_rust_fmt_code,
+            snip_rust_panicking_code: self.snip_rust_panicking_code,
+        }
+    }
+}
+
+pub(crate) fn run_wasm_snip(opts: WasmSnipConfig) -> Result<(), Error> {
+    let module = wasm_snip::snip(opts.clone().into())?;
+
+    if let Some(output) = opts.output {
+        elements::serialize_to_file(output, module)?;
+    } else {
+        let stdout = ::std::io::stdout();
+        let mut stdout = stdout.lock();
+        module.serialize(&mut stdout)?;
+    }
+    Ok(())
+}