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

@@ -498,6 +498,7 @@ impl<'a> Help<'a> {
     fn spec_vals(&self, a: &ArgWithDisplay) -> String {
         debugln!("Help::spec_vals: a={}", a);
         let mut spec_vals = vec![];
+        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: {}]",
@@ -507,6 +508,7 @@ impl<'a> Help<'a> {
                                            Format::None(pv.to_string_lossy())
                                        }));
             }
+        }
         if let Some(ref aliases) = a.aliases() {
             debugln!("Help::spec_vals: Found aliases...{:?}", aliases);
             spec_vals.push(format!(" [aliases: {}]",

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

src/args/settings.rs

@@ -19,6 +19,7 @@ bitflags! {
         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::<ArgSettings>().unwrap(),
                    ArgSettings::Last);
+        assert_eq!("hidedefaultvalue".parse::<ArgSettings>().unwrap(),
+                   ArgSettings::HideDefaultValue);
         assert!("hahahaha".parse::<ArgSettings>().is_err());
     }
 }