add support for repeated flags

If a flag is defined with 'mutiple()' - we collect the flag repeatly.
I have extened the `Context` with functioin to fetch all occurence
of a flag. E.g. `string_flag_vec` which return a Vector of
`Result<String, FlagError>` similar with the other flag types.

Author: jhilmer

src/context.rs

@@ -21,21 +21,31 @@ impl Context {
         let flags_val = match flags {
             Some(flags) => {
                 for flag in flags {
-                    if let Some(index) = flag.option_index(&parsed_args) {
-                        parsed_args.remove(index);
+                    let mut found_flag = false;
+                    loop {
+                        if let Some(index) = flag.option_index(&parsed_args) {
+                            found_flag = true;
+                            parsed_args.remove(index);
 
-                        let val = if flag.flag_type != FlagType::Bool {
-                            if parsed_args.len() <= index {
-                                None
+                            let val = if flag.flag_type != FlagType::Bool {
+                                if parsed_args.len() <= index {
+                                    None
+                                } else {
+                                    Some(parsed_args.remove(index))
+                                }
                             } else {
-                                Some(parsed_args.remove(index))
+                                None
+                            };
+                            v.push((flag.name.to_string(), flag.value(val)));
+                            if !flag.multiple {
+                                break;
                             }
                         } else {
-                            None
-                        };
-                        v.push((flag.name.to_string(), flag.value(val)))
-                    } else {
-                        v.push((flag.name.to_string(), Err(FlagError::NotFound)))
+                            if !found_flag {
+                                v.push((flag.name.to_string(), Err(FlagError::NotFound)));
+                            }
+                            break;
+                        }
                     }
                 }
                 Some(v)
@@ -66,6 +76,15 @@ impl Context {
         }
     }
 
+    // Get flag values for repeated flags
+    fn result_flag_value_vec(&self, name: &str) -> Vec::<Result<FlagValue, FlagError>> {
+        self.flags.as_ref().unwrap().iter().filter(|flag| flag.0 == name)
+            .map(|f| match &f.1 {
+            Ok(val) => Ok(val.to_owned()),
+            Err(e) => Err(e.to_owned()),
+        }).collect::<Vec<_>>()
+    }
+
     /// Get bool flag
     ///
     /// Example
@@ -111,6 +130,34 @@ impl Context {
         }
     }
 
+    /// Get string flags for repeated flags
+    ///
+    /// Example
+    ///
+    /// ```
+    /// use seahorse::Context;
+    ///
+    /// fn action(c: &Context) {
+    ///    for s in c.string_flag_vec("string") {
+    ///       match s {
+    ///          Ok(s) => println!("{}", s),
+    ///         Err(e) => println!("{}", e)
+    ///      }
+    ///   }
+    /// }
+    /// ```
+    pub fn string_flag_vec(&self, name: &str) -> Vec<Result<String, FlagError>> {
+        let r = self.result_flag_value_vec(name);
+
+        r.iter().map(|r|
+        {
+            match r {
+                Ok(FlagValue::String(val)) => Ok(val.clone()),
+                _ => Err(FlagError::TypeError),
+            }
+        }).collect::<Vec<_>>()
+    }
+
     /// Get int flag
     ///
     /// Example
@@ -133,6 +180,34 @@ impl Context {
         }
     }
 
+    /// Get int flags for repeated flags
+    ///
+    /// Example
+    ///
+    /// ```
+    /// use seahorse::Context;
+    ///
+    /// fn action(c: &Context) {
+    ///     for i in c.int_flag_vec("int") {
+    ///         match i {
+    ///             Ok(i) => println!("{}", i),
+    ///            Err(e) => println!("{}", e)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub fn int_flag_vec(&self, name: &str) -> Vec<Result<isize, FlagError>> {
+        let r = self.result_flag_value_vec(name);
+
+        r.iter().map(|r|
+        {
+            match r {
+                Ok(FlagValue::Int(val)) => Ok(val.clone()),
+                _ => Err(FlagError::TypeError),
+            }
+        }).collect::<Vec<_>>()
+    }
+
     /// Get Uint flag
     ///
     /// Example
@@ -155,6 +230,34 @@ impl Context {
         }
     }
 
+    /// Get uint flags for repeated flags
+    ///
+    /// Example
+    ///
+    /// ```
+    /// use seahorse::Context;
+    ///
+    /// fn action(c: &Context) {
+    ///     for i in c.uint_flag_vec("uint") {
+    ///         match i {
+    ///             Ok(i) => println!("{}", i),
+    ///            Err(e) => println!("{}", e)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub fn uint_flag_vec(&self, name: &str) -> Vec<Result<usize, FlagError>> {
+        let r = self.result_flag_value_vec(name);
+
+        r.iter().map(|r|
+        {
+            match r {
+                Ok(FlagValue::Uint(val)) => Ok(val.clone()),
+                _ => Err(FlagError::TypeError),
+            }
+        }).collect::<Vec<_>>()
+    }
+
     /// Get float flag
     ///
     /// Example
@@ -177,6 +280,36 @@ impl Context {
         }
     }
 
+    /// Get float flags for repeated flags
+    ///
+    /// Example
+    ///
+    /// ```
+    /// use seahorse::Context;
+    ///
+    /// fn action(c: &Context) {
+    ///     for f in c.float_flag_vec("float") {
+    ///         match f {
+    ///             Ok(f) => println!("{}", f),
+    ///            Err(e) => println!("{}", e)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub fn float_flag_vec(&self, name: &str) -> Vec<Result<f64, FlagError>> {
+        let r = self.result_flag_value_vec(name);
+
+        // I would like to map the Result<FlagValue, FlagError> to Result<f64, FlagError>
+
+        r.iter().map(|r|
+        {
+            match *r {
+                Ok(FlagValue::Float(val)) => Ok(val),
+                _ => Err(FlagError::TypeError),
+            }
+        }).collect::<Vec<_>>()
+    }
+
     /// Display help
     ///
     /// Example
@@ -213,6 +346,8 @@ mod tests {
             "1234567654321".to_string(),
             "--float".to_string(),
             "1.23".to_string(),
+            "--float".to_string(),
+            "1.44".to_string(),
             "--invalid_float".to_string(),
             "invalid".to_string(),
         ];
@@ -221,7 +356,7 @@ mod tests {
             Flag::new("string", FlagType::String),
             Flag::new("int", FlagType::Int),
             Flag::new("uint", FlagType::Uint),
-            Flag::new("float", FlagType::Float),
+            Flag::new("float", FlagType::Float).multiple(),
             Flag::new("invalid_float", FlagType::Float),
             Flag::new("not_specified", FlagType::String),
         ];

src/flag.rs

@@ -13,6 +13,8 @@ pub struct Flag {
     pub flag_type: FlagType,
     /// Flag alias
     pub alias: Option<Vec<String>>,
+    /// Multiple occurrence
+    pub multiple: bool,
 }
 
 /// `FlagType` enum
@@ -72,6 +74,7 @@ impl Flag {
             description: None,
             flag_type,
             alias: None,
+            multiple: false,
         }
     }
 
@@ -90,6 +93,21 @@ impl Flag {
         self
     }
 
+    /// Set multiple flag
+    ///
+    /// Example
+    ///
+    /// ```
+    /// use seahorse::{Flag, FlagType};
+    ///
+    /// let bool_flag = Flag::new("bool", FlagType::Bool)
+    ///    .multiple();
+    /// ```
+    pub fn multiple(mut self) -> Self {
+        self.multiple = true;
+        self
+    }
+
     /// Set alias of the flag
     ///
     /// Example
@@ -284,4 +302,23 @@ mod tests {
             _ => assert!(false),
         }
     }
+
+    #[test]
+    fn multiple_string_flag_test() {
+        let string_flag = Flag::new("string", FlagType::String);
+        let v = vec![
+            "cli".to_string(),
+            "command".to_string(),
+            "args".to_string(),
+            "--string".to_string(),
+            "test".to_string(),
+            "--string".to_string(),
+            "test2".to_string(),
+        ];
+
+        match string_flag.value(Some(v[4].to_owned())) {
+            Ok(FlagValue::String(val)) => assert_eq!("test".to_string(), val),
+            _ => assert!(false),
+        }
+    }
 }