Add -C flag to build command (#734)

* Add `-C` flag to build command

* no-source-compression -> source-compression

* Use enum instead of bool for command in tests

* Use WitOptions in CodegenOptionsGroup

* Make the linter happy

crates/cli/src/commands.rs

@@ -1,5 +1,8 @@
+use anyhow::{anyhow, bail};
 use clap::{Parser, Subcommand};
-use std::path::PathBuf;
+use std::{path::PathBuf, str::FromStr};
+
+use crate::codegen::WitOptions;
 
 #[derive(Debug, Parser)]
 #[command(
@@ -27,24 +30,17 @@ pub enum Command {
     ///
     /// Use the `build` command instead.
     #[command(arg_required_else_help = true)]
-    Compile(CompileAndBuildCommandOpts),
+    Compile(CompileCommandOpts),
     /// Generates WebAssembly from a JavaScript source.
     #[command(arg_required_else_help = true)]
-    Build(CompileAndBuildCommandOpts),
+    Build(BuildCommandOpts),
     /// Emits the provider binary that is required to run dynamically
     /// linked WebAssembly modules.
     EmitProvider(EmitProviderCommandOpts),
 }
 
-impl Command {
-    /// Returns true if it is [`Command::Compile`].
-    pub fn is_compile(&self) -> bool {
-        matches!(self, Command::Compile(_))
-    }
-}
-
 #[derive(Debug, Parser)]
-pub struct CompileAndBuildCommandOpts {
+pub struct CompileCommandOpts {
     #[arg(value_name = "INPUT", required = true)]
     /// Path of the JavaScript input file.
     pub input: PathBuf,
@@ -73,9 +69,117 @@ pub struct CompileAndBuildCommandOpts {
     pub no_source_compression: bool,
 }
 
+#[derive(Debug, Parser)]
+pub struct BuildCommandOpts {
+    #[arg(value_name = "INPUT", required = true)]
+    /// Path of the JavaScript input file.
+    pub input: PathBuf,
+
+    #[arg(short, default_value = "index.wasm")]
+    /// Desired path of the WebAssembly output file.
+    pub output: PathBuf,
+
+    #[arg(
+        short = 'C',
+        long_help = "Available codegen options:
+-C dynamic[=y|n] -- Creates a smaller module that requires a dynamically linked QuickJS provider Wasm module to execute (see `emit-provider` command).
+-C wit=path -- Optional path to WIT file describing exported functions. Only supports function exports with no arguments and no return values.
+-C wit-world=val -- Optional WIT world name for WIT file. Must be specified if WIT is file path is specified.
+-C source-compression[=y|n] -- Enable source code compression, which generates smaller WebAssembly files at the cost of increased compile time. Defaults to enabled.
+    "
+    )]
+    /// Codegen options.
+    pub codegen: Vec<CodegenOption>,
+}
+
 #[derive(Debug, Parser)]
 pub struct EmitProviderCommandOpts {
     #[structopt(short, long)]
     /// Output path for the provider binary (default is stdout).
     pub out: Option<PathBuf>,
 }
+
+pub struct CodegenOptionGroup {
+    /// Creates a smaller module that requires a dynamically linked QuickJS provider Wasm
+    /// module to execute (see `emit-provider` command).
+    pub dynamic: bool,
+    /// The WIT options.
+    pub wit: WitOptions,
+    /// Enable source code compression, which generates smaller WebAssembly files at the cost of increased compile time. Defaults to enabled.
+    pub source_compression: bool,
+}
+
+#[derive(Clone, Debug)]
+pub enum CodegenOption {
+    /// Creates a smaller module that requires a dynamically linked QuickJS provider Wasm
+    /// module to execute (see `emit-provider` command).
+    Dynamic(bool),
+    /// Optional path to WIT file describing exported functions.
+    /// Only supports function exports with no arguments and no return values.
+    Wit(PathBuf),
+    /// Optional path to WIT file describing exported functions.
+    /// Only supports function exports with no arguments and no return values.
+    WitWorld(String),
+    /// Enable source code compression, which generates smaller WebAssembly files at the cost of increased compile time. Defaults to enabled.
+    SourceCompression(bool),
+}
+
+impl FromStr for CodegenOption {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let mut parts = s.splitn(2, '=');
+        let key = parts.next().ok_or_else(|| anyhow!("Invalid codegen key"))?;
+        let value = parts.next();
+        let option = match key {
+            "dynamic" => Self::Dynamic(match value {
+                None => true,
+                Some("y") => true,
+                Some("n") => false,
+                _ => bail!("Invalid value for dynamic"),
+            }),
+            "wit" => Self::Wit(PathBuf::from(
+                value.ok_or_else(|| anyhow!("Must provide value for wit"))?,
+            )),
+            "wit-world" => Self::WitWorld(
+                value
+                    .ok_or_else(|| anyhow!("Must provide value for wit-world"))?
+                    .to_string(),
+            ),
+            "source-compression" => Self::SourceCompression(match value {
+                None => true,
+                Some("y") => true,
+                Some("n") => false,
+                _ => bail!("Invalid value for source-compression"),
+            }),
+            _ => bail!("Invalid codegen key"),
+        };
+        Ok(option)
+    }
+}
+
+impl TryFrom<Vec<CodegenOption>> for CodegenOptionGroup {
+    type Error = anyhow::Error;
+
+    fn try_from(value: Vec<CodegenOption>) -> Result<Self, Self::Error> {
+        let mut dynamic = false;
+        let mut wit = None;
+        let mut wit_world = None;
+        let mut source_compression = true;
+
+        for option in value {
+            match option {
+                CodegenOption::Dynamic(enabled) => dynamic = enabled,
+                CodegenOption::Wit(path) => wit = Some(path),
+                CodegenOption::WitWorld(world) => wit_world = Some(world),
+                CodegenOption::SourceCompression(enabled) => source_compression = enabled,
+            }
+        }
+
+        Ok(Self {
+            dynamic,
+            wit: WitOptions::from_tuple((wit, wit_world))?,
+            source_compression,
+        })
+    }
+}

crates/cli/src/main.rs

@@ -9,6 +9,7 @@ use crate::commands::{Cli, Command, EmitProviderCommandOpts};
 use anyhow::Result;
 use clap::Parser;
 use codegen::CodeGenBuilder;
+use commands::CodegenOptionGroup;
 use js::JS;
 use std::fs;
 use std::fs::File;
@@ -19,10 +20,9 @@ fn main() -> Result<()> {
 
     match &args.command {
         Command::EmitProvider(opts) => emit_provider(opts),
-        c @ Command::Compile(opts) | c @ Command::Build(opts) => {
-            if c.is_compile() {
-                eprintln!(
-                    r#"
+        Command::Compile(opts) => {
+            eprintln!(
+                r#"
                 The `compile` command will be deprecated in the next major
                 release of the CLI (v4.0.0)
 
@@ -31,8 +31,7 @@ fn main() -> Result<()> {
                 
                 Use the `build` command instead.
             "#
-                );
-            }
+            );
 
             let js = JS::from_file(&opts.input)?;
             let mut builder = CodeGenBuilder::new();
@@ -52,6 +51,26 @@ fn main() -> Result<()> {
 
             let wasm = gen.generate(&js)?;
 
+            fs::write(&opts.output, wasm)?;
+            Ok(())
+        }
+        Command::Build(opts) => {
+            let js = JS::from_file(&opts.input)?;
+            let codegen: CodegenOptionGroup = opts.codegen.clone().try_into()?;
+            let mut builder = CodeGenBuilder::new();
+            builder
+                .wit_opts(codegen.wit)
+                .source_compression(codegen.source_compression)
+                .provider_version("2");
+
+            let mut gen = if codegen.dynamic {
+                builder.build::<DynamicGenerator>()?
+            } else {
+                builder.build::<StaticGenerator>()?
+            };
+
+            let wasm = gen.generate(&js)?;
+
             fs::write(&opts.output, wasm)?;
             Ok(())
         }

crates/cli/tests/common/mod.rs

@@ -0,0 +1,11 @@
+use anyhow::Result;
+use javy_runner::{Builder, JavyCommand};
+
+pub fn run_with_compile_and_build<F>(test: F) -> Result<()>
+where
+    F: Fn(&mut Builder) -> Result<()>,
+{
+    test(Builder::default().command(JavyCommand::Compile))?;
+    test(Builder::default().command(JavyCommand::Build))?;
+    Ok(())
+}