cmd(snip): run wasm-snip command

Author: csmoe

Cargo.lock

@@ -24,3 +24,4 @@ slog-async = "2.3"
 structopt = "0.2"
 toml = "0.4"
 wasm-snip = "0.1.3"
+parity-wasm = "0.27.0"

Cargo.toml

@@ -1,3 +1,5 @@
+use parity_wasm::elements::{self, Serialize};
+
 use bindgen;
 use build;
 use console::style;
@@ -82,9 +84,9 @@ pub enum Command {
 
 #[derive(Clone, Debug, StructOpt)]
 pub struct SnipOpitons {
-        input: Option<String>,
+        input: String,
         #[structopt(long = "output", short = "o")]
-        output: Option<String>,
+        pub(crate) output: Option<String>,
         functions: Vec<String>,
         #[structopt(long = "pattern", short = "p")]
         patterns: Vec<String>,
@@ -94,15 +96,14 @@ pub struct SnipOpitons {
         snip_rust_panicking_code: bool,
 }
 
-impl From<wasm_snip::Options> for SnipOpitons {
-    fn from(opts: wasm_snip::Options) -> Self {
-        SnipOpitons {
-            input: opts.input.to_str().map(::std::borrow::ToOwned::to_owned),
-            output: Default::default(),
-            functions: opts.functions,
-            patterns: opts.patterns,
-            snip_rust_fmt_code: opts.snip_rust_fmt_code,
-            snip_rust_panicking_code: opts.snip_rust_panicking_code,
+impl Into<wasm_snip::Options> for SnipOpitons {
+    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,
         }
     }
 }
@@ -156,9 +157,11 @@ pub fn run_wasm_pack(command: Command, log: &Logger) -> result::Result<(), Error
             login(registry, scope, always_auth, auth_type, &log)
         }
 
-        Command::Snip(_opts) => {
-            unimplemented!()
+        Command::Snip(opts) => {
+            info!(&log,  "Running snip command...");
+            snip(opts)
         }
+
     };
 
     match status {
@@ -348,3 +351,17 @@ fn set_crate_path(path: Option<String>) -> String {
 
     crate_path
 }
+
+fn snip(opts: SnipOpitons) -> Result<(), Error> {
+    let opt = opts.clone();
+     let module = wasm_snip::snip(opts.into())?;
+
+    if let Some(output) = opt.output {
+        elements::serialize_to_file(output, module)?;
+    } else {
+        let stdout = ::std::io::stdout();
+        let mut stdout = stdout.lock();
+        module.serialize(&mut stdout)?;
+    }
+    Ok(())
+}

src/command.rs

@@ -1,8 +1,10 @@
 //! Code related to error handling for wasm-pack
 use serde_json;
+use parity_wasm;
 use std::borrow::Cow;
 use std::io;
 use toml;
+use failure;
 
 #[derive(Debug, Fail)]
 pub enum Error {
@@ -66,3 +68,22 @@ impl From<toml::de::Error> for Error {
         Error::SerdeToml(e)
     }
 }
+
+impl From<parity_wasm::elements::Error> for Error {
+    fn from(error: parity_wasm::elements::Error) -> Self {
+        Error::Cli {
+            message: format!("{}", "There was an output Error"),
+            stderr: format!("{}", error),
+        }
+    }
+}
+
+impl From<failure::Error> for Error {
+    fn from(error: failure::Error) -> Self {
+        Error::Cli {
+            message: format!("{}", "There was an wasm-snip Error"),
+            stderr: format!("{}", error),
+        }
+    }
+}
+

src/error.rs

@@ -16,6 +16,7 @@ extern crate slog_async;
 extern crate slog_term;
 extern crate toml;
 extern crate wasm_snip;
+extern crate parity_wasm;
 
 pub mod bindgen;
 pub mod build;

src/lib.rs

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