fix!: remove winnow and replace it with hand-implemented parsers everywhere.

Author: Byron

Cargo.lock

@@ -71,10 +71,10 @@ impl ParsedIdentity<'_> {
 
 fn parse_trailer_identity(trailer: gix::objs::commit::message::body::TrailerRef<'_>) -> Option<ParsedIdentity<'_>> {
     match trailer.value {
-        std::borrow::Cow::Borrowed(value) => IdentityRef::from_bytes::<gix::objs::decode::ParseError>(value.as_ref())
+        std::borrow::Cow::Borrowed(value) => IdentityRef::from_bytes(value.as_ref())
             .ok()
             .map(|identity| ParsedIdentity::Borrowed(identity.trim())),
-        std::borrow::Cow::Owned(value) => IdentityRef::from_bytes::<gix::objs::decode::ParseError>(value.as_ref())
+        std::borrow::Cow::Owned(value) => IdentityRef::from_bytes(value.as_ref())
             .ok()
             .map(|identity| ParsedIdentity::Owned(identity.trim().to_owned())),
     }

gitoxide-core/src/hours/mod.rs

@@ -71,7 +71,7 @@ pub fn check(
 
     let mut buf = Vec::new();
     for contact in contacts {
-        let actor = match gix::actor::IdentityRef::from_bytes::<()>(&contact) {
+        let actor = match gix::actor::IdentityRef::from_bytes(&contact) {
             Ok(a) => a,
             Err(_) => {
                 let Some(email) = contact

gitoxide-core/src/repository/mailmap.rs

@@ -4,7 +4,7 @@ use crate::{signature::decode, Identity, IdentityRef};
 
 impl<'a> IdentityRef<'a> {
     /// Deserialize an identity from the given `data`.
-    pub fn from_bytes(mut data: &'a [u8]) -> Result<Self, crate::decode::Error> {
+    pub fn from_bytes(mut data: &'a [u8]) -> Result<Self, gix_error::ValidationError> {
         decode::identity(&mut data)
     }
 

gix-actor/src/decode.rs

@@ -44,8 +44,6 @@ use bstr::{BStr, BString};
 /// For convenience to allow using `gix-date` without adding it to own cargo manifest.
 pub use gix_date as date;
 
-/// Decode actor identities and signatures.
-pub mod decode;
 mod identity;
 ///
 pub mod signature;

gix-actor/src/identity.rs

@@ -1,10 +1,11 @@
 pub(crate) mod function {
     use bstr::ByteSlice;
+    use gix_error::ValidationError;
 
-    use crate::{decode::Error, IdentityRef, SignatureRef};
+    use crate::{IdentityRef, SignatureRef};
 
     /// Parse a signature from the bytes input `i`, and change it to point to the unparsed bytes afterwards.
-    pub fn decode<'a>(i: &mut &'a [u8]) -> Result<SignatureRef<'a>, Error> {
+    pub fn decode<'a>(i: &mut &'a [u8]) -> Result<SignatureRef<'a>, ValidationError> {
         let identity = identity(i)?;
         if i.first() == Some(&b' ') {
             *i = &i[1..];
@@ -25,19 +26,23 @@ pub(crate) mod function {
     }
 
     /// Parse an identity from the bytes input `i` (like `name <email>`).
-    pub fn identity<'a>(i: &mut &'a [u8]) -> Result<IdentityRef<'a>, Error> {
+    pub fn identity<'a>(i: &mut &'a [u8]) -> Result<IdentityRef<'a>, ValidationError> {
         let eol_idx = i.find_byte(b'\n').unwrap_or(i.len());
-        let right_delim_idx = i[..eol_idx].rfind_byte(b'>').ok_or(Error::MissingClosingBracket)?;
+        let right_delim_idx = i[..eol_idx]
+            .rfind_byte(b'>')
+            .ok_or_else(|| ValidationError::new("Closing '>' not found"))?;
         let i_name_and_email = &i[..right_delim_idx];
         let skip_from_right = i_name_and_email.iter().rev().take_while(|b| **b == b'>').count();
-        let left_delim_idx = i_name_and_email.find_byte(b'<').ok_or(Error::MissingOpeningBracket)?;
+        let left_delim_idx = i_name_and_email
+            .find_byte(b'<')
+            .ok_or_else(|| ValidationError::new("Opening '<' not found"))?;
         let skip_from_left = i[left_delim_idx..].iter().take_while(|b| **b == b'<').count();
         let mut name = i[..left_delim_idx].as_bstr();
         name = name.strip_suffix(b" ").unwrap_or(name).as_bstr();
 
         let email = i
             .get(left_delim_idx + skip_from_left..right_delim_idx - skip_from_right)
-            .ok_or(Error::DelimiterOverlap)?
+            .ok_or_else(|| ValidationError::new("Skipped parts run into each other"))?
             .as_bstr();
         *i = i.get(right_delim_idx + 1..).unwrap_or(&[]);
         Ok(IdentityRef { name, email })
@@ -52,9 +57,11 @@ pub use function::identity;
 #[cfg(test)]
 mod tests {
     mod parse_signature {
-        use crate::{decode::Error, signature, SignatureRef};
+        use gix_error::ValidationError;
 
-        fn decode(i: &[u8]) -> Result<(&[u8], SignatureRef<'_>), Error> {
+        use crate::{signature, SignatureRef};
+
+        fn decode(i: &[u8]) -> Result<(&[u8], SignatureRef<'_>), ValidationError> {
             let mut i = i;
             signature::decode(&mut i).map(|signature| (i, signature))
         }
@@ -137,8 +144,10 @@ mod tests {
         #[test]
         fn invalid_signature() {
             assert_eq!(
-                decode(b"hello < 12345 -1215").expect_err("parse fails as > is missing"),
-                Error::MissingClosingBracket
+                decode(b"hello < 12345 -1215")
+                    .expect_err("parse fails as > is missing")
+                    .to_string(),
+                "Closing '>' not found"
             );
         }
 

gix-actor/src/lib.rs

@@ -6,7 +6,7 @@ mod _ref {
     /// Lifecycle
     impl<'a> SignatureRef<'a> {
         /// Deserialize a signature from the given `data`.
-        pub fn from_bytes(mut data: &'a [u8]) -> Result<SignatureRef<'a>, crate::decode::Error> {
+        pub fn from_bytes(mut data: &'a [u8]) -> Result<SignatureRef<'a>, gix_error::ValidationError> {
             decode(&mut data)
         }
 

gix-actor/src/signature/decode.rs

@@ -28,7 +28,6 @@ gix-sec = { version = "^0.13.3", path = "../gix-sec" }
 gix-ref = { version = "^0.62.0", path = "../gix-ref" }
 gix-glob = { version = "^0.25.0", path = "../gix-glob" }
 
-winnow = { version = "1.0.0", features = ["simd"] }
 memchr = "2"
 thiserror = "2.0.18"
 unicode-bom = { version = "2.0.3" }