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

   1 // Std
   2 use std::borrow::Cow;
   3 use std::fmt::{Display, Formatter, Result};
   4 use std::rc::Rc;
   5 use std::result::Result as StdResult;
   6 use std::ffi::{OsStr, OsString};
   7
   8 // Third Party
   9 use vec_map::{self, VecMap};
  10
  11 // Internal
  12 use Arg;
  13 use args::{ArgSettings, Base, Valued, ArgKind, AnyArg, DispOrder};
  14
  15 #[allow(missing_debug_implementations)]
  16 #[doc(hidden)]
  17 #[derive(Clone, Default)]
  18 pub struct PosBuilder<'n, 'e>
  19     where 'n: 'e
  20 {
  21     pub b: Base<'n, 'e>,
  22     pub v: Valued<'n, 'e>,
  23     pub index: u64,
  24 }
  25
  26 impl<'n, 'e> PosBuilder<'n, 'e> {
  27     pub fn new(name: &'n str, idx: u64) -> Self {
  28         PosBuilder {
  29             b: Base::new(name),
  30             index: idx,
  31             ..Default::default()
  32         }
  33     }
  34
  35     pub fn from_arg(a: &Arg<'n, 'e>, idx: u64, reqs: &mut Vec<&'n str>) -> Self {
  36         // Create the Positional Argument Builder with each HashSet = None to only
  37         // allocate
  38         // those that require it
  39         let mut pb = PosBuilder {
  40             b: Base::from(a),
  41             v: Valued::from(a),
  42             index: idx,
  43         };
  44         if a.max_vals.is_some() || a.min_vals.is_some() ||
  45            (a.num_vals.is_some() && a.num_vals.unwrap() > 1) {
  46             pb.b.settings.set(ArgSettings::Multiple);
  47         }
  48         // If the arg is required, add all it's requirements to master required list
  49         if a.is_set(ArgSettings::Required) {
  50             if let Some(ref areqs) = a.requires {
  51                 for name in areqs.iter().filter(|&&(val,_)|val.is_none()).map(|&(_, name)| name) {
  52                     reqs.push(name);
  53                 }
  54             }
  55         }
  56         pb
  57     }
  58
  59     pub fn multiple_str(&self) -> &str {
  60         if self.b.settings.is_set(ArgSettings::Multiple) && self.v.val_names.is_none() {
  61             "..."
  62         } else {
  63             ""
  64         }
  65     }
  66
  67     pub fn name_no_brackets(&self) -> Cow<str> {
  68         if let Some(ref names) = self.v.val_names {
  69             Cow::Owned(names.values()
  70                 .map(|n| format!("<{}>", n))
  71                 .collect::<Vec<_>>()
  72                 .join(" "))
  73         } else {
  74             Cow::Borrowed(self.b.name)
  75         }
  76     }
  77 }
  78
  79 impl<'n, 'e> Display for PosBuilder<'n, 'e> {
  80     fn fmt(&self, f: &mut Formatter) -> Result {
  81         if let Some(ref names) = self.v.val_names {
  82             try!(write!(f,
  83                         "{}",
  84                         names.values()
  85                             .map(|n| format!("<{}>", n))
  86                             .collect::<Vec<_>>()
  87                             .join(" ")));
  88         } else {
  89             try!(write!(f, "<{}>", self.b.name));
  90         }
  91         if self.b.settings.is_set(ArgSettings::Multiple) && self.v.val_names.is_none() {
  92             try!(write!(f, "..."));
  93         }
  94
  95         Ok(())
  96     }
  97 }
  98
  99 impl<'n, 'e> AnyArg<'n, 'e> for PosBuilder<'n, 'e> {
 100     fn name(&self) -> &'n str { self.b.name }
 101     fn id(&self) -> usize { self.b.id }
 102     fn kind(&self) -> ArgKind { ArgKind::Pos }
 103     fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
 104     fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { self.b.requires.as_ref().map(|o| &o[..]) }
 105     fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
 106     fn required_unless(&self) -> Option<&[&'e str]> { self.b.r_unless.as_ref().map(|o| &o[..]) }
 107     fn val_names(&self) -> Option<&VecMap<&'e str>> { self.v.val_names.as_ref() }
 108     fn is_set(&self, s: ArgSettings) -> bool { self.b.settings.is_set(s) }
 109     fn set(&mut self, s: ArgSettings) { self.b.settings.set(s) }
 110     fn has_switch(&self) -> bool { false }
 111     fn max_vals(&self) -> Option<u64> { self.v.max_vals }
 112     fn val_terminator(&self) -> Option<&'e str> { self.v.terminator }
 113     fn num_vals(&self) -> Option<u64> { self.v.num_vals }
 114     fn possible_vals(&self) -> Option<&[&'e str]> { self.v.possible_vals.as_ref().map(|o| &o[..]) }
 115     fn validator(&self) -> Option<&Rc<Fn(String) -> StdResult<(), String>>> {
 116         self.v.validator.as_ref()
 117     }
 118     fn validator_os(&self) -> Option<&Rc<Fn(&OsStr) -> StdResult<(), OsString>>> {
 119         self.v.validator_os.as_ref()
 120     }
 121     fn min_vals(&self) -> Option<u64> { self.v.min_vals }
 122     fn short(&self) -> Option<char> { None }
 123     fn long(&self) -> Option<&'e str> { None }
 124     fn val_delim(&self) -> Option<char> { self.v.val_delim }
 125     fn takes_value(&self) -> bool { true }
 126     fn help(&self) -> Option<&'e str> { self.b.help }
 127     fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e str>, &'e str)>> { self.v.default_vals_ifs.as_ref().map(|vm| vm.values()) }
 128     fn default_val(&self) -> Option<&'n str> { self.v.default_val }
 129     fn longest_filter(&self) -> bool { true }
 130     fn aliases(&self) -> Option<Vec<&'e str>> { None }
 131 }
 132
 133 impl<'n, 'e> DispOrder for PosBuilder<'n, 'e> {
 134     fn disp_ord(&self) -> usize { self.index as usize }
 135 }
 136
 137 #[cfg(test)]
 138 mod test {
 139     use args::settings::ArgSettings;
 140     use super::PosBuilder;
 141     use vec_map::VecMap;
 142
 143     #[test]
 144     fn display_mult() {
 145         let mut p = PosBuilder::new("pos", 1);
 146         p.b.settings.set(ArgSettings::Multiple);
 147
 148         assert_eq!(&*format!("{}", p), "<pos>...");
 149     }
 150
 151     #[test]
 152     fn display_required() {
 153         let mut p2 = PosBuilder::new("pos", 1);
 154         p2.b.settings.set(ArgSettings::Required);
 155
 156         assert_eq!(&*format!("{}", p2), "<pos>");
 157     }
 158
 159     #[test]
 160     fn display_val_names() {
 161         let mut p2 = PosBuilder::new("pos", 1);
 162         let mut vm = VecMap::new();
 163         vm.insert(0, "file1");
 164         vm.insert(1, "file2");
 165         p2.v.val_names = Some(vm);
 166
 167         assert_eq!(&*format!("{}", p2), "<file1> <file2>");
 168     }
 169
 170     #[test]
 171     fn display_val_names_req() {
 172         let mut p2 = PosBuilder::new("pos", 1);
 173         p2.b.settings.set(ArgSettings::Required);
 174         let mut vm = VecMap::new();
 175         vm.insert(0, "file1");
 176         vm.insert(1, "file2");
 177         p2.v.val_names = Some(vm);
 178
 179         assert_eq!(&*format!("{}", p2), "<file1> <file2>");
 180     }
 181 }