hidden arguments (closes #14)

derive/src/argument.rs

@@ -19,6 +19,7 @@ pub(crate) struct Argument {
 pub(crate) enum ArgType {
     Option {
         flags: Flags,
+        hidden: bool,
         takes_value: bool,
         default: TokenStream,
     },
@@ -59,6 +60,7 @@ pub(crate) fn parse_argument(v: Variant) -> Option<Argument> {
                 flags: opt.flags,
                 takes_value: field.is_some(),
                 default: default_expr,
+                hidden: opt.hidden,
             }
         }
         ArgAttr::Positional(pos) => {
@@ -113,6 +115,7 @@ pub(crate) fn short_handling(args: &[Argument]) -> TokenStream {
                 ref flags,
                 takes_value,
                 ref default,
+                hidden: _,
             } => (flags, takes_value, default),
             ArgType::Positional { .. } => continue,
         };
@@ -157,6 +160,7 @@ pub(crate) fn long_handling(args: &[Argument], help_flags: &Flags) -> TokenStrea
                 flags,
                 takes_value,
                 ref default,
+                hidden: _,
             } => (flags, takes_value, default),
             ArgType::Positional { .. } => continue,
         };

derive/src/attributes.rs

@@ -32,6 +32,7 @@ enum AttributeArguments {
     File(String),
     Env(String),
     Last,
+    Hidden,
 }
 
 impl AttributeArguments {
@@ -47,6 +48,7 @@ pub(crate) struct OptionAttr {
     pub(crate) flags: Flags,
     pub(crate) parser: Option<Expr>,
     pub(crate) default: Option<Expr>,
+    pub(crate) hidden: bool,
 }
 
 impl OptionAttr {
@@ -58,6 +60,7 @@ impl OptionAttr {
                 AttributeArguments::String(a) => option_attr.flags.add(&a),
                 AttributeArguments::Parser(e) => option_attr.parser = Some(e),
                 AttributeArguments::Default(e) => option_attr.default = Some(e),
+                AttributeArguments::Hidden => option_attr.hidden = true,
                 _ => panic!("Invalid argument"),
             };
         }
@@ -238,9 +241,11 @@ impl Parse for AttributeArguments {
             let name = input.parse::<Ident>()?.to_string();
 
             // Arguments that do not take values
-            if name.as_str() == "last" {
-                return Ok(Self::Last);
-            }
+            match name.as_str() {
+                "last" => return Ok(Self::Last),
+                "hidden" => return Ok(Self::Hidden),
+                _ => {}
+            };
 
             input.parse::<Token![=]>()?;
 

derive/src/help.rs

@@ -57,11 +57,17 @@ pub(crate) fn help_string(
 
     for Argument { arg_type, help, .. } in args {
         match arg_type {
-            ArgType::Option { flags, .. } => {
+            ArgType::Option {
+                flags,
+                hidden: false,
+                ..
+            } => {
                 let flags = flags.format();
                 let renderer = str_to_renderer(help);
                 options.push(quote!((#flags, #renderer)));
             }
+            // Hidden arguments should not show up in --help
+            ArgType::Option { hidden: true, .. } => {}
             ArgType::Positional { .. } => {}
         }
     }

examples/hello_world.rs

@@ -15,6 +15,10 @@ enum Arg {
     /// The **number of times** to `greet`
     #[option("-c N", "--count=N")]
     Count(u8),
+
+    /// This argument is hidden
+    #[option("--hidden", hidden)]
+    Hidden,
 }
 
 #[derive(Default, Options)]