feat: add custom default values

Author: funbiscuit

embedded-cli-macros/src/command/model.rs

@@ -2,7 +2,7 @@ use convert_case::{Case, Casing};
 use darling::{Error, FromField, FromMeta, FromVariant, Result};
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
-use syn::{Field, Fields, FieldsNamed, FieldsUnnamed, Variant};
+use syn::{Expr, Field, Fields, FieldsNamed, FieldsUnnamed, Variant};
 
 use super::args::{ArgType, TypedArg};
 
@@ -64,9 +64,27 @@ impl FromMeta for ShortName {
     }
 }
 
+#[derive(Debug)]
+enum TypedDefault {
+    Generated,
+    Fixed(Expr),
+}
+
+impl FromMeta for TypedDefault {
+    fn from_expr(value: &Expr) -> Result<Self> {
+        Ok(Self::Fixed(value.clone()))
+    }
+
+    fn from_word() -> Result<Self> {
+        Ok(Self::Generated)
+    }
+}
+
 #[derive(Debug, FromField, Default)]
 #[darling(default, attributes(arg), forward_attrs(allow, doc, cfg))]
 struct ArgAttrs {
+    default_value: Option<String>,
+    default_value_t: Option<TypedDefault>,
     short: Option<ShortName>,
     long: Option<LongName>,
     value_name: Option<String>,
@@ -111,6 +129,7 @@ impl CommandArgType {
 
 pub struct CommandArg {
     pub arg_type: CommandArgType,
+    pub default_value: Option<TokenStream>,
     pub field_name: String,
     pub field_type: TokenStream,
     #[cfg(feature = "help")]
@@ -146,9 +165,9 @@ impl CommandArg {
             LongName::Fixed(name) => name,
         });
         if let Some(long) = &long {
-            if long.chars().any(|c| !c.is_ascii_alphabetic() && c != '-') {
+            if long.chars().any(|c| !c.is_ascii_alphanumeric() && c != '-') {
                 return Err(Error::custom(
-                    "Option name must consist of alphabetic ASCII chars",
+                    "Option name must consist of alphanumeric ASCII chars",
                 ));
             }
         }
@@ -167,8 +186,29 @@ impl CommandArg {
         } else {
             CommandArgType::Positional
         };
+
+        let default_value = match (arg_attrs.default_value, arg_attrs.default_value_t) {
+            (Some(value), None) => Some(quote! {
+                <#field_type as _cli::arguments::FromArgument>::from_arg(#value)?,
+            }),
+            (None, Some(value)) => {
+                let value = match value {
+                    TypedDefault::Generated => quote! { Default::default() },
+                    TypedDefault::Fixed(expr) => quote! { #expr },
+                };
+                Some(quote! { #value })
+            }
+            (None, None) => None,
+            _ => {
+                return Err(Error::custom(
+                    "Only one of default_value or default_value_t is allowed",
+                ))
+            }
+        };
+
         Ok(Self {
             arg_type,
+            default_value,
             field_name,
             field_type,
             #[cfg(feature = "help")]

embedded-cli-macros/src/command/parse.rs

@@ -101,7 +101,7 @@ fn create_arg_parsing(command: &Command) -> (TokenStream, Vec<TokenStream>) {
                 ));
             }
             CommandArgType::Option { long, short } => {
-                arg_default = None;
+                arg_default = arg.default_value.clone();
                 let state = format_ident!(
                     "Expect{}",
                     arg.field_name.from_case(Case::Snake).to_case(Case::Pascal)
@@ -123,7 +123,7 @@ fn create_arg_parsing(command: &Command) -> (TokenStream, Vec<TokenStream>) {
                 ));
             }
             CommandArgType::Positional => {
-                arg_default = None;
+                arg_default = arg.default_value.clone();
                 let parse_value = create_parse_arg_value(ty);
 
                 positional_value_arms.push(quote! {

embedded-cli/tests/cli/defaults.rs

@@ -0,0 +1,87 @@
+use embedded_cli::Command;
+use rstest::rstest;
+
+use crate::impl_convert;
+use crate::wrapper::CliWrapper;
+
+use crate::terminal::assert_terminal;
+
+#[derive(Debug, Clone, Command, PartialEq)]
+enum CliTestCommand<'a> {
+    Cmd {
+        #[arg(long, default_value = "default name")]
+        name: &'a str,
+
+        #[arg(long, default_value = "8")]
+        level: u8,
+
+        #[arg(long, default_value_t = 9)]
+        level2: u8,
+
+        #[arg(long, default_value_t)]
+        level3: u8,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum TestCommand {
+    Cmd {
+        name: String,
+        level: u8,
+        level2: u8,
+        level3: u8,
+    },
+}
+
+impl_convert! {CliTestCommand<'_> => TestCommand, command, {
+    match command {
+        cmd => cmd.into(),
+    }
+}}
+
+impl<'a> From<CliTestCommand<'a>> for TestCommand {
+    fn from(value: CliTestCommand<'a>) -> Self {
+        match value {
+            CliTestCommand::Cmd {
+                name,
+                level,
+                level2,
+                level3,
+            } => Self::Cmd {
+                name: name.to_string(),
+                level,
+                level2,
+                level3,
+            },
+        }
+    }
+}
+
+#[rstest]
+#[case("cmd --name test-name --level 1 --level2 2 --level3 3", TestCommand::Cmd {
+    name: "test-name".to_string(),
+    level: 1,
+    level2: 2,
+    level3: 3,
+})]
+#[case("cmd", TestCommand::Cmd {
+    name: "default name".to_string(),
+    level: 8,
+    level2: 9,
+    level3: 0,
+})]
+fn options_parsing(#[case] command: &str, #[case] expected: TestCommand) {
+    let mut cli = CliWrapper::new();
+
+    cli.process_str(command);
+
+    cli.send_enter();
+
+    assert_terminal!(
+        cli.terminal(),
+        2,
+        vec![format!("$ {}", command), "$".to_string()]
+    );
+
+    assert_eq!(cli.received_commands(), vec![Ok(expected)]);
+}

embedded-cli/tests/cli/main.rs

@@ -5,6 +5,7 @@ mod autocomplete;
 #[cfg(not(feature = "autocomplete"))]
 mod autocomplete_disabled;
 mod base;
+mod defaults;
 #[cfg(feature = "help")]
 mod help_simple;
 #[cfg(feature = "help")]