Parser refactor.

src/build/app/settings.rs

@@ -225,7 +225,7 @@ pub enum AppSettings {
     /// [`Arg::allow_hyphen_values`]: ./struct.Arg.html#method.allow_hyphen_values
     AllowLeadingHyphen,
 
-    /// Specifies that all arguments override themselves. This is the equivolent to saying the `foo`
+    /// Specifies that all arguments override themselves. This is the equivalent to saying the `foo`
     /// arg using [`Arg::overrides_with("foo")`] for all defined arguments.
     ///
     /// [`Arg::overrides_with("foo")`]: ./struct.Arg.html#method.overrides_with

src/parse/arg_matcher.rs

@@ -8,6 +8,9 @@ use crate::{
     util::Id,
 };
 
+// Third party
+use indexmap::map::Entry;
+
 #[derive(Debug)]
 pub(crate) struct ArgMatcher(pub(crate) ArgMatches);
 
@@ -116,38 +119,63 @@ impl ArgMatcher {
 
     pub(crate) fn inc_occurrence_of(&mut self, arg: &Id) {
         debug!("ArgMatcher::inc_occurrence_of: arg={:?}", arg);
-        let ma = self
-            .entry(arg)
-            .or_insert(MatchedArg::new(ValueType::CommandLine));
+        let ma = self.entry(arg).or_insert(MatchedArg::new());
+        ma.set_ty(ValueType::CommandLine);
         ma.occurs += 1;
     }
 
-    pub(crate) fn add_val_to(&mut self, arg: &Id, val: OsString, ty: ValueType) {
+    pub(crate) fn add_val_to(&mut self, arg: &Id, val: OsString, ty: ValueType, append: bool) {
+        if append {
+            self.append_val_to(arg, val, ty);
+        } else {
+            self.push_val_to(arg, val, ty);
+        }
+    }
+
+    pub(crate) fn push_val_to(&mut self, arg: &Id, val: OsString, ty: ValueType) {
         // We will manually inc occurrences later(for flexibility under
         // specific circumstances, like only add one occurrence for flag
         // when we met: `--flag=one,two`).
-        let ma = self.entry(arg).or_insert(MatchedArg::new(ty));
-        ma.vals.push(val);
+        let ma = self.entry(arg).or_default();
+        ma.set_ty(ty);
+        ma.push_val(val);
+    }
+
+    pub(crate) fn new_val_group(&mut self, arg: &Id) {
+        let ma = self.entry(arg).or_default();
+        ma.new_val_group();
+    }
+
+    pub(crate) fn append_val_to(&mut self, arg: &Id, val: OsString, ty: ValueType) {
+        let ma = self.entry(arg).or_default();
+        ma.set_ty(ty);
+        ma.append_val(val);
     }
 
     pub(crate) fn add_index_to(&mut self, arg: &Id, idx: usize, ty: ValueType) {
-        let ma = self.entry(arg).or_insert(MatchedArg::new(ty));
-        ma.indices.push(idx);
+        let ma = self.entry(arg).or_default();
+        ma.set_ty(ty);
+        ma.push_index(idx);
+    }
+
+    pub(crate) fn arg_have_val(&mut self, arg: &Id) -> bool {
+        matches!(self.entry(arg), Entry::Occupied(_))
     }
 
     pub(crate) fn needs_more_vals(&self, o: &Arg) -> bool {
         debug!("ArgMatcher::needs_more_vals: o={}", o.name);
         if let Some(ma) = self.get(&o.id) {
+            let current_num = ma.num_vals_last_group() as u64;
             if let Some(num) = o.num_vals {
                 debug!("ArgMatcher::needs_more_vals: num_vals...{}", num);
                 return if o.is_set(ArgSettings::MultipleValues) {
-                    ((ma.vals.len() as u64) % num) != 0
+                    (current_num % num) != 0
                 } else {
-                    num != (ma.vals.len() as u64)
+                    num != current_num
                 };
             } else if let Some(num) = o.max_vals {
                 debug!("ArgMatcher::needs_more_vals: max_vals...{}", num);
-                return (ma.vals.len() as u64) < num;
+                return current_num < num;
             } else if o.min_vals.is_some() {
                 debug!("ArgMatcher::needs_more_vals: min_vals...true");
                 return true;

src/parse/matches/arg_matches.rs

@@ -3,7 +3,7 @@ use std::{
     borrow::Cow,
     ffi::{OsStr, OsString},
     fmt::{Debug, Display},
-    iter::{Cloned, Map},
+    iter::{Cloned, Flatten, Map},
     slice::Iter,
     str::FromStr,
 };
@@ -122,7 +122,7 @@ impl ArgMatches {
     /// [`occurrences_of`]: ./struct.ArgMatches.html#method.occurrences_of
     pub fn value_of<T: Key>(&self, id: T) -> Option<&str> {
         if let Some(arg) = self.args.get(&Id::from(id)) {
-            if let Some(v) = arg.vals.get(0) {
+            if let Some(v) = arg.get_val(0) {
                 return Some(v.to_str().expect(INVALID_UTF8));
             }
         }
@@ -159,7 +159,7 @@ impl ArgMatches {
     /// [`Arg::values_of_lossy`]: ./struct.ArgMatches.html#method.values_of_lossy
     pub fn value_of_lossy<T: Key>(&self, id: T) -> Option<Cow<'_, str>> {
         if let Some(arg) = self.args.get(&Id::from(id)) {
-            if let Some(v) = arg.vals.get(0) {
+            if let Some(v) = arg.get_val(0) {
                 return Some(v.to_string_lossy());
             }
         }
@@ -201,7 +201,7 @@ impl ArgMatches {
     pub fn value_of_os<T: Key>(&self, id: T) -> Option<&OsStr> {
         self.args
             .get(&Id::from(id))
-            .and_then(|arg| arg.vals.get(0).map(OsString::as_os_str))
+            .and_then(|arg| arg.get_val(0).map(OsString::as_os_str))
     }
 
     /// Gets a [`Values`] struct which implements [`Iterator`] for values of a specific argument
@@ -234,14 +234,31 @@ impl ArgMatches {
             fn to_str_slice(o: &OsString) -> &str {
                 o.to_str().expect(INVALID_UTF8)
             }
-            let to_str_slice: fn(&OsString) -> &str = to_str_slice; // coerce to fn pointer
 
             Values {
-                iter: arg.vals.iter().map(to_str_slice),
+                iter: arg.vals_flatten().map(to_str_slice),
             }
         })
     }
 
+    /// Placeholder documentation.
+    pub fn grouped_values_of<T: Key>(&self, id: T) -> Option<GroupedValues> {
+        #[allow(clippy::type_complexity)]
+        let arg_values: for<'a> fn(
+            &'a MatchedArg,
+        ) -> Map<
+            Iter<'a, Vec<OsString>>,
+            fn(&Vec<OsString>) -> Vec<&str>,
+        > = |arg| {
+            arg.vals()
+                .map(|g| g.iter().map(|x| x.to_str().expect(INVALID_UTF8)).collect())
+        };
+        self.args
+            .get(&Id::from(id))
+            .map(arg_values)
+            .map(|iter| GroupedValues { iter })
+    }
+
     /// Gets the lossy values of a specific argument. If the option wasn't present at runtime
     /// it returns `None`. A lossy value is one where if it contains invalid UTF-8 code points,
     /// those invalid points will be replaced with `\u{FFFD}`
@@ -268,8 +285,7 @@ impl ArgMatches {
     /// ```
     pub fn values_of_lossy<T: Key>(&self, id: T) -> Option<Vec<String>> {
         self.args.get(&Id::from(id)).map(|arg| {
-            arg.vals
-                .iter()
+            arg.vals_flatten()
                 .map(|v| v.to_string_lossy().into_owned())
                 .collect()
         })
@@ -306,14 +322,13 @@ impl ArgMatches {
     /// [`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
     /// [`OsString`]: https://doc.rust-lang.org/std/ffi/struct.OsString.html
     /// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
-    pub fn values_of_os<'a, T: Key>(&'a self, id: T) -> Option<OsValues<'a>> {
+    pub fn values_of_os<T: Key>(&self, id: T) -> Option<OsValues> {
         fn to_str_slice(o: &OsString) -> &OsStr {
-            &*o
+            o
         }
-        let to_str_slice: fn(&'a OsString) -> &'a OsStr = to_str_slice; // coerce to fn pointer
 
         self.args.get(&Id::from(id)).map(|arg| OsValues {
-            iter: arg.vals.iter().map(to_str_slice),
+            iter: arg.vals_flatten().map(to_str_slice),
         })
     }
 
@@ -717,8 +732,8 @@ impl ArgMatches {
     /// [delimiter]: ./struct.Arg.html#method.value_delimiter
     pub fn index_of<T: Key>(&self, name: T) -> Option<usize> {
         if let Some(arg) = self.args.get(&Id::from(name)) {
-            if let Some(i) = arg.indices.get(0) {
-                return Some(*i);
+            if let Some(i) = arg.get_index(0) {
+                return Some(i);
             }
         }
         None
@@ -799,7 +814,7 @@ impl ArgMatches {
     /// [delimiter]: ./struct.Arg.html#method.value_delimiter
     pub fn indices_of<T: Key>(&self, id: T) -> Option<Indices<'_>> {
         self.args.get(&Id::from(id)).map(|arg| Indices {
-            iter: arg.indices.iter().cloned(),
+            iter: arg.indices(),
         })
     }
 
@@ -988,7 +1003,8 @@ impl ArgMatches {
 #[derive(Clone)]
 #[allow(missing_debug_implementations)]
 pub struct Values<'a> {
-    iter: Map<Iter<'a, OsString>, fn(&'a OsString) -> &'a str>,
+    #[allow(clippy::type_complexity)]
+    iter: Map<Flatten<Iter<'a, Vec<OsString>>>, for<'r> fn(&'r OsString) -> &'r str>,
 }
 
 impl<'a> Iterator for Values<'a> {
@@ -1013,13 +1029,45 @@ impl<'a> ExactSizeIterator for Values<'a> {}
 /// Creates an empty iterator.
 impl<'a> Default for Values<'a> {
     fn default() -> Self {
-        static EMPTY: [OsString; 0] = [];
-        // This is never called because the iterator is empty:
-        fn to_str_slice(_: &OsString) -> &str {
-            unreachable!()
-        }
+        static EMPTY: [Vec<OsString>; 0] = [];
         Values {
-            iter: EMPTY[..].iter().map(to_str_slice),
+            iter: EMPTY[..].iter().flatten().map(|_| unreachable!()),
+        }
+    }
+}
+
+#[derive(Clone)]
+#[allow(missing_debug_implementations)]
+pub struct GroupedValues<'a> {
+    #[allow(clippy::type_complexity)]
+    iter: Map<Iter<'a, Vec<OsString>>, fn(&Vec<OsString>) -> Vec<&str>>,
+}
+
+impl<'a> Iterator for GroupedValues<'a> {
+    type Item = Vec<&'a str>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl<'a> DoubleEndedIterator for GroupedValues<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.iter.next_back()
+    }
+}
+
+impl<'a> ExactSizeIterator for GroupedValues<'a> {}
+
+/// Creates an empty iterator. Used for `unwrap_or_default()`.
+impl<'a> Default for GroupedValues<'a> {
+    fn default() -> Self {
+        static EMPTY: [Vec<OsString>; 0] = [];
+        GroupedValues {
+            iter: EMPTY[..].iter().map(|_| unreachable!()),
         }
     }
 }
@@ -1048,7 +1096,8 @@ impl<'a> Default for Values<'a> {
 #[derive(Clone)]
 #[allow(missing_debug_implementations)]
 pub struct OsValues<'a> {
-    iter: Map<Iter<'a, OsString>, fn(&'a OsString) -> &'a OsStr>,
+    #[allow(clippy::type_complexity)]
+    iter: Map<Flatten<Iter<'a, Vec<OsString>>>, fn(&OsString) -> &OsStr>,
 }
 
 impl<'a> Iterator for OsValues<'a> {
@@ -1073,13 +1122,9 @@ impl<'a> ExactSizeIterator for OsValues<'a> {}
 /// Creates an empty iterator.
 impl Default for OsValues<'_> {
     fn default() -> Self {
-        static EMPTY: [OsString; 0] = [];
-        // This is never called because the iterator is empty:
-        fn to_str_slice(_: &OsString) -> &OsStr {
-            unreachable!()
-        }
+        static EMPTY: [Vec<OsString>; 0] = [];
         OsValues {
-            iter: EMPTY[..].iter().map(to_str_slice),
+            iter: EMPTY[..].iter().flatten().map(|_| unreachable!()),
         }
     }
 }