Add StringArgumentType

3 files changed, 136 insertions, 17 deletions

diff --git a/src/args.rs b/src/args.rs
index ca35bfb..b3bd7ca 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -134,7 +134,6 @@ impl<T: ArgumentType<S, E> + Send + Sync, S, E> ArgumentTypeAny<S, E> for T {
 
 /// A boolean argument.
 // FIXME add examples/expand docs
-// FIXME add tests
 #[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash, Default)]
 pub struct BoolArgumentType;
 
@@ -324,3 +323,95 @@ where
         Cow::Borrowed(&["0", "1.2", ".5", "-1", "-.5", "-1234.56"])
     }
 }
+
+/// A string argument.
+#[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
+pub struct StringArgumentType(StringMode);
+
+/// Creates a string argument that accepts simple words.
+///
+/// # Examples
+///
+/// ```rust
+/// use ::iosonism::args::word;
+///
+/// let argtype = word();
+/// ```
+pub fn word() -> StringArgumentType {
+    StringArgumentType(StringMode::SingleWord)
+}
+
+/// Creates a string argument that accepts simple words and quoted strings.
+///
+/// # Examples
+///
+/// ```rust
+/// use ::iosonism::args::string;
+///
+/// let argtype = string();
+/// ```
+pub fn string() -> StringArgumentType {
+    StringArgumentType(StringMode::QuotablePhrase)
+}
+
+/// Creates a string argument that accepts simple text until the end of the
+/// input.
+///
+/// # Examples
+///
+/// ```rust
+/// use ::iosonism::args::greedy_string;
+///
+/// let argtype = greedy_string();
+/// ```
+pub fn greedy_string() -> StringArgumentType {
+    StringArgumentType(StringMode::GreedyPhrase)
+}
+
+/// The "mode" of parsing a string.
+#[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
+enum StringMode {
+    SingleWord,
+    QuotablePhrase,
+    GreedyPhrase,
+}
+
+/// An `ArgumentType` for strings.
+impl<S, E> ArgumentType<S, E> for StringArgumentType
+where for<'i> E: ReadError<'i, Cursor<&'i str>> {
+    /// A `StringArgumentType` parses a string.
+    type Result = String;
+
+    /// Attempts to parse a string from the `reader`.
+    fn parse<'i>(
+        &self,
+        reader: &mut Cursor<&'i str>,
+    ) -> Result<String, E> where E: 'i {
+        match self {
+            Self(StringMode::SingleWord) => {
+                Ok(reader.read_unquoted_str().into())
+            },
+            Self(StringMode::QuotablePhrase) => reader.read_string(),
+            Self(StringMode::GreedyPhrase) => {
+                let text = reader.get_remaining().into();
+                reader.set_position(reader.total_len() as u64);
+                Ok(text)
+            },
+        }
+    }
+
+    /// Returns examples
+    fn get_examples(&self) -> Cow<'static, [&str]> {
+        match self {
+            Self(StringMode::SingleWord) => {
+                Cow::Borrowed(&["word", "words_With_underscores"])
+            },
+            Self(StringMode::QuotablePhrase) => {
+                Cow::Borrowed(&["\"quoted phrase\"", "word", "\"\""])
+            },
+            Self(StringMode::GreedyPhrase) => {
+                Cow::Borrowed(&["word", "with spaces", "text \"and symbols\""])
+            },
+        }
+    }
+}
diff --git a/src/strcursor.rs b/src/strcursor.rs
index d733ade..b7c0e5f 100644
--- a/src/strcursor.rs
+++ b/src/strcursor.rs
@@ -18,6 +18,9 @@ use crate::error::ReadError;
 /// `getRemainingLength` (use `get_remaining().len()` or
 /// `remaining_slice().len()`) and `getTotalLength` (use `get_ref().len()`).
 pub trait StringReader<'a>: Sized {
+    /// Returns the total length of the string.
+    //#[inline]
+    fn total_len(&self) -> usize;
     /// Returns the part of the string that has been read so far.
     ///
     /// # Panics
@@ -147,6 +150,10 @@ pub trait StringReader<'a>: Sized {
 
 impl<'a> StringReader<'a> for Cursor<&'a str> {
     #[inline]
+    fn total_len(&self) -> usize {
+        self.get_ref().len()
+    }
+    #[inline]
     fn get_read(&self) -> &'a str {
         &self.get_ref()[..(self.position() as usize)]
     }
@@ -157,7 +164,7 @@ impl<'a> StringReader<'a> for Cursor<&'a str> {
     #[inline]
     fn can_read_n(&self, len: usize) -> bool {
         // NOTE: NOT overflow-aware!
-        self.position() as usize + len <= self.get_ref().len()
+        self.position() as usize + len <= self.total_len()
     }
     #[inline]
     fn peek_n(&self, offset: usize) -> char {
@@ -183,7 +190,7 @@ impl<'a> StringReader<'a> for Cursor<&'a str> {
     where T: FromStr<Err=::std::num::ParseIntError> {
         // see read_unquoted_str for rationale
         let start = self.position() as usize;
-        let total = self.get_ref().len();
+        let total = self.total_len();
         let end = total - {
             self.get_remaining().trim_start_matches(number_chars).len()
         };
@@ -204,7 +211,7 @@ impl<'a> StringReader<'a> for Cursor<&'a str> {
     where T: FromStr<Err=::std::num::ParseFloatError> {
         // see read_unquoted_str for rationale
         let start = self.position() as usize;
-        let total = self.get_ref().len();
+        let total = self.total_len();
         let end = total - {
             self.get_remaining().trim_start_matches(number_chars).len()
         };
@@ -240,7 +247,7 @@ impl<'a> StringReader<'a> for Cursor<&'a str> {
         // there's no easy way to grab start matches, so we have to do something
         // a bit more involved.
         let start = self.position() as usize;
-        let total = self.get_ref().len();
+        let total = self.total_len();
         let end = total - {
             self.get_remaining().trim_start_matches(unquoted_chars).len()
         };
diff --git a/tests/arguments.rs b/tests/arguments.rs
index 55b4a4b..0029998 100644
--- a/tests/arguments.rs
+++ b/tests/arguments.rs
@@ -13,7 +13,10 @@ use ::iosonism::args::BoolArgumentType;
 use ::iosonism::args::bounded_float;
 use ::iosonism::args::bounded_integer;
 use ::iosonism::args::float;
+use ::iosonism::args::greedy_string;
 use ::iosonism::args::integer;
+use ::iosonism::args::string;
+use ::iosonism::args::word;
 use ::iosonism::strcursor::StringReader;
 
 mod common;
@@ -45,10 +48,7 @@ fn test_bool__parse() {
 fn test_i32__parse() {
     let mut reader = Cursor::new("15");
     assert_eq!(
-        ArgumentType::<(), ErrorPanic>::parse(
-            &integer::<i32>(),
-            &mut reader,
-        ),
+        ArgumentType::<(), ErrorPanic>::parse(&integer::<i32>(), &mut reader),
         Ok(15),
     );
     assert!(!reader.can_read());
@@ -74,10 +74,7 @@ fn test_i32__parse__range() {
 fn test_i64__parse() {
     let mut reader = Cursor::new("15");
     assert_eq!(
-        ArgumentType::<(), ErrorPanic>::parse(
-            &integer::<i64>(),
-            &mut reader,
-        ),
+        ArgumentType::<(), ErrorPanic>::parse(&integer::<i64>(), &mut reader),
         Ok(15),
     );
     assert!(!reader.can_read());
@@ -103,10 +100,7 @@ fn test_i64__parse__range() {
 fn test_f32__parse() {
     let mut reader = Cursor::new("15");
     assert_eq!(
-        ArgumentType::<(), ErrorPanic>::parse(
-            &float::<f32>(),
-            &mut reader,
-        ),
+        ArgumentType::<(), ErrorPanic>::parse(&float::<f32>(), &mut reader),
         Ok(15.0),
     );
     assert!(!reader.can_read());
@@ -157,3 +151,30 @@ fn test_f64__parse__range() {
     }
 }
 
+#[test]
+fn test_string__parse__word() {
+    let mut reader = Cursor::new("hello");
+    assert_eq!(
+        ArgumentType::<(), ErrorPanic>::parse(&word(), &mut reader),
+        Ok("hello".into()),
+    );
+}
+
+#[test]
+fn test_string__parse__string() {
+    let mut reader = Cursor::new("\"hello world\"");
+    assert_eq!(
+        ArgumentType::<(), ErrorPanic>::parse(&string(), &mut reader),
+        Ok("hello world".into()),
+    );
+}
+
+#[test]
+fn test_string__parse__greedy_string() {
+    let mut reader = Cursor::new("Hello world! This is a test.");
+    assert_eq!(
+        ArgumentType::<(), ErrorPanic>::parse(&greedy_string(), &mut reader),
+        Ok("Hello world! This is a test.".into()),
+    );
+    assert!(!reader.can_read());
+}