src/vendor/clap/src/args/arg_builder/flag.rs

   1 // Std
   2 use std::convert::From;
   3 use std::fmt::{Display, Formatter, Result};
   4 use std::rc::Rc;
   5 use std::result::Result as StdResult;
   6
   7 // Third Party
   8 use vec_map::VecMap;
   9
  10 // Internal
  11 use Arg;
  12 use args::{ArgSettings, ArgKind, Base, Switched, AnyArg, DispOrder};
  13
  14 #[derive(Default, Clone, Debug)]
  15 #[doc(hidden)]
  16 pub struct FlagBuilder<'n, 'e>
  17     where 'n: 'e
  18 {
  19     pub b: Base<'n, 'e>,
  20     pub s: Switched<'e>,
  21 }
  22
  23 impl<'n, 'e> FlagBuilder<'n, 'e> {
  24     pub fn new(name: &'n str) -> Self { FlagBuilder { b: Base::new(name), ..Default::default() } }
  25 }
  26
  27 impl<'a, 'b, 'z> From<&'z Arg<'a, 'b>> for FlagBuilder<'a, 'b> {
  28     fn from(a: &'z Arg<'a, 'b>) -> Self {
  29         // No need to check for index() or takes_value() as that is handled above
  30
  31         FlagBuilder {
  32             b: Base::from(a),
  33             s: Switched::from(a),
  34         }
  35     }
  36 }
  37
  38 impl<'n, 'e> Display for FlagBuilder<'n, 'e> {
  39     fn fmt(&self, f: &mut Formatter) -> Result {
  40         if let Some(l) = self.s.long {
  41             try!(write!(f, "--{}", l));
  42         } else {
  43             try!(write!(f, "-{}", self.s.short.unwrap()));
  44         }
  45
  46         Ok(())
  47     }
  48 }
  49
  50 impl<'n, 'e> AnyArg<'n, 'e> for FlagBuilder<'n, 'e> {
  51     fn name(&self) -> &'n str { self.b.name }
  52     fn id(&self) -> usize { self.b.id }
  53     fn kind(&self) -> ArgKind { ArgKind::Flag }
  54     fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
  55     fn requires(&self) -> Option<&[&'e str]> { self.b.requires.as_ref().map(|o| &o[..]) }
  56     fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
  57     fn required_unless(&self) -> Option<&[&'e str]> { None }
  58     fn is_set(&self, s: ArgSettings) -> bool { self.b.settings.is_set(s) }
  59     fn has_switch(&self) -> bool { true }
  60     fn takes_value(&self) -> bool { false }
  61     fn set(&mut self, s: ArgSettings) { self.b.settings.set(s) }
  62     fn max_vals(&self) -> Option<u64> { None }
  63     fn val_names(&self) -> Option<&VecMap<&'e str>> { None }
  64     fn num_vals(&self) -> Option<u64> { None }
  65     fn possible_vals(&self) -> Option<&[&'e str]> { None }
  66     fn validator(&self) -> Option<&Rc<Fn(String) -> StdResult<(), String>>> { None }
  67     fn min_vals(&self) -> Option<u64> { None }
  68     fn short(&self) -> Option<char> { self.s.short }
  69     fn long(&self) -> Option<&'e str> { self.s.long }
  70     fn val_delim(&self) -> Option<char> { None }
  71     fn help(&self) -> Option<&'e str> { self.b.help }
  72     fn default_val(&self) -> Option<&'n str> { None }
  73     fn longest_filter(&self) -> bool { self.s.long.is_some() }
  74     fn aliases(&self) -> Option<Vec<&'e str>> {
  75         if let Some(ref aliases) = self.s.aliases {
  76             let vis_aliases: Vec<_> = aliases.iter()
  77                 .filter_map(|&(n, v)| if v { Some(n) } else { None })
  78                 .collect();
  79             if vis_aliases.is_empty() {
  80                 None
  81             } else {
  82                 Some(vis_aliases)
  83             }
  84         } else {
  85             None
  86         }
  87     }
  88 }
  89
  90 impl<'n, 'e> DispOrder for FlagBuilder<'n, 'e> {
  91     fn disp_ord(&self) -> usize { self.s.disp_ord }
  92 }
  93
  94 #[cfg(test)]
  95 mod test {
  96     use args::settings::ArgSettings;
  97     use super::FlagBuilder;
  98
  99     #[test]
 100     fn flagbuilder_display() {
 101         let mut f = FlagBuilder::new("flg");
 102         f.b.settings.set(ArgSettings::Multiple);
 103         f.s.long = Some("flag");
 104
 105         assert_eq!(&*format!("{}", f), "--flag");
 106
 107         let mut f2 = FlagBuilder::new("flg");
 108         f2.s.short = Some('f');
 109
 110         assert_eq!(&*format!("{}", f2), "-f");
 111     }
 112
 113     #[test]
 114     fn flagbuilder_display_single_alias() {
 115         let mut f = FlagBuilder::new("flg");
 116         f.s.long = Some("flag");
 117         f.s.aliases = Some(vec![("als", true)]);
 118
 119         assert_eq!(&*format!("{}", f), "--flag");
 120     }
 121
 122     #[test]
 123     fn flagbuilder_display_multiple_aliases() {
 124         let mut f = FlagBuilder::new("flg");
 125         f.s.short = Some('f');
 126         f.s.aliases =
 127             Some(vec![("alias_not_visible", false), ("f2", true), ("f3", true), ("f4", true)]);
 128         assert_eq!(&*format!("{}", f), "-f");
 129     }
 130 }