From 89e6ea861e16a1ad56757ca12f6b32d02253e44a Mon Sep 17 00:00:00 2001 From: CrazyMerlyn Date: Wed, 22 Mar 2017 02:18:54 +0530 Subject: [PATCH] api(Arg::hide_default_value): adds ability to hide the default value of an argument from the help string Adds a new method, `Arg::hide_default_value`, which allows for specifying whether the default value of the argument should be hidden from the help string. Closes #902 --- src/app/help.rs | 18 ++++++++++-------- src/args/arg.rs | 36 +++++++++++++++++++++++++++++++++++- src/args/settings.rs | 39 +++++++++++++++++++++++---------------- 3 files changed, 68 insertions(+), 25 deletions(-) diff --git a/src/app/help.rs b/src/app/help.rs index 074dfc87b2e..1c5f2152543 100644 --- a/src/app/help.rs +++ b/src/app/help.rs @@ -498,14 +498,16 @@ impl<'a> Help<'a> { fn spec_vals(&self, a: &ArgWithDisplay) -> String { debugln!("Help::spec_vals: a={}", a); let mut spec_vals = vec![]; - if let Some(pv) = a.default_val() { - debugln!("Help::spec_vals: Found default value...[{:?}]", pv); - spec_vals.push(format!(" [default: {}]", - if self.color { - self.cizer.good(pv.to_string_lossy()) - } else { - Format::None(pv.to_string_lossy()) - })); + if !a.is_set(ArgSettings::HideDefaultValue) { + if let Some(pv) = a.default_val() { + debugln!("Help::spec_vals: Found default value...[{:?}]", pv); + spec_vals.push(format!(" [default: {}]", + if self.color { + self.cizer.good(pv.to_string_lossy()) + } else { + Format::None(pv.to_string_lossy()) + })); + } } if let Some(ref aliases) = a.aliases() { debugln!("Help::spec_vals: Found aliases...{:?}", aliases); diff --git a/src/args/arg.rs b/src/args/arg.rs index 8e3734a0e0d..dee6cdd17b0 100644 --- a/src/args/arg.rs +++ b/src/args/arg.rs @@ -1707,6 +1707,40 @@ impl<'a, 'b> Arg<'a, 'b> { } } + /// Specifies if the default value of an argument should be displayed in the help text or + /// not. Defaults to `false` (i.e. show default value) + /// + /// This is useful when default behavior of an arg is explained elsewhere in the help text. + /// + /// # Examples + /// + /// ```rust + /// # use clap::{App, Arg}; + /// Arg::with_name("config") + /// .hide_default_value(true) + /// # ; + /// ``` + /// + /// ```rust + /// # use clap::{App, Arg}; + /// let m = App::new("connect") + /// .arg(Arg::with_name("host") + /// .long("host") + /// .default_value("localhost") + /// .hide_default_value(true)); + /// + /// ``` + /// + /// If we were to run the above program with `--help` the `[default: localhost]` portion of + /// the help text would be omitted. + pub fn hide_default_value(self, hide: bool) -> Self { + if hide { + self.set(ArgSettings::HideDefaultValue) + } else { + self.unset(ArgSettings::HideDefaultValue) + } + } + /// Specifies the index of a positional argument **starting at** 1. /// /// **NOTE:** The index refers to position according to **other positional argument**. It does @@ -3332,4 +3366,4 @@ impl<'n, 'e> PartialEq for Arg<'n, 'e> { fn eq(&self, other: &Arg<'n, 'e>) -> bool { self.b == other.b } -} \ No newline at end of file +} diff --git a/src/args/settings.rs b/src/args/settings.rs index 82d36f57899..347946eedb4 100644 --- a/src/args/settings.rs +++ b/src/args/settings.rs @@ -4,21 +4,22 @@ use std::str::FromStr; bitflags! { flags Flags: u16 { - const REQUIRED = 1 << 0, - const MULTIPLE = 1 << 1, - const EMPTY_VALS = 1 << 2, - const GLOBAL = 1 << 3, - const HIDDEN = 1 << 4, - const TAKES_VAL = 1 << 5, - const USE_DELIM = 1 << 6, - const NEXT_LINE_HELP = 1 << 7, - const R_UNLESS_ALL = 1 << 8, - const REQ_DELIM = 1 << 9, - const DELIM_NOT_SET = 1 << 10, - const HIDE_POS_VALS = 1 << 11, - const ALLOW_TAC_VALS = 1 << 12, - const REQUIRE_EQUALS = 1 << 13, - const LAST = 1 << 14, + const REQUIRED = 1 << 0, + const MULTIPLE = 1 << 1, + const EMPTY_VALS = 1 << 2, + const GLOBAL = 1 << 3, + const HIDDEN = 1 << 4, + const TAKES_VAL = 1 << 5, + const USE_DELIM = 1 << 6, + const NEXT_LINE_HELP = 1 << 7, + const R_UNLESS_ALL = 1 << 8, + const REQ_DELIM = 1 << 9, + const DELIM_NOT_SET = 1 << 10, + const HIDE_POS_VALS = 1 << 11, + const ALLOW_TAC_VALS = 1 << 12, + const REQUIRE_EQUALS = 1 << 13, + const LAST = 1 << 14, + const HIDE_DEFAULT_VAL = 1 << 15, } } @@ -44,7 +45,8 @@ impl ArgFlags { HidePossibleValues => HIDE_POS_VALS, AllowLeadingHyphen => ALLOW_TAC_VALS, RequireEquals => REQUIRE_EQUALS, - Last => LAST + Last => LAST, + HideDefaultValue => HIDE_DEFAULT_VAL } } @@ -87,6 +89,8 @@ pub enum ArgSettings { /// Specifies that the arg is the last positional argument and may be accessed early via `--` /// syntax Last, + /// Hides the default value from the help string + HideDefaultValue, #[doc(hidden)] RequiredUnlessAll, #[doc(hidden)] @@ -112,6 +116,7 @@ impl FromStr for ArgSettings { "allowleadinghyphen" => Ok(ArgSettings::AllowLeadingHyphen), "requireequals" => Ok(ArgSettings::RequireEquals), "last" => Ok(ArgSettings::Last), + "hidedefaultvalue" => Ok(ArgSettings::HideDefaultValue), _ => Err("unknown ArgSetting, cannot convert from str".to_owned()), } } @@ -153,6 +158,8 @@ mod test { ArgSettings::RequireEquals); assert_eq!("last".parse::().unwrap(), ArgSettings::Last); + assert_eq!("hidedefaultvalue".parse::().unwrap(), + ArgSettings::HideDefaultValue); assert!("hahahaha".parse::().is_err()); } }