Add argument parser module with picker API

1 files changed, 95 insertions, 0 deletions

diff --git a/mingling/src/parser/args.rs b/mingling/src/parser/args.rs
new file mode 100644
index 0000000..e659feb
--- /dev/null
+++ b/mingling/src/parser/args.rs
@@ -0,0 +1,95 @@
+use mingling_core::{Flag, special_argument, special_flag};
+
+pub struct Argument {
+    vec: Vec<String>,
+}
+
+impl From<&'static str> for Argument {
+    fn from(s: &'static str) -> Self {
+        Argument {
+            vec: vec![s.to_string()],
+        }
+    }
+}
+
+impl From<&'static [&'static str]> for Argument {
+    fn from(slice: &'static [&'static str]) -> Self {
+        Argument {
+            vec: slice.iter().map(|&s| s.to_string()).collect(),
+        }
+    }
+}
+
+impl<const N: usize> From<[&'static str; N]> for Argument {
+    fn from(slice: [&'static str; N]) -> Self {
+        Argument {
+            vec: slice.iter().map(|&s| s.to_string()).collect(),
+        }
+    }
+}
+
+impl<const N: usize> From<&'static [&'static str; N]> for Argument {
+    fn from(slice: &'static [&'static str; N]) -> Self {
+        Argument {
+            vec: slice.iter().map(|&s| s.to_string()).collect(),
+        }
+    }
+}
+
+impl From<Vec<String>> for Argument {
+    fn from(vec: Vec<String>) -> Self {
+        Argument { vec }
+    }
+}
+
+impl AsRef<[String]> for Argument {
+    fn as_ref(&self) -> &[String] {
+        &self.vec
+    }
+}
+
+impl std::ops::Deref for Argument {
+    type Target = Vec<String>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.vec
+    }
+}
+
+impl std::ops::DerefMut for Argument {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.vec
+    }
+}
+
+impl Argument {
+    /// Extracts argument (with value) from arguments
+    pub fn pick_argument<F>(&mut self, flag: F) -> Option<String>
+    where
+        F: Into<Flag>,
+    {
+        let flag: Flag = flag.into();
+        for argument in flag.iter() {
+            let value = special_argument!(self.vec, argument);
+            if value.is_some() {
+                return value;
+            }
+        }
+        None
+    }
+
+    /// Extracts flags from arguments
+    pub fn pick_flag<F>(&mut self, flag: F) -> bool
+    where
+        F: Into<Flag>,
+    {
+        let flag: Flag = flag.into();
+        for argument in flag.iter() {
+            let enabled = special_flag!(self.vec, argument);
+            if enabled {
+                return enabled;
+            }
+        }
+        false
+    }
+}