feat!: `ansi_c::unquote()` returns the amount of consumed bytes. (#301)

That way it's possible to continue parsing past the quoted string.

Sebastian Thiel committed 4 years ago

Commit a052d791 parent 22c776b2 files · +30 −19Browse files

Unified · Split

2 files

git-quote/src/ansi_c.rs +11 −5
git-quote/tests/quote.rs +19 −14

 use bstr::{BStr, BString, ByteSlice};
-/// Unquote the given ansi-c quoted `input` string.
+/// Unquote the given ansi-c quoted `input` string, returning it and all of the consumed bytes.
 ///
 /// The `input` is returned unaltered if it doesn't start with a `"` character to indicate
-/// quotation, otherwise a new unqoted string will always be allocated.
+/// quotation, otherwise a new unquoted string will always be allocated.
+/// The amount of consumed bytes allow to pass strings that start with a quote, and skip all quoted text for additional processing
 ///
 /// See [the tests][tests] for quotation examples.
 ///
 /// [tests]: https://github.com/Byron/gitoxide/blob/e355b4ad133075152312816816af5ce72cf79cff/git-odb/src/alternate/unquote.rs#L110-L118
-pub fn undo(input: &BStr) -> Result<Cow<'_, BStr>, undo::Error> {
+pub fn undo(input: &BStr) -> Result<(Cow<'_, BStr>, usize), undo::Error> {
     if !input.starts_with(b"\"") {
-        return Ok(input.into());
+        return Ok((input.into(), input.len()));
     }
     if input.len() < 2 {
         return Err(undo::Error::new("Input must be surrounded by double quotes", input));
     }
     let original = input.as_bstr();
     let mut input = &input[1..];
+    let mut consumed = 1;
     let mut out = BString::default();
     fn consume_one_past(input: &mut &BStr, position: usize) -> Result<u8, undo::Error> {
         *input = input
         match input.find_byteset(b"\"\\") {
             Some(position) => {
                 out.extend_from_slice(&input[..position]);
+                consumed += position + 1;
                 match input[position] {
                     b'"' => break,
                     b'\\' => {
                         let next = consume_one_past(&mut input, position)?;
+                        consumed += 1;
                         match next {
                             b'n' => out.push(b'\n'),
                             b'r' => out.push(b'\r'),
                                 let byte = btoi::btou_radix(&buf, 8).map_err(|e| undo::Error::new(e, original))?;
                                 out.push(byte);
                                 input = &input[2..];
+                                consumed += 2;
                             }
                             _ => {
                                 return Err(undo::Error::UnsupportedEscapeByte {
             }
             None => {
                 out.extend_from_slice(input);
+                consumed += input.len();
                 break;
             }
         }
     }
-    Ok(out.into())
+    Ok((out.into(), consumed))
 }

git-quote/tests/quote.rs+19−14

         use git_quote::ansi_c;
         macro_rules! test {
-            ($name:ident, $input:literal, $expected:literal) => {
+            ($name:ident, $input:literal, $expected:literal, $consumed:literal) => {
                 #[test]
                 fn $name() {
                     assert_eq!(
                         ansi_c::undo($input.as_bytes().as_bstr()).expect("valid input"),
-                        std::borrow::Cow::Borrowed($expected.as_bytes().as_bstr())
+                        (
+                            std::borrow::Cow::Borrowed($expected.as_bytes().as_bstr()),
+                            $consumed
+                        )
                     );
                 }
             };
         }
-        test!(unquoted_remains_unchanged, "hello", "hello");
+        test!(unquoted_remains_unchanged, "hello", "hello", 5);
-        test!(empty_surrounded_by_quotes, "\"\"", "");
+        test!(empty_surrounded_by_quotes, "\"\"", "", 2);
-        test!(surrounded_only_by_quotes, "\"hello\"", "hello");
+        test!(surrounded_only_by_quotes, "\"hello\"", "hello", 7);
-        test!(typical_escapes, r#""\n\r\t""#, b"\n\r\t");
+        test!(typical_escapes, r#""\n\r\t""#, b"\n\r\t", 8);
-        test!(untypical_escapes, r#""\a\b\f\v""#, b"\x07\x08\x0c\x0b");
+        test!(untypical_escapes, r#""\a\b\f\v""#, b"\x07\x08\x0c\x0b", 10);
-        test!(literal_escape_and_double_quote, r#""\"\\""#, br#""\"#);
+        test!(literal_escape_and_double_quote, r#""\"\\""#, br#""\"#, 6);
         test!(
             unicode_byte_escapes_by_number,
             r#""\346\277\261\351\207\216\t\347\264\224""#,
-            "濱野\t純"
+            "濱野\t純",
+            40
         );
         test!(
             exclamation_and_tilde_survive_an_escape_with_double_escaping,
             r#""\\!\\#hello there/file.ext""#,
-            r"\!\#hello there/file.ext"
+            r"\!\#hello there/file.ext",
+            28
         );
         #[test]
         fn out_of_quote_characters_can_be_passed_and_will_not_be_consumed() {
-            assert_eq!(
+            let input = br#""hello there" out of quote"#.as_bstr();
-                ansi_c::undo(br#""hello there" out of quote"#.as_bstr()).expect("valid input"),
+            let (unquoted, consumed) = ansi_c::undo(input).expect("valid input");
-                std::borrow::Cow::Borrowed(b"hello there".as_bstr())
+            assert_eq!(unquoted, std::borrow::Cow::Borrowed(b"hello there".as_bstr()));
-            );
+            assert_eq!(&input[consumed..], " out of quote");
         }
     }
 }