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

   1 // Std
   2 use std::fmt::{Display, Formatter, Result};
   3 use std::rc::Rc;
   4 use std::result::Result as StdResult;
   5
   6 // Third Party
   7 use vec_map::VecMap;
   8
   9 // Internal
  10 use args::{ArgSettings, ArgKind, AnyArg, Base, Switched, Valued, Arg, DispOrder};
  11
  12 #[allow(missing_debug_implementations)]
  13 #[doc(hidden)]
  14 #[derive(Default, Clone)]
  15 pub struct OptBuilder<'n, 'e>
  16     where 'n: 'e
  17 {
  18     pub b: Base<'n, 'e>,
  19     pub s: Switched<'e>,
  20     pub v: Valued<'n, 'e>,
  21 }
  22
  23 impl<'n, 'e> OptBuilder<'n, 'e> {
  24     pub fn new(name: &'n str) -> Self { OptBuilder { b: Base::new(name), ..Default::default() } }
  25
  26     pub fn from_arg(a: &Arg<'n, 'e>, reqs: &mut Vec<&'e str>) -> Self {
  27         // No need to check for .index() as that is handled above
  28         let ob = OptBuilder {
  29             b: Base::from(a),
  30             s: Switched::from(a),
  31             v: Valued::from(a),
  32         };
  33         // If the arg is required, add all it's requirements to master required list
  34         if a.is_set(ArgSettings::Required) {
  35             if let Some(ref areqs) = a.requires {
  36                 reqs.extend_from_slice(areqs);
  37             }
  38         }
  39         ob
  40     }
  41 }
  42
  43 impl<'n, 'e> Display for OptBuilder<'n, 'e> {
  44     fn fmt(&self, f: &mut Formatter) -> Result {
  45         debugln!("fn=fmt");
  46         // Write the name such --long or -l
  47         if let Some(l) = self.s.long {
  48             try!(write!(f, "--{} ", l));
  49         } else {
  50             try!(write!(f, "-{} ", self.s.short.unwrap()));
  51         }
  52
  53         // Write the values such as <name1> <name2>
  54         if let Some(ref vec) = self.v.val_names {
  55             let mut it = vec.iter().peekable();
  56             while let Some((_, val)) = it.next() {
  57                 try!(write!(f, "<{}>", val));
  58                 if it.peek().is_some() {
  59                     try!(write!(f, " "));
  60                 }
  61             }
  62             let num = vec.len();
  63             if self.is_set(ArgSettings::Multiple) && num == 1 {
  64                 try!(write!(f, "..."));
  65             }
  66         } else if let Some(num) = self.v.num_vals {
  67             let mut it = (0..num).peekable();
  68             while let Some(_) = it.next() {
  69                 try!(write!(f, "<{}>", self.b.name));
  70                 if it.peek().is_some() {
  71                     try!(write!(f, " "));
  72                 }
  73             }
  74             if self.is_set(ArgSettings::Multiple) && num == 1 {
  75                 try!(write!(f, "..."));
  76             }
  77         } else {
  78             try!(write!(f,
  79                         "<{}>{}",
  80                         self.b.name,
  81                         if self.is_set(ArgSettings::Multiple) {
  82                             "..."
  83                         } else {
  84                             ""
  85                         }));
  86         }
  87
  88         Ok(())
  89     }
  90 }
  91
  92 impl<'n, 'e> AnyArg<'n, 'e> for OptBuilder<'n, 'e> {
  93     fn name(&self) -> &'n str { self.b.name }
  94     fn id(&self) -> usize { self.b.id }
  95     fn kind(&self) -> ArgKind { ArgKind::Opt }
  96     fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
  97     fn requires(&self) -> Option<&[&'e str]> { self.b.requires.as_ref().map(|o| &o[..]) }
  98     fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
  99     fn required_unless(&self) -> Option<&[&'e str]> { self.b.r_unless.as_ref().map(|o| &o[..]) }
 100     fn val_names(&self) -> Option<&VecMap<&'e str>> { self.v.val_names.as_ref() }
 101     fn is_set(&self, s: ArgSettings) -> bool { self.b.settings.is_set(s) }
 102     fn has_switch(&self) -> bool { true }
 103     fn set(&mut self, s: ArgSettings) { self.b.settings.set(s) }
 104     fn max_vals(&self) -> Option<u64> { self.v.max_vals }
 105     fn num_vals(&self) -> Option<u64> { self.v.num_vals }
 106     fn possible_vals(&self) -> Option<&[&'e str]> { self.v.possible_vals.as_ref().map(|o| &o[..]) }
 107     fn validator(&self) -> Option<&Rc<Fn(String) -> StdResult<(), String>>> {
 108         self.v.validator.as_ref()
 109     }
 110     fn min_vals(&self) -> Option<u64> { self.v.min_vals }
 111     fn short(&self) -> Option<char> { self.s.short }
 112     fn long(&self) -> Option<&'e str> { self.s.long }
 113     fn val_delim(&self) -> Option<char> { self.v.val_delim }
 114     fn takes_value(&self) -> bool { true }
 115     fn help(&self) -> Option<&'e str> { self.b.help }
 116     fn default_val(&self) -> Option<&'n str> { self.v.default_val }
 117     fn longest_filter(&self) -> bool { true }
 118     fn aliases(&self) -> Option<Vec<&'e str>> {
 119         if let Some(ref aliases) = self.s.aliases {
 120             let vis_aliases: Vec<_> = aliases.iter()
 121                 .filter_map(|&(n, v)| if v { Some(n) } else { None })
 122                 .collect();
 123             if vis_aliases.is_empty() {
 124                 None
 125             } else {
 126                 Some(vis_aliases)
 127             }
 128         } else {
 129             None
 130         }
 131     }
 132 }
 133
 134 impl<'n, 'e> DispOrder for OptBuilder<'n, 'e> {
 135     fn disp_ord(&self) -> usize { self.s.disp_ord }
 136 }
 137
 138 #[cfg(test)]
 139 mod test {
 140     use args::settings::ArgSettings;
 141     use super::OptBuilder;
 142     use vec_map::VecMap;
 143
 144     #[test]
 145     fn optbuilder_display1() {
 146         let mut o = OptBuilder::new("opt");
 147         o.s.long = Some("option");
 148         o.b.settings.set(ArgSettings::Multiple);
 149
 150         assert_eq!(&*format!("{}", o), "--option <opt>...");
 151     }
 152
 153     #[test]
 154     fn optbuilder_display2() {
 155         let mut v_names = VecMap::new();
 156         v_names.insert(0, "file");
 157         v_names.insert(1, "name");
 158
 159         let mut o2 = OptBuilder::new("opt");
 160         o2.s.short = Some('o');
 161         o2.v.val_names = Some(v_names);
 162
 163         assert_eq!(&*format!("{}", o2), "-o <file> <name>");
 164     }
 165
 166     #[test]
 167     fn optbuilder_display3() {
 168         let mut v_names = VecMap::new();
 169         v_names.insert(0, "file");
 170         v_names.insert(1, "name");
 171
 172         let mut o2 = OptBuilder::new("opt");
 173         o2.s.short = Some('o');
 174         o2.v.val_names = Some(v_names);
 175         o2.b.settings.set(ArgSettings::Multiple);
 176
 177         assert_eq!(&*format!("{}", o2), "-o <file> <name>");
 178     }
 179
 180     #[test]
 181     fn optbuilder_display_single_alias() {
 182         let mut o = OptBuilder::new("opt");
 183         o.s.long = Some("option");
 184         o.s.aliases = Some(vec![("als", true)]);
 185
 186         assert_eq!(&*format!("{}", o), "--option <opt>");
 187     }
 188
 189     #[test]
 190     fn optbuilder_display_multiple_aliases() {
 191         let mut o = OptBuilder::new("opt");
 192         o.s.long = Some("option");
 193         o.s.aliases =
 194             Some(vec![("als_not_visible", false), ("als2", true), ("als3", true), ("als4", true)]);
 195         assert_eq!(&*format!("{}", o), "--option <opt>");
 196     }
 197 }