feat(options): replace options parser with jaarg

Author: azenla

Cargo.lock

@@ -19,6 +19,10 @@ default-features = false
 features = ["png"]
 optional = true
 
+[dependencies.jaarg]
+git = "https://github.com/gay-pizza/jaarg.git"
+rev = "6b4d6d20efd7596121c1a253f276634233b2b53f"
+
 [dependencies.serde]
 version = "1.0.228"
 features = ["derive"]

Cargo.toml

@@ -9,7 +9,6 @@ use crate::context::{RootContext, SproutContext};
 use crate::entries::BootableEntry;
 use crate::integrations::bootloader_interface::{BootloaderInterface, BootloaderInterfaceTimeout};
 use crate::options::SproutOptions;
-use crate::options::parser::OptionsRepresentable;
 use crate::phases::phase;
 use crate::platform::timer::PlatformTimer;
 use crate::platform::tpm::PlatformTpm;

src/main.rs

@@ -1,9 +1,11 @@
-use crate::options::parser::{OptionDescription, OptionForm, OptionsRepresentable};
 use anyhow::{Context, Result, bail};
-use std::collections::BTreeMap;
-
-/// The Sprout options parser.
-pub mod parser;
+use jaarg::std::ParseMapResult;
+use jaarg::{
+    HelpWriter, HelpWriterContext, Opt, Opts, ParseError, StandardFullHelpWriter,
+    StandardShortUsageWriter,
+};
+use log::info;
+use std::process::ExitCode;
 
 /// Default configuration file path.
 const DEFAULT_CONFIG_PATH: &str = "\\sprout.toml";
@@ -36,79 +38,76 @@ impl Default for SproutOptions {
     }
 }
 
-/// The options parser mechanism for Sprout.
-impl OptionsRepresentable for SproutOptions {
-    /// Produce the [SproutOptions] structure.
-    type Output = Self;
-
-    /// All the Sprout options that are defined.
-    fn options() -> &'static [(&'static str, OptionDescription<'static>)] {
-        &[
-            (
-                "autoconfigure",
-                OptionDescription {
-                    description: "Enable Sprout Autoconfiguration",
-                    form: OptionForm::Flag,
-                },
-            ),
-            (
-                "config",
-                OptionDescription {
-                    description: "Path to Sprout configuration file",
-                    form: OptionForm::Value,
-                },
-            ),
-            (
-                "boot",
-                OptionDescription {
-                    description: "Entry to boot, bypassing the menu",
-                    form: OptionForm::Value,
-                },
-            ),
-            (
-                "force-menu",
-                OptionDescription {
-                    description: "Force showing of the boot menu",
-                    form: OptionForm::Flag,
-                },
-            ),
-            (
-                "menu-timeout",
-                OptionDescription {
-                    description: "Boot menu timeout, in seconds",
-                    form: OptionForm::Value,
-                },
-            ),
-            (
-                "help",
-                OptionDescription {
-                    description: "Display Sprout Help",
-                    form: OptionForm::Help,
-                },
-            ),
-        ]
-    }
+/// Sprout options parser.
+impl SproutOptions {
+    /// Parse options with jaarg.
+    pub fn parse() -> Result<Self> {
+        const OPTIONS: Opts<&str> = Opts::new(&[
+            Opt::help_flag("help", &["--help"]).help_text("Display Sprout Help"),
+            Opt::flag("autoconfigure", &["--autoconfigure"])
+                .help_text("Enable Sprout autoconfiguration"),
+            Opt::value("config", &["--config"], "PATH")
+                .help_text("Path to Sprout configuration file"),
+            Opt::value("boot", &["--boot"], "ENTRY").help_text("Entry to boot, bypassing the menu"),
+            Opt::flag("force-menu", &["--force-menu"]).help_text("Force showing the boot menu"),
+            Opt::value("menu-timeout", &["--menu-timeout"], "TIMEOUT")
+                .help_text("Boot menu timeout, in seconds"),
+        ]);
 
-    /// Produces [SproutOptions] from the parsed raw `options` map.
-    fn produce(options: BTreeMap<String, Option<String>>) -> Result<Self> {
-        // Use the default value of sprout options and have the raw options be parsed into it.
-        let mut result = Self::default();
+        // Collect all the arguments to Sprout.
+        // Skip the first argument, which is the path to our executable.
+        let mut args = std::env::args().skip(1).collect::<Vec<_>>();
+
+        // Correct firmware that may add invalid arguments at the start.
+        // Witnessed this on a Dell Precision 5690 when direct booting.
+        loop {
+            // Grab the first argument or break.
+            let Some(arg) = args.first() else {
+                break;
+            };
+
+            // If the argument starts with a tilde, remove it.
+            if arg.starts_with("`") {
+                args.remove(0);
+                continue;
+            }
+            break;
+        }
+
+        // Parse the OPTIONS into a map using jaarg.
+        let parsed = match OPTIONS.parse_map(
+            "sprout",
+            args.iter(),
+            |name| Self::help(&OPTIONS, name),
+            |name, e| Self::error(&OPTIONS, name, e),
+        ) {
+            ParseMapResult::Map(map) => map,
+            ParseMapResult::Exit(ExitCode::SUCCESS) => {
+                std::process::exit(0);
+            }
+
+            ParseMapResult::Exit(ExitCode::FAILURE) => {
+                std::process::exit(1);
+            }
+        };
 
-        for (key, value) in options {
-            match key.as_str() {
+        // Use the default value of sprout OPTIONS and have the raw OPTIONS be parsed into it.
+        let mut result = Self::default();
+        for (key, value) in parsed {
+            match key {
                 "autoconfigure" => {
                     // Enable autoconfiguration.
                     result.autoconfigure = true;
                 }
 
                 "config" => {
                     // The configuration file to load.
-                    result.config = value.context("--config option requires a value")?;
+                    result.config = value;
                 }
 
                 "boot" => {
                     // The entry to boot.
-                    result.boot = Some(value.context("--boot option requires a value")?);
+                    result.boot = Some(value);
                 }
 
                 "force-menu" => {
@@ -118,7 +117,6 @@ impl OptionsRepresentable for SproutOptions {
 
                 "menu-timeout" => {
                     // The timeout for the boot menu in seconds.
-                    let value = value.context("--menu-timeout option requires a value")?;
                     let value = value
                         .parse::<u64>()
                         .context("menu-timeout must be a number")?;
@@ -130,4 +128,22 @@ impl OptionsRepresentable for SproutOptions {
         }
         Ok(result)
     }
+
+    fn help<'a>(options: &'a Opts<&'static str>, program_name: &'a str) {
+        let ctx = HelpWriterContext {
+            options,
+            program_name,
+        };
+        info!("{}", StandardFullHelpWriter::new(ctx));
+    }
+
+    fn error(options: &Opts<&'static str>, program_name: &str, err: ParseError) {
+        info!("{program_name}: {err}");
+        let ctx = HelpWriterContext {
+            options,
+            program_name,
+        };
+        info!("{}", StandardShortUsageWriter::new(ctx));
+        info!("Run 'sprout --help' to view all available options.");
+    }
 }