feat(quoting): WithoutQuotingValidator does not have to check len>=0

Many validators states consisted soley of checking if the
token had length > 0, this is now done by the quote_if_needed
algorithm.

Author: rustonaut

src/error.rs

@@ -8,9 +8,39 @@ pub enum CoreError {
     UnquoteableCharQuoted,
     DoesNotStartWithDQuotes,
     DoesNotEndWithDQuotes,
-    InvalidChar
+    InvalidChar,
+    ZeroSizedValue
 }
 
+impl CoreError {
+
+    pub fn id(&self) -> u8 {
+        use self::CoreError::*;
+        match *self {
+            AdvancedFailedAutomaton => 0,
+            QuotedStringAlreadyEnded => 1,
+            UnquoteableCharQuoted => 2,
+            DoesNotStartWithDQuotes => 3,
+            DoesNotEndWithDQuotes => 4,
+            InvalidChar => 5,
+            ZeroSizedValue => 6,
+        }
+    }
+
+    pub fn from_id(id: u8) -> Option<Self> {
+        use self::CoreError::*;
+        Some(match id {
+            0 => AdvancedFailedAutomaton,
+            1 => QuotedStringAlreadyEnded,
+            2 => UnquoteableCharQuoted,
+            3 => DoesNotStartWithDQuotes,
+            4 => DoesNotEndWithDQuotes,
+            5 => InvalidChar,
+            6 => ZeroSizedValue,
+            _ => return None
+        })
+    }
+}
 impl Display for CoreError {
     fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
         fter.write_str(self.description())
@@ -32,7 +62,9 @@ impl StdError for CoreError {
             DoesNotEndWithDQuotes =>
                 "quoted string did not end with \"",
             InvalidChar =>
-                "char can not be represented in a quoted string (without encoding)"
+                "char can not be represented in a quoted string (without encoding)",
+            ZeroSizedValue =>
+                "value had a size of zero chars/bytes but has to have at last one"
         }
     }
 }

src/iter.rs

@@ -2,6 +2,7 @@ use std::str::Chars;
 use std::iter::Iterator;
 use std::cmp::{ PartialEq };
 
+use error::CoreError;
 use spec::{GeneralQSSpec, ScanAutomaton, PartialCodePoint};
 // this import will become unused in future rust versions
 // but won't be removed for now for supporting current
@@ -98,7 +99,7 @@ impl<'s, Impl> ContentChars<'s, Impl>
 impl<'a, Impl> Iterator for ContentChars<'a, Impl>
     where Impl: GeneralQSSpec
 {
-    type Item = Result<char, Impl::Error>;
+    type Item = Result<char, CoreError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {

src/parse.rs

@@ -1,4 +1,5 @@
 use spec::{ScanAutomaton, GeneralQSSpec,  PartialCodePoint};
+use error::CoreError;
 
 /// validates if input is a valid quoted-string
 ///
@@ -54,7 +55,7 @@ pub struct Parsed<'a> {
 /// });
 /// ```
 ///
-pub fn parse<Impl: GeneralQSSpec>(input: &str) -> Result<Parsed, (usize, Impl::Error)> {
+pub fn parse<Impl: GeneralQSSpec>(input: &str) -> Result<Parsed, (usize, CoreError)> {
     let mut automaton = ScanAutomaton::<Impl::Parsing>::new();
 
     for (idx, bch) in input.bytes().enumerate() {

src/quote.rs

@@ -32,7 +32,7 @@ use spec::{
 #[inline]
 pub fn quote<Spec: GeneralQSSpec>(
     input: &str
-) -> Result<String, Spec::Error>
+) -> Result<String, CoreError>
 {
     let mut out = String::with_capacity(input.len()+2);
     out.push('"');
@@ -50,20 +50,14 @@ pub fn quote<Spec: GeneralQSSpec>(
 fn quote_inner<Spec: GeneralQSSpec>(
     input: &str,
     out: &mut String,
-) -> Result<(), Spec::Error>
+) -> Result<(), CoreError>
 {
     use self::QuotingClass::*;
     for ch in input.chars() {
         match Spec::Quoting::classify_for_quoting(PartialCodePoint::from_code_point(ch as u32)) {
             QText => out.push(ch),
             NeedsQuoting => { out.push('\\'); out.push(ch); }
-            Invalid => {
-                let err: <Spec::Quoting as QuotingClassifier>::Error
-                    = CoreError::InvalidChar.into();
-                let err: Spec::Error
-                    = err.into();
-                return Err(err)
-            }
+            Invalid => return Err(CoreError::InvalidChar)
         }
     }
     Ok(())
@@ -97,7 +91,7 @@ fn quote_inner<Spec: GeneralQSSpec>(
 pub fn quote_if_needed<'a, Spec, WQImpl>(
     input: &'a str,
     validator: &mut WQImpl
-) -> Result<Cow<'a, str>, Spec::Error>
+) -> Result<Cow<'a, str>, CoreError>
     where Spec: GeneralQSSpec,
           WQImpl: WithoutQuotingValidator
 {
@@ -109,6 +103,7 @@ pub fn quote_if_needed<'a, Spec, WQImpl>(
             needs_quoting_from = Some(idx);
             break;
         } else {
+            //FIXME check if is this even enabled in the right context
             #[cfg(debug_assertions)]
             {
                 match Spec::Quoting::classify_for_quoting(pcp) {
@@ -123,7 +118,9 @@ pub fn quote_if_needed<'a, Spec, WQImpl>(
     }
 
     let start_quoting_from =
-        if let Some(offset) = needs_quoting_from {
+        if input.len() == 0 {
+            0
+        } else if let Some(offset) = needs_quoting_from {
             offset
         } else {
             return if validator.end() {
@@ -199,7 +196,7 @@ mod test {
         let out = quote_if_needed::<TestSpec, _>("ab def", &mut without_quoting).unwrap();
         let expected: Cow<'static, str> = Cow::Owned("\"ab def\"".into());
         assert_eq!(out, expected);
-        assert!(without_quoting.count >= 3);
+        assert!(without_quoting.count >= 2);
     }
 
     #[test]
@@ -208,7 +205,7 @@ mod test {
         let out = quote_if_needed::<TestSpec, _>("abc..f", &mut without_quoting).unwrap();
         let expected: Cow<'static, str> = Cow::Owned("\"abc..f\"".into());
         assert_eq!(out, expected);
-        assert!(without_quoting.count >= 5);
+        assert!(without_quoting.count >= 4);
     }
 
     #[test]
@@ -220,4 +217,12 @@ mod test {
         assert!(without_quoting.count >= 1);
     }
 
+    #[test]
+    fn quote_if_needed_empty_value() {
+        let mut without_quoting = TestUnquotedValidator::new();
+        let out = quote_if_needed::<TestSpec, _>("", &mut without_quoting).unwrap();
+        let expected: Cow<'static, str> = Cow::Owned("\"\"".into());
+        assert_eq!(out, expected);
+        assert_eq!(without_quoting.count, 0);
+    }
 }

src/spec.rs

@@ -2,15 +2,11 @@ use std::fmt::Debug;
 use error::CoreError;
 
 pub trait GeneralQSSpec: Clone+Debug {
-    type Error:
-        From<<Self::Quoting as QuotingClassifier>::Error>
-        + From<<Self::Parsing as ParsingImpl>::Error>;
     type Quoting: QuotingClassifier;
     type Parsing: ParsingImpl;
 }
 
 pub trait QuotingClassifier {
-    type Error: From<CoreError>;
     fn classify_for_quoting(pcp: PartialCodePoint) -> QuotingClass;
 }
 
@@ -21,8 +17,10 @@ pub enum QuotingClass {
 }
 
 pub trait WithoutQuotingValidator {
+    /// if next returns false, it's state should NOT be modified i.e. calling
+    /// .end() after next(..) returned false corresponds to the input sequence _until_ next(..) was false
     fn next(&mut self, pcp: PartialCodePoint) -> bool;
-    fn end(&mut self) -> bool;
+    fn end(&self) -> bool;
 }
 
 
@@ -38,10 +36,9 @@ pub enum State<T: Copy+Eq+Debug> {
 
 
 pub trait ParsingImpl: Copy+Eq+Debug {
-    type Error: From<CoreError>;
     fn can_be_quoted(bch: PartialCodePoint) -> bool;
-    fn handle_normal_state(bch: PartialCodePoint) -> Result<(State<Self>, bool), Self::Error>;
-    fn advance(&self, _pcp: PartialCodePoint) -> Result<(State<Self>, bool), Self::Error> {
+    fn handle_normal_state(bch: PartialCodePoint) -> Result<(State<Self>, bool), CoreError>;
+    fn advance(&self, _pcp: PartialCodePoint) -> Result<(State<Self>, bool), CoreError> {
         unreachable!("[BUG] custom state is not used, so advance is unreachable")
     }
 }
@@ -64,15 +61,15 @@ impl<Impl> ScanAutomaton<Impl>
         self.state == State::End
     }
 
-    pub fn end(&mut self) -> Result<(), Impl::Error> {
+    pub fn end(&mut self) -> Result<(), CoreError> {
         if self.did_end() {
             Ok(())
         } else {
             Err(CoreError::DoesNotEndWithDQuotes.into())
         }
     }
 
-    pub fn advance(&mut self, pcp: PartialCodePoint) -> Result<bool, Impl::Error> {
+    pub fn advance(&mut self, pcp: PartialCodePoint) -> Result<bool, CoreError> {
         match _advance_scan_automaton(self.state, pcp) {
             Ok((state, emit)) => {
                 self.state = state;
@@ -88,7 +85,7 @@ impl<Impl> ScanAutomaton<Impl>
 }
 
 fn _advance_scan_automaton<Impl: ParsingImpl>(state: State<Impl>, pcp: PartialCodePoint)
-    -> Result<(State<Impl>, bool), Impl::Error>
+    -> Result<(State<Impl>, bool), CoreError>
 {
     use self::State::*;
     let pcp_val = pcp.as_u8();
@@ -97,7 +94,7 @@ fn _advance_scan_automaton<Impl: ParsingImpl>(state: State<Impl>, pcp: PartialCo
             if pcp_val == b'"' {
                 Ok((Normal, false))
             } else {
-                Err(CoreError::DoesNotStartWithDQuotes.into())
+                Err(CoreError::DoesNotStartWithDQuotes)
             }
         }
         Normal => {

src/test_utils.rs

@@ -15,13 +15,11 @@ use error::CoreError;
 pub struct TestSpec;
 
 impl GeneralQSSpec for TestSpec {
-    type Error = CoreError;
     type Quoting = Self;
     type Parsing = TestParsingImpl;
 }
 
 impl QuotingClassifier for TestSpec {
-    type Error = CoreError;
     fn classify_for_quoting(pcp: PartialCodePoint) -> QuotingClass {
         if !is_valid_pcp(pcp) {
             QuotingClass::Invalid
@@ -57,11 +55,10 @@ pub enum TestParsingImpl {
 }
 
 impl ParsingImpl for TestParsingImpl {
-    type Error = CoreError;
     fn can_be_quoted(bch: PartialCodePoint) -> bool {
         is_valid_pcp(bch)
     }
-    fn handle_normal_state(bch: PartialCodePoint) -> Result<(State<Self>, bool), Self::Error> {
+    fn handle_normal_state(bch: PartialCodePoint) -> Result<(State<Self>, bool), CoreError> {
         if bch.as_u8() == b'\n' {
             Ok((State::Custom(TestParsingImpl::StrangeInc(0)), false))
         } else if is_valid_pcp(bch) {
@@ -71,7 +68,7 @@ impl ParsingImpl for TestParsingImpl {
         }
     }
 
-    fn advance(&self, pcp: PartialCodePoint) -> Result<(State<Self>, bool), Self::Error> {
+    fn advance(&self, pcp: PartialCodePoint) -> Result<(State<Self>, bool), CoreError> {
         use self::TestParsingImpl::*;
         let bch = pcp.as_u8();
         match *self {
@@ -120,10 +117,9 @@ impl TestUnquotedValidator {
 
 impl WithoutQuotingValidator for TestUnquotedValidator {
     fn next(&mut self, pcp: PartialCodePoint) -> bool {
-        self.count += 1;
         let bch = pcp.as_u8();
         let lwd = self.last_was_dot;
-        match bch {
+        let res = match bch {
             b'a'...b'z' => {
                 self.last_was_dot = false;
                 true
@@ -133,9 +129,13 @@ impl WithoutQuotingValidator for TestUnquotedValidator {
                 true
             }
             _ => false
+        };
+        if res {
+            self.count += 1;
         }
+        res
     }
-    fn end(&mut self) -> bool {
+    fn end(&self) -> bool {
         self.count == 6 && !self.last_was_dot
     }
 }

src/unquote.rs

@@ -1,4 +1,5 @@
 use spec::{GeneralQSSpec, ScanAutomaton, PartialCodePoint};
+use error::CoreError;
 use std::borrow::Cow;
 
 /// converts a quoted string into it's content
@@ -25,7 +26,7 @@ use std::borrow::Cow;
 ///
 pub fn to_content<'a, Spec: GeneralQSSpec>(
     quoted_string: &'a str
-) -> Result<Cow<'a, str>, Spec::Error>
+) -> Result<Cow<'a, str>, CoreError>
 {
     let mut automaton = ScanAutomaton::<Spec::Parsing>::new();
     let mut continue_copy_from = None;