feat: support for trimming of whitespace around name and email (#364)

It's separated from parsing to assure we can round-trip, but it's
made easy to obtain trimmed results using new methods.

This high-level git-repository will also trim by default now.

Author: Byron

git-actor/Cargo.toml

@@ -22,7 +22,7 @@ local-time-support = ["git-features/time"]
 git-features = { version = "^0.19.1", path = "../git-features", optional = true }
 quick-error = "2.0.0"
 btoi = "0.4.2"
-bstr = { version = "0.2.13", default-features = false, features = ["std"]}
+bstr = { version = "0.2.13", default-features = false, features = ["std", "unicode"]}
 nom = { version = "7", default-features = false, features = ["std"]}
 itoa = "1.0.1"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}

git-actor/src/signature/mod.rs

@@ -1,5 +1,6 @@
 mod _ref {
     use crate::{signature::decode, Signature, SignatureRef};
+    use bstr::ByteSlice;
 
     impl<'a> SignatureRef<'a> {
         /// Deserialize a signature from the given `data`.
@@ -18,6 +19,15 @@ mod _ref {
                 time: self.time,
             }
         }
+
+        /// Trim whitespace surrounding the name and email and return a new signature.
+        pub fn trim(&self) -> SignatureRef<'a> {
+            SignatureRef {
+                name: self.name.trim().as_bstr(),
+                email: self.email.trim().as_bstr(),
+                time: self.time,
+            }
+        }
     }
 }
 

git-actor/tests/signature/mod.rs

@@ -54,12 +54,20 @@ mod write_to {
 use bstr::ByteSlice;
 use git_actor::Signature;
 
+#[test]
+fn trim() {
+    let sig = git_actor::SignatureRef::from_bytes::<()>(b" \t hello there \t < \t email \t > 1 -0030").unwrap();
+    let sig = sig.trim();
+    assert_eq!(sig.name, "hello there");
+    assert_eq!(sig.email, "email");
+}
+
 #[test]
 fn round_trip() -> Result<(), Box<dyn std::error::Error>> {
     for input in &[
         &b"Sebastian Thiel <[email protected]> 1 -0030"[..],
         ".. ☺️Sebastian 王知明 Thiel🙌 .. <[email protected]> 1528473343 +0230".as_bytes(),
-        ".. whitespace  \t  is explicitly allowed    - unicode aware trimming must be done elsewhere <[email protected]> 1528473343 +0230"
+        ".. whitespace  \t  is explicitly allowed    - unicode aware trimming must be done elsewhere  <[email protected]> 1528473343 +0230"
             .as_bytes(),
     ] {
         let signature: Signature = git_actor::SignatureRef::from_bytes::<()>(input)?.into();

git-object/src/commit/mod.rs

@@ -48,6 +48,20 @@ impl<'a> CommitRef<'a> {
         crate::commit::ExtraHeaders::new(self.extra_headers.iter().map(|(k, v)| (*k, v.as_ref())))
     }
 
+    /// Return the author, with whitespace trimmed.
+    ///
+    /// This is different from the `author` field which may contain whitespace.
+    pub fn author(&self) -> git_actor::SignatureRef<'a> {
+        self.author.trim()
+    }
+
+    /// Return the committer, with whitespace trimmed.
+    ///
+    /// This is different from the `committer` field which may contain whitespace.
+    pub fn committer(&self) -> git_actor::SignatureRef<'a> {
+        self.committer.trim()
+    }
+
     /// Returns a partially parsed message from which more information can be derived.
     pub fn message(&self) -> MessageRef<'a> {
         MessageRef::from_bytes(self.message)

git-object/src/commit/ref_iter.rs

@@ -88,6 +88,8 @@ impl<'a> CommitRefIter<'a> {
     }
 
     /// Returns the author signature if there is no decoding error.
+    ///
+    /// It may contain white space surrounding it, and is exactly as parsed.
     /// Errors are coerced into options, hiding whether there was an error or not. The caller knows if there was an error or not.
     pub fn author(mut self) -> Result<git_actor::SignatureRef<'a>, crate::decode::Error> {
         self.find_map(|t| match t {
@@ -99,6 +101,9 @@ impl<'a> CommitRefIter<'a> {
     }
 
     /// Returns the message if there is no decoding error.
+    ///
+    /// It may contain white space surrounding it, and is exactly as
+    //  parsed.
     /// Errors are coerced into options, hiding whether there was an error or not. The caller knows if there was an error or not.
     pub fn message(mut self) -> Result<&'a BStr, crate::decode::Error> {
         self.find_map(|t| match t {

git-object/src/lib.rs

@@ -76,9 +76,13 @@ pub struct CommitRef<'a> {
     pub tree: &'a BStr,
     /// HEX hash of each parent commit. Empty for first commit in repository.
     pub parents: SmallVec<[&'a BStr; 2]>,
-    /// Who wrote this commit.
+    /// Who wrote this commit. Name and email might contain whitespace and are not trimmed to ensure round-tripping.
+    ///
+    /// Use the [`author()`][CommitRef::author()] method to received a trimmed version of it.
     pub author: git_actor::SignatureRef<'a>,
-    /// Who committed this commit.
+    /// Who committed this commit. Name and email might contain whitespace and are not trimmed to ensure round-tripping.
+    ///
+    /// Use the [`committer()`][CommitRef::committer()] method to received a trimmed version of it.
     ///
     /// This may be different from the `author` in case the author couldn't write to the repository themselves and
     /// is commonly encountered with contributed commits.

git-repository/src/object/commit.rs

@@ -76,14 +76,18 @@ impl<'repo> Commit<'repo> {
         git_object::CommitRefIter::from_bytes(&self.data)
     }
 
-    /// Return the commits author.
+    /// Return the commits author, with surrounding whitespace trimmed.
     pub fn author(&self) -> Result<git_actor::SignatureRef<'_>, git_object::decode::Error> {
-        git_object::CommitRefIter::from_bytes(&self.data).author()
+        git_object::CommitRefIter::from_bytes(&self.data)
+            .author()
+            .map(|s| s.trim())
     }
 
-    /// Return the commits committer.
+    /// Return the commits committer. with surrounding whitespace trimmed.
     pub fn committer(&self) -> Result<git_actor::SignatureRef<'_>, git_object::decode::Error> {
-        git_object::CommitRefIter::from_bytes(&self.data).committer()
+        git_object::CommitRefIter::from_bytes(&self.data)
+            .committer()
+            .map(|s| s.trim())
     }
 
     /// Decode this commits parent ids on the fly without allocating.