Add legion encode commands and legion decode commands

projects/legion-cli/src/commands/mod.rs

@@ -0,0 +1,38 @@
+use crate::ToolsError;
+use clap::{Args, Parser, Subcommand};
+use std::path::PathBuf;
+mod run_decode;
+mod run_encode;
+
+pub use self::run_encode::RunEncode;
+
+#[derive(Debug, Args)]
+pub struct LegionArguments {
+    /// Optional name to operate on
+    name: Option<String>,
+
+    /// Sets a custom config file
+    #[arg(short, long, value_name = "FILE")]
+    config: Option<PathBuf>,
+
+    /// Turn debugging information on
+    #[arg(short, long, action = clap::ArgAction::Count)]
+    debug: u8,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum LegionCommands {
+    /// does testing things
+    Encode(RunEncode),
+    /// does testing things
+    Decode(RunEncode),
+}
+
+impl LegionCommands {
+    pub async fn run(self, arguments: &LegionArguments) -> Result<(), ToolsError> {
+        match self {
+            Self::Encode(cmd) => cmd.run(arguments).await,
+            Self::Decode(cmd) => cmd.run(arguments).await,
+        }
+    }
+}

projects/legion-cli/src/commands/run_decode/mod.rs

@@ -0,0 +1,30 @@
+use crate::{ToolsError, commands::LegionArguments};
+use clap::Parser;
+use wasmprinter::PrintFmtWrite;
+use wat::GenerateDwarf;
+
+#[derive(Debug, Parser)]
+pub struct RunDecode {
+    #[arg(short, long, value_name = "FILE")]
+    skeleton_only: bool,
+    #[arg(short, long, value_name = "FILE")]
+    indent_text: String,
+    #[arg(short, long, value_name = "FILE")]
+    fold_instructions: bool,
+}
+
+impl RunDecode {
+    pub async fn run(self, args: &LegionArguments) -> Result<(), ToolsError> {
+        let input = [];
+        let mut parser = wasmprinter::Config::new();
+        parser.name_unnamed(true);
+        parser.print_offsets(false);
+        parser.print_skeleton(self.skeleton_only);
+        parser.indent_text(self.indent_text);
+        parser.fold_instructions(self.fold_instructions);
+        let mut dst = String::new();
+        parser.print(&input, &mut PrintFmtWrite(&mut dst))?;
+
+        Ok(())
+    }
+}

projects/legion-cli/src/commands/run_encode/mod.rs

@@ -0,0 +1,21 @@
+use crate::{ToolsError, commands::LegionArguments};
+use clap::Parser;
+use wat::GenerateDwarf;
+
+#[derive(Debug, Parser)]
+pub struct RunEncode {
+    #[arg(short, long, value_name = "FILE")]
+    generate_dwarf: bool,
+}
+
+impl RunEncode {
+    pub async fn run(self, args: &LegionArguments) -> Result<(), ToolsError> {
+        let input = "";
+        let mut parser = wat::Parser::new();
+        if self.generate_dwarf {
+            parser.generate_dwarf(GenerateDwarf::Full);
+        }
+        let bytes = parser.parse_str(None, input)?;
+        Ok(())
+    }
+}

projects/legion-cli/src/lib.rs

@@ -1,5 +1,7 @@
 mod errors;
 mod tools;
+pub mod commands;
+
 // use inquire::{Text, validator::{StringValidator, Validation}, CustomUserError};
 pub use crate::errors::ToolsError;
 use std::path::PathBuf;
@@ -15,60 +17,6 @@ pub struct LegionCLI {
     arguments: LegionArguments,
 }
 
-#[derive(Debug, Args)]
-pub struct LegionArguments {
-    /// Optional name to operate on
-    name: Option<String>,
-
-    /// Sets a custom config file
-    #[arg(short, long, value_name = "FILE")]
-    config: Option<PathBuf>,
-
-    /// Turn debugging information on
-    #[arg(short, long, action = clap::ArgAction::Count)]
-    debug: u8,
-}
-
-#[derive(Debug, Subcommand)]
-pub enum LegionCommands {
-    /// does testing things
-    Test {
-        /// lists test values
-        #[arg(short, long)]
-        list: bool,
-    },
-    Encode(RunEncode),
-}
-
-#[derive(Debug, Parser)]
-pub struct RunEncode {
-    #[arg(short, long, value_name = "FILE")]
-    generate_dwarf: bool,
-}
-
-impl RunEncode {
-    pub async fn run(self, args: &LegionArguments) -> Result<(), ToolsError> {
-        let input = "";
-        let mut parser = wat::Parser::new();
-        if self.generate_dwarf {
-            parser.generate_dwarf(GenerateDwarf::Full);
-        }
-        let bytes = parser.parse_str(None, input)?;
-        Ok(())
-    }
-}
-impl LegionCommands {
-    pub async fn run(self, arguments: &LegionArguments) -> Result<(), ToolsError> {
-        match self {
-            LegionCommands::Test { list } => {
-                println!("Testing!");
-                Ok(())
-            }
-            LegionCommands::Encode(cmd) => cmd.run(arguments).await,
-        }
-    }
-}
-
 impl LegionCLI {
     pub async fn run(self) -> Result<(), ToolsError> {
         println!("{:?}", self.arguments);
@@ -85,6 +33,7 @@ impl LegionCLI {
 
 use dialoguer::{Select, theme::ColorfulTheme};
 use wat::GenerateDwarf;
+use crate::commands::{LegionArguments, LegionCommands};
 
 fn main() {
     let selections = &["Ice Cream", "Vanilla Cupcake", "Chocolate Muffin", "A Pile of sweet, sweet mustard"];

projects/legion-cli/src/tools/mod.rs

@@ -18,16 +18,7 @@
 
 //
 //     fn wasm_decode(input: Vec<u8>, config: DecodeConfig) -> Result<String, ToolsError> {
-//         let mut parser = wasmprinter::Config::new();
-//         parser.name_unnamed(true);
-//         parser.print_offsets(false);
-//         parser.print_skeleton(config.skeleton_only);
-//         parser.indent_text(config.indent_text);
-//         // parser.name_unnamed(config.indent_text);
-//         parser.fold_instructions(config.fold_instructions);
-//         let mut dst = String::new();
-//         parser.print(&input, &mut PrintFmtWrite(&mut dst))?;
-//         Ok(dst)
+
 //     }
 //
 //     fn wasi_polyfill(input: Vec<u8>, config: PolyfillConfig) -> Result<Vec<(String, Vec<u8>)>, ToolsError> {