Parse explicitly in prep for 0.4

epage · epage · commit b3f041829881 · 2023-08-17T15:26:11.000-05:00
diff --git a/gix-actor/src/signature/decode.rs b/gix-actor/src/signature/decode.rs
@@ -26,11 +26,13 @@ pub(crate) mod function {
             identity,
             b" ",
             (|i| {
-                terminated(take_until0(SPACE), take(1usize))(i).and_then(|(i, v)| {
-                    btoi::<SecondsSinceUnixEpoch>(v)
-                        .map(|v| (i, v))
-                        .map_err(|_| winnow::error::ErrMode::from_error_kind(i, winnow::error::ErrorKind::MapRes))
-                })
+                terminated(take_until0(SPACE), take(1usize))
+                    .parse_next(i)
+                    .and_then(|(i, v)| {
+                        btoi::<SecondsSinceUnixEpoch>(v)
+                            .map(|v| (i, v))
+                            .map_err(|_| winnow::error::ErrMode::from_error_kind(i, winnow::error::ErrorKind::MapRes))
+                    })
             })
             .context("<timestamp>"),
             alt((
@@ -39,19 +41,23 @@ pub(crate) mod function {
             ))
             .context("+|-"),
             (|i| {
-                take_while_m_n(2usize, 2, AsChar::is_dec_digit)(i).and_then(|(i, v)| {
-                    btoi::<OffsetInSeconds>(v)
-                        .map(|v| (i, v))
-                        .map_err(|_| winnow::error::ErrMode::from_error_kind(i, winnow::error::ErrorKind::MapRes))
-                })
+                take_while_m_n(2usize, 2, AsChar::is_dec_digit)
+                    .parse_next(i)
+                    .and_then(|(i, v)| {
+                        btoi::<OffsetInSeconds>(v)
+                            .map(|v| (i, v))
+                            .map_err(|_| winnow::error::ErrMode::from_error_kind(i, winnow::error::ErrorKind::MapRes))
+                    })
             })
             .context("HH"),
             (|i| {
-                take_while_m_n(1usize, 2, AsChar::is_dec_digit)(i).and_then(|(i, v)| {
-                    btoi::<OffsetInSeconds>(v)
-                        .map(|v| (i, v))
-                        .map_err(|_| winnow::error::ErrMode::from_error_kind(i, winnow::error::ErrorKind::MapRes))
-                })
+                take_while_m_n(1usize, 2, AsChar::is_dec_digit)
+                    .parse_next(i)
+                    .and_then(|(i, v)| {
+                        btoi::<OffsetInSeconds>(v)
+                            .map(|v| (i, v))
+                            .map_err(|_| winnow::error::ErrMode::from_error_kind(i, winnow::error::ErrorKind::MapRes))
+                    })
             })
             .context("MM"),
         )
diff --git a/gix-object/src/commit/decode.rs b/gix-object/src/commit/decode.rs
@@ -53,7 +53,7 @@ pub fn commit<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
     )))
     .context("<field> <single-line|multi-line>")
     .parse_next(i)?;
-    let (i, message) = terminated(message, eof)(i)?;
+    let (i, message) = terminated(message, eof).parse_next(i)?;
 
     Ok((
         i,
diff --git a/gix-object/src/commit/message/body.rs b/gix-object/src/commit/message/body.rs
@@ -4,8 +4,8 @@ use winnow::{
     bytes::take_until1,
     combinator::eof,
     error::{ErrorKind, ParseError},
+    prelude::*,
     sequence::terminated,
-    IResult,
 };
 
 use crate::{
@@ -33,7 +33,7 @@ pub struct TrailerRef<'a> {
 }
 
 fn parse_single_line_trailer<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], (&'a BStr, &'a BStr), E> {
-    let (value, token) = terminated(take_until1(b":".as_ref()), b": ")(i.trim_end())?;
+    let (value, token) = terminated(take_until1(b":".as_ref()), b": ").parse_next(i.trim_end())?;
     if token.trim_end().len() != token.len() || value.trim_start().len() != value.len() {
         Err(winnow::error::ErrMode::from_error_kind(i, ErrorKind::Fail).cut())
     } else {
@@ -50,13 +50,13 @@ impl<'a> Iterator for Trailers<'a> {
         }
         for line in self.cursor.lines_with_terminator() {
             self.cursor = &self.cursor[line.len()..];
-            if let Some(trailer) =
-                terminated(parse_single_line_trailer::<()>, eof)(line)
-                    .ok()
-                    .map(|(_, (token, value))| TrailerRef {
-                        token: token.trim().as_bstr(),
-                        value: value.trim().as_bstr(),
-                    })
+            if let Some(trailer) = terminated(parse_single_line_trailer::<()>, eof)
+                .parse_next(line)
+                .ok()
+                .map(|(_, (token, value))| TrailerRef {
+                    token: token.trim().as_bstr(),
+                    value: value.trim().as_bstr(),
+                })
             {
                 return Some(trailer);
             }
diff --git a/gix-object/src/commit/message/decode.rs b/gix-object/src/commit/message/decode.rs
@@ -3,14 +3,14 @@ use winnow::{branch::alt, bytes::take_till1, combinator::eof, error::ParseError,
 use crate::bstr::{BStr, ByteSlice};
 
 pub(crate) fn newline<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &'a [u8], E> {
-    alt((b"\r\n", b"\n"))(i)
+    alt((b"\r\n", b"\n")).parse_next(i)
 }
 
 fn subject_and_body<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], (&'a BStr, Option<&'a BStr>), E> {
     let mut c = i;
     let mut consumed_bytes = 0;
     while !c.is_empty() {
-        c = match take_till1::<_, _, E>(|c| c == b'\n' || c == b'\r')(c) {
+        c = match take_till1::<_, _, E>(|c| c == b'\n' || c == b'\r').parse_next(c) {
             Ok((i1, segment)) => {
                 consumed_bytes += segment.len();
                 match (newline::<E>, newline::<E>).parse_next(i1) {
@@ -46,5 +46,8 @@ fn subject_and_body<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8
 
 /// Returns title and body, without separator
 pub fn message(input: &[u8]) -> (&BStr, Option<&BStr>) {
-    terminated(subject_and_body::<()>, eof)(input).expect("cannot fail").1
+    terminated(subject_and_body::<()>, eof)
+        .parse_next(input)
+        .expect("cannot fail")
+        .1
 }
diff --git a/gix-object/src/commit/ref_iter.rs b/gix-object/src/commit/ref_iter.rs
@@ -236,7 +236,7 @@ impl<'a> CommitRefIter<'a> {
                 }
             }
             Message => {
-                let (i, message) = terminated(decode::message, eof)(i)?;
+                let (i, message) = terminated(decode::message, eof).parse_next(i)?;
                 debug_assert!(
                     i.is_empty(),
                     "we should have consumed all data - otherwise iter may go forever"
diff --git a/gix-object/src/parse.rs b/gix-object/src/parse.rs
@@ -6,6 +6,7 @@ use winnow::{
     multi::many1,
     prelude::*,
     sequence::{preceded, terminated},
+    Parser,
 };
 
 use crate::ByteSlice;
@@ -46,16 +47,16 @@ pub(crate) fn any_header_field_multi_line<'a, E: ParseError<&'a [u8]> + ContextE
 pub(crate) fn header_field<'a, T, E: ParseError<&'a [u8]>>(
     i: &'a [u8],
     name: &'static [u8],
-    parse_value: impl FnMut(&'a [u8]) -> IResult<&'a [u8], T, E>,
+    parse_value: impl Parser<&'a [u8], T, E>,
 ) -> IResult<&'a [u8], T, E> {
-    terminated(preceded(terminated(name, SPACE), parse_value), NL)(i)
+    terminated(preceded(terminated(name, SPACE), parse_value), NL).parse_next(i)
 }
 
 pub(crate) fn any_header_field<'a, T, E: ParseError<&'a [u8]>>(
     i: &'a [u8],
-    parse_value: impl FnMut(&'a [u8]) -> IResult<&'a [u8], T, E>,
+    parse_value: impl Parser<&'a [u8], T, E>,
 ) -> IResult<&'a [u8], (&'a [u8], T), E> {
-    terminated((terminated(take_till1(SPACE_OR_NL), SPACE), parse_value), NL)(i)
+    terminated((terminated(take_till1(SPACE_OR_NL), SPACE), parse_value), NL).parse_next(i)
 }
 
 fn is_hex_digit_lc(b: u8) -> bool {
@@ -67,7 +68,8 @@ pub fn hex_hash<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &
         gix_hash::Kind::shortest().len_in_hex(),
         gix_hash::Kind::longest().len_in_hex(),
         is_hex_digit_lc,
-    )(i)
+    )
+    .parse_next(i)
     .map(|(i, hex)| (i, hex.as_bstr()))
 }
 
diff --git a/gix-object/src/tag/decode.rs b/gix-object/src/tag/decode.rs
@@ -28,7 +28,7 @@ pub fn git_tag<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(i: &'a [u8]
     let (i, signature) = opt(|i| parse::header_field(i, b"tagger", parse::signature))
         .context("tagger <signature>")
         .parse_next(i)?;
-    let (i, (message, pgp_signature)) = terminated(message, eof)(i)?;
+    let (i, (message, pgp_signature)) = terminated(message, eof).parse_next(i)?;
     Ok((
         i,
         TagRef {
@@ -49,7 +49,7 @@ pub fn message<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], (&
     if i.is_empty() {
         return Ok((i, (i.as_bstr(), None)));
     }
-    let (i, _) = tag(NL)(i)?;
+    let (i, _) = tag(NL).parse_next(i)?;
     fn all_to_end<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], (&'a [u8], &'a [u8]), E> {
         if i.is_empty() {
             // Empty message. That's OK.
@@ -74,8 +74,9 @@ pub fn message<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], (&
             ),
         ),
         all_to_end,
-    ))(i)?;
-    let (i, _) = opt(NL)(i)?;
+    ))
+    .parse_next(i)?;
+    let (i, _) = opt(NL).parse_next(i)?;
     Ok((
         i,
         (
diff --git a/gix-object/src/tag/ref_iter.rs b/gix-object/src/tag/ref_iter.rs
@@ -98,7 +98,7 @@ impl<'a> TagRefIter<'a> {
                 (i, Token::Tagger(signature))
             }
             Message => {
-                let (i, (message, pgp_signature)) = terminated(decode::message, eof)(i)?;
+                let (i, (message, pgp_signature)) = terminated(decode::message, eof).parse_next(i)?;
                 debug_assert!(
                     i.is_empty(),
                     "we should have consumed all data - otherwise iter may go forever"
diff --git a/gix-object/src/tree/ref_iter.rs b/gix-object/src/tree/ref_iter.rs
@@ -122,9 +122,9 @@ mod decode {
         combinator::eof,
         error::ParseError,
         multi::many0,
+        prelude::*,
         sequence::terminated,
         stream::AsChar,
-        IResult,
     };
 
     use crate::{parse::SPACE, tree, tree::EntryRef, TreeRef};
@@ -161,11 +161,11 @@ mod decode {
     }
 
     pub fn entry<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&[u8], EntryRef<'_>, E> {
-        let (i, mode) = terminated(take_while_m_n(5, 6, AsChar::is_dec_digit), SPACE)(i)?;
+        let (i, mode) = terminated(take_while_m_n(5, 6, AsChar::is_dec_digit), SPACE).parse_next(i)?;
         let mode = tree::EntryMode::try_from(mode)
             .map_err(|invalid| winnow::error::ErrMode::from_error_kind(invalid, winnow::error::ErrorKind::MapRes))?;
-        let (i, filename) = terminated(take_while1(|b| b != NULL[0]), NULL)(i)?;
-        let (i, oid) = take(20u8)(i)?; // TODO: make this compatible with other hash lengths
+        let (i, filename) = terminated(take_while1(|b| b != NULL[0]), NULL).parse_next(i)?;
+        let (i, oid) = take(20u8).parse_next(i)?; // TODO: make this compatible with other hash lengths
 
         Ok((
             i,
@@ -178,7 +178,7 @@ mod decode {
     }
 
     pub fn tree<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], TreeRef<'a>, E> {
-        let (i, entries) = terminated(many0(entry), eof)(i)?;
+        let (i, entries) = terminated(many0(entry), eof).parse_next(i)?;
         Ok((i, TreeRef { entries }))
     }
 }
diff --git a/gix-ref/src/parse.rs b/gix-ref/src/parse.rs
@@ -1,5 +1,5 @@
 use gix_object::bstr::{BStr, ByteSlice};
-use winnow::{branch::alt, bytes::take_while_m_n, error::ParseError, IResult};
+use winnow::{branch::alt, bytes::take_while_m_n, error::ParseError, prelude::*};
 
 fn is_hex_digit_lc(b: u8) -> bool {
     matches!(b, b'0'..=b'9' | b'a'..=b'f')
@@ -13,10 +13,11 @@ pub fn hex_hash<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &
         gix_hash::Kind::shortest().len_in_hex(),
         gix_hash::Kind::longest().len_in_hex(),
         is_hex_digit_lc,
-    )(i)
+    )
+    .parse_next(i)
     .map(|(i, hex)| (i, hex.as_bstr()))
 }
 
 pub fn newline<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &'a [u8], E> {
-    alt((b"\r\n", b"\n"))(i)
+    alt((b"\r\n", b"\n")).parse_next(i)
 }
diff --git a/gix-ref/src/store/file/log/line.rs b/gix-ref/src/store/file/log/line.rs
@@ -127,7 +127,9 @@ pub mod decode {
         if i.is_empty() {
             Ok((&[], i.as_bstr()))
         } else {
-            terminated(take_while0(|c| c != b'\n'), opt(b'\n'))(i).map(|(i, o)| (i, o.as_bstr()))
+            terminated(take_while0(|c| c != b'\n'), opt(b'\n'))
+                .parse_next(i)
+                .map(|(i, o)| (i, o.as_bstr()))
         }
     }
 
diff --git a/gix-ref/src/store/file/loose/reference/decode.rs b/gix-ref/src/store/file/loose/reference/decode.rs
@@ -67,7 +67,7 @@ impl Reference {
 
 fn parse(bytes: &[u8]) -> IResult<&[u8], MaybeUnsafeState> {
     let is_space = |b: u8| b == b' ';
-    if let (path, Some(_ref_prefix)) = opt(terminated("ref: ", take_while0(is_space)))(bytes)? {
+    if let (path, Some(_ref_prefix)) = opt(terminated("ref: ", take_while0(is_space))).parse_next(bytes)? {
         terminated(take_while0(|b| b != b'\r' && b != b'\n'), opt(newline))
             .map(|path| MaybeUnsafeState::UnvalidatedPath(path.into()))
             .parse_next(path)
diff --git a/gix-ref/src/store/packed/decode.rs b/gix-ref/src/store/packed/decode.rs
@@ -50,7 +50,7 @@ pub fn header<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], Header, E>
 where
     E: ParseError<&'a [u8]>,
 {
-    let (rest, traits) = preceded(b"# pack-refs with: ", until_newline)(input)?;
+    let (rest, traits) = preceded(b"# pack-refs with: ", until_newline).parse_next(input)?;
 
     let mut peeled = Peeled::Unspecified;
     let mut sorted = false;
@@ -72,7 +72,7 @@ pub fn reference<'a, E: ParseError<&'a [u8]> + FromExternalError<&'a [u8], crate
 ) -> IResult<&'a [u8], packed::Reference<'a>, E> {
     let (input, (target, name)) =
         (terminated(hex_hash, b" "), until_newline.map_res(TryInto::try_into)).parse_next(input)?;
-    let (rest, object) = opt(delimited(b"^", hex_hash, newline))(input)?;
+    let (rest, object) = opt(delimited(b"^", hex_hash, newline)).parse_next(input)?;
     Ok((rest, packed::Reference { name, target, object }))
 }
 

Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ impl<'a> CommitRefIter<'a> {`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`	`Message => {`
`239`		`- let (i, message) = terminated(decode::message, eof)(i)?;`
	`239`	`+ let (i, message) = terminated(decode::message, eof).parse_next(i)?;`
`240`	`240`	`debug_assert!(`
`241`	`241`	`i.is_empty(),`
`242`	`242`	`"we should have consumed all data - otherwise iter may go forever"`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ impl<'a> TagRefIter<'a> {`
`98`	`98`	`(i, Token::Tagger(signature))`
`99`	`99`	`}`
`100`	`100`	`Message => {`
`101`		`- let (i, (message, pgp_signature)) = terminated(decode::message, eof)(i)?;`
	`101`	`+ let (i, (message, pgp_signature)) = terminated(decode::message, eof).parse_next(i)?;`
`102`	`102`	`debug_assert!(`
`103`	`103`	`i.is_empty(),`
`104`	`104`	`"we should have consumed all data - otherwise iter may go forever"`