Initial implementation of config parser

bpaf_derive/src/attrs.rs

@@ -139,6 +139,8 @@ pub(crate) enum Name {
     Long { name: Option<LitStr>, span: Span },
     /// Enum variable, name must be specified
     Env { name: Box<Expr> },
+    /// Value can also be consumed from a config key
+    Key { name: Option<LitStr>, span: Span },
 }
 
 impl StrictName {
@@ -165,6 +167,18 @@ impl StrictName {
                 None => return Err(Error::new(span, "Can't derive an explicit name for unnamed struct, try adding a name here like long(\"arg\")", ))
             },
             Name::Env { name, .. } => Self::Env { name },
+            Name::Key {
+                name: Some(name),..
+            } => StrictName::Key { name },
+            Name::Key {
+                name: None, span
+            } => match ident {
+                Some(name) => {
+                    let derived_name = &to_kebab_case(&name.to_string());
+                    Self::Key { name: LitStr::new(derived_name, span) }
+                }
+                None => return Err(Error::new(span, "Can't derive an explicit name for unnamed struct, try adding a name here like key(\"name\")", ))
+            },
         })
     }
 }
@@ -174,6 +188,7 @@ pub(crate) enum StrictName {
     Short { name: LitChar },
     Long { name: LitStr },
     Env { name: Box<Expr> },
+    Key { name: LitStr },
 }
 
 impl ToTokens for StrictName {
@@ -182,6 +197,7 @@ impl ToTokens for StrictName {
             StrictName::Short { name } => quote!(short(#name)),
             StrictName::Long { name } => quote!(long(#name)),
             StrictName::Env { name } => quote!(env(#name)),
+            StrictName::Key { name } => quote!(key(#name)),
         }
         .to_tokens(tokens);
     }
@@ -238,6 +254,7 @@ impl ToTokens for PostDecor {
             PostDecor::Hide { .. } => quote!(hide()),
             PostDecor::CustomUsage { usage, .. } => quote!(custom_usage(#usage)),
             PostDecor::HideUsage { .. } => quote!(hide_usage()),
+            PostDecor::Enter { name, .. } => quote!(enter(#name)),
         }
         .to_tokens(tokens);
     }
@@ -323,6 +340,10 @@ pub(crate) enum PostDecor {
     HideUsage {
         span: Span,
     },
+    Enter {
+        name: Box<Expr>,
+        span: Span,
+    },
 }
 impl PostDecor {
     fn span(&self) -> Span {
@@ -339,6 +360,7 @@ impl PostDecor {
             | Self::Guard { span, .. }
             | Self::Hide { span }
             | Self::CustomUsage { span, .. }
+            | Self::Enter { span, .. }
             | Self::HideUsage { span } => *span,
         }
     }
@@ -392,6 +414,13 @@ impl Name {
                 None
             };
             Name::Long { name, span }
+        } else if kw == "key" {
+            let name = if input.peek(token::Paren) {
+                Some(parse_lit_str(input)?)
+            } else {
+                None
+            };
+            Name::Key { name, span }
         } else if kw == "env" {
             let name = parse_expr(input)?;
             Name::Env { name }
@@ -521,6 +550,9 @@ impl PostDecor {
         } else if kw == "custom_usage" {
             let usage = parse_arg(input)?;
             Self::CustomUsage { usage, span }
+        } else if kw == "enter" {
+            let name = parse_expr(input)?;
+            Self::Enter { span, name }
         } else {
             return Ok(None);
         }))

bpaf_derive/src/field_tests.rs

@@ -74,13 +74,25 @@ fn implicit_parser_custom_help() {
 }
 
 #[test]
-fn short_long() {
+fn short_long_key() {
     let input: NamedField = parse_quote! {
-        #[bpaf(short, long)]
+        #[bpaf(short, long, key("num"))]
         number: usize
     };
     let output = quote! {
-        ::bpaf::short('n').long("number").argument::<usize>("ARG")
+        ::bpaf::short('n').long("number").key("num").argument::<usize>("ARG")
+    };
+    assert_eq!(input.to_token_stream().to_string(), output.to_string());
+}
+
+#[test]
+fn just_key() {
+    let input: NamedField = parse_quote! {
+        #[bpaf(key)]
+        number: usize
+    };
+    let output = quote! {
+        ::bpaf::key("number").argument::<usize>("ARG")
     };
     assert_eq!(input.to_token_stream().to_string(), output.to_string());
 }

bpaf_derive/src/top_tests.rs

@@ -46,6 +46,27 @@ fn top_struct_construct() {
     assert_eq!(top.to_token_stream().to_string(), expected.to_string());
 }
 
+#[test]
+fn top_struct_enter() {
+    let top: Top = parse_quote! {
+        #[bpaf(enter("opt"))]
+        struct Opt { #[bpaf(enter("bar"))] verbose: bool }
+    };
+
+    let expected = quote! {
+        fn opt() -> impl ::bpaf::Parser<Opt> {
+            #[allow (unused_imports)]
+            use ::bpaf::Parser;
+            {
+                let verbose = ::bpaf::long("verbose").switch().enter("bar");
+                ::bpaf::construct!(Opt { verbose, })
+            }.enter("opt")
+        }
+    };
+
+    assert_eq!(top.to_token_stream().to_string(), expected.to_string());
+}
+
 #[test]
 fn top_enum_construct() {
     let top: Top = parse_quote! {

src/args.rs

@@ -1,4 +1,4 @@
-use std::ffi::OsString;
+use std::{ffi::OsString, rc::Rc};
 
 pub(crate) use crate::arg::*;
 use crate::{
@@ -37,6 +37,7 @@ pub struct Args<'a> {
     name: Option<String>,
     #[cfg(feature = "autocomplete")]
     c_rev: Option<usize>,
+    config: Option<Rc<dyn crate::config::Config + 'static>>,
 }
 
 impl Args<'_> {
@@ -77,6 +78,12 @@ impl Args<'_> {
         self.name = Some(name.to_owned());
         self
     }
+
+    #[must_use]
+    pub fn with_config(mut self, config: impl crate::config::Config + 'static) -> Self {
+        self.config = Some(Rc::new(config));
+        self
+    }
 }
 
 impl<const N: usize> From<&'static [&'static str; N]> for Args<'_> {
@@ -86,6 +93,7 @@ impl<const N: usize> From<&'static [&'static str; N]> for Args<'_> {
             #[cfg(feature = "autocomplete")]
             c_rev: None,
             name: None,
+            config: None,
         }
     }
 }
@@ -97,6 +105,7 @@ impl<'a> From<&'a [&'a std::ffi::OsStr]> for Args<'a> {
             #[cfg(feature = "autocomplete")]
             c_rev: None,
             name: None,
+            config: None,
         }
     }
 }
@@ -108,6 +117,7 @@ impl<'a> From<&'a [&'a str]> for Args<'a> {
             #[cfg(feature = "autocomplete")]
             c_rev: None,
             name: None,
+            config: None,
         }
     }
 }
@@ -119,6 +129,7 @@ impl<'a> From<&'a [String]> for Args<'a> {
             #[cfg(feature = "autocomplete")]
             c_rev: None,
             name: None,
+            config: None,
         }
     }
 }
@@ -130,6 +141,7 @@ impl<'a> From<&'a [OsString]> for Args<'a> {
             #[cfg(feature = "autocomplete")]
             c_rev: None,
             name: None,
+            config: None,
         }
     }
 }
@@ -150,6 +162,7 @@ impl Args<'_> {
             #[cfg(feature = "autocomplete")]
             c_rev: None,
             name,
+            config: None,
         }
     }
 }
@@ -245,7 +258,7 @@ pub use inner::State;
 mod inner {
     use std::{ops::Range, rc::Rc};
 
-    use crate::{error::Message, Args};
+    use crate::{config::ConfigReader, error::Message, Args};
 
     use super::{split_os_argument, Arg, ArgType, ItemState};
     #[derive(Clone, Debug)]
@@ -278,6 +291,8 @@ mod inner {
         /// scope starts on the right of the first consumed item and might end before the end
         /// of the list, similarly for "commands"
         scope: Range<usize>,
+
+        pub(crate) config: Option<ConfigReader>,
     }
 
     impl State {
@@ -400,6 +415,9 @@ mod inner {
             if let Some(name) = args.name {
                 path.push(name);
             }
+
+            let config = args.config.map(ConfigReader::new);
+
             State {
                 item_state,
                 remaining,
@@ -409,6 +427,7 @@ mod inner {
                 path,
                 #[cfg(feature = "autocomplete")]
                 comp,
+                config,
             }
         }
     }
@@ -472,6 +491,10 @@ mod inner {
             self.remaining
         }
 
+        pub(crate) fn full_len(&self) -> usize {
+            self.remaining + self.config.as_ref().map_or(0, |c| c.unconsumed())
+        }
+
         /// Get an argument from a scope that was not consumed yet
         pub(crate) fn get(&self, ix: usize) -> Option<&Arg> {
             if self.scope.contains(&ix) && self.item_state.get(ix)?.present() {