From 15a7d4ec98c97e058ce7f0ae04131cc0609388cf Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Mon, 27 Sep 2021 21:11:46 +0200
Subject: [PATCH 01/20] Add binding for `git_message_trailers`

---
 libgit2-sys/lib.rs |  23 ++++++
 src/lib.rs         |   2 +-
 src/message.rs     | 184 ++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 207 insertions(+), 2 deletions(-)

diff --git a/libgit2-sys/lib.rs b/libgit2-sys/lib.rs
index 5e277b31ef..648d8ddd53 100644
--- a/libgit2-sys/lib.rs
+++ b/libgit2-sys/lib.rs
@@ -1953,6 +1953,20 @@ git_enum! {
     }
 }
 
+#[repr(C)]
+pub struct git_message_trailer {
+    pub key: *const c_char,
+    pub value: *const c_char,
+}
+
+#[repr(C)]
+#[derive(Copy,Clone)]
+pub struct git_message_trailer_array {
+    pub trailers: *const git_message_trailer,
+    pub count: size_t,
+    pub _trailer_block: *mut c_char,
+}
+
 extern "C" {
     // threads
     pub fn git_libgit2_init() -> c_int;
@@ -3678,6 +3692,15 @@ extern "C" {
         comment_char: c_char,
     ) -> c_int;
 
+    pub fn git_message_trailers(
+        out: *mut git_message_trailer_array,
+        message: *const c_char,
+    ) -> c_int;
+
+    pub fn git_message_trailer_array_free(
+        trailer: *mut git_message_trailer_array,
+    );
+
     // packbuilder
     pub fn git_packbuilder_new(out: *mut *mut git_packbuilder, repo: *mut git_repository) -> c_int;
     pub fn git_packbuilder_set_threads(pb: *mut git_packbuilder, n: c_uint) -> c_uint;
diff --git a/src/lib.rs b/src/lib.rs
index bcabcdf044..d9e4829f9e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -101,7 +101,7 @@ pub use crate::indexer::{IndexerProgress, Progress};
 pub use crate::mailmap::Mailmap;
 pub use crate::mempack::Mempack;
 pub use crate::merge::{AnnotatedCommit, MergeOptions};
-pub use crate::message::{message_prettify, DEFAULT_COMMENT_CHAR};
+pub use crate::message::{message_prettify, DEFAULT_COMMENT_CHAR, message_trailers, MessageTrailers, MessageTrailersIterator};
 pub use crate::note::{Note, Notes};
 pub use crate::object::Object;
 pub use crate::odb::{Odb, OdbObject, OdbPackwriter, OdbReader, OdbWriter};
diff --git a/src/message.rs b/src/message.rs
index 7c17eeffe0..e797a21212 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,4 +1,7 @@
 use std::ffi::CString;
+use std::ffi::CStr;
+use std::ptr;
+use std::marker;
 
 use libc::{c_char, c_int};
 
@@ -28,15 +31,133 @@ fn _message_prettify(message: CString, comment_char: Option<u8>) -> Result<Strin
     Ok(ret.as_str().unwrap().to_string())
 }
 
+/// Collection of trailer key–value pairs.
+///
+/// Use `iter()` to get access to the values.
+pub struct MessageTrailers<'pair> {
+    raw: raw::git_message_trailer_array,
+    _marker: marker::PhantomData<&'pair c_char>,
+}
+
+impl<'pair> MessageTrailers<'pair> {
+    fn new() -> MessageTrailers<'pair> {
+        crate::init();
+        unsafe {
+            Binding::from_raw(&mut raw::git_message_trailer_array {
+                trailers: ptr::null_mut(),
+                count: 0,
+                _trailer_block: ptr::null_mut(),
+            } as *mut _)
+        }
+    }
+    /// Create a borrowed iterator.
+    pub fn iter(&'pair self) -> MessageTrailersIterator<'pair> {
+        MessageTrailersIterator {
+            trailers: self,
+            counter: 0,
+        }
+    }
+    /// The number of trailer key–value pairs.
+    pub fn len(&self) -> usize {
+        self.raw.count
+    }
+}
+
+impl<'pair> Drop for MessageTrailers<'pair> {
+    fn drop(&mut self) {
+        unsafe {
+            raw::git_message_trailer_array_free(&mut self.raw);
+        }
+    }
+}
+
+impl<'pair> Binding for MessageTrailers<'pair> {
+    type Raw = *mut raw::git_message_trailer_array;
+    unsafe fn from_raw(
+        raw: *mut raw::git_message_trailer_array
+    ) -> MessageTrailers<'pair> {
+        MessageTrailers {
+            raw: *raw,
+            _marker: marker::PhantomData,
+        }
+    }
+    fn raw(&self) -> *mut raw::git_message_trailer_array {
+        &self.raw as *const _ as *mut _
+    }
+}
+
+struct Trailer<'pair> {
+    key: *const c_char,
+    value: *const c_char,
+    _marker: marker::PhantomData<&'pair c_char>,
+}
+
+impl<'pair> Trailer<'pair> {
+    fn to_str_tuple(self) -> (&'pair str, &'pair str) {
+        unsafe {
+            let key = CStr::from_ptr(self.key).to_str().unwrap();
+            let value = CStr::from_ptr(self.value).to_str().unwrap();
+            (key, value)
+        }
+    }
+}
+
+/// A borrowed iterator.
+pub struct MessageTrailersIterator<'pair> {
+    trailers: &'pair MessageTrailers<'pair>,
+    counter: usize,
+}
+
+impl<'pair> Iterator for MessageTrailersIterator<'pair> {
+    type Item = (&'pair str, &'pair str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.counter == self.trailers.raw.count {
+            None
+        } else {
+            unsafe {
+                let addr = self.trailers.raw.trailers.wrapping_add(self.counter);
+                self.counter += 1;
+                Some(Trailer {
+                    key: (*addr).key,
+                    value: (*addr).value,
+                    _marker: marker::PhantomData,
+                }.to_str_tuple())
+            }
+        }
+    }
+}
+
+/// Get the trailers for the given message.
+pub fn message_trailers<'pair, S: IntoCString>(
+    message: S
+) -> Result<MessageTrailers<'pair>, Error> {
+    _message_trailers(message.into_c_string()?)
+}
+
+fn _message_trailers<'pair>(
+    message: CString
+) -> Result<MessageTrailers<'pair>, Error> {
+    let ret = MessageTrailers::new();
+    unsafe {
+        try_call!(raw::git_message_trailers(
+            ret.raw(),
+            message
+        ));
+    }
+    Ok(ret)
+}
+
 /// The default comment character for `message_prettify` ('#')
 pub const DEFAULT_COMMENT_CHAR: Option<u8> = Some(b'#');
 
 #[cfg(test)]
 mod tests {
-    use crate::{message_prettify, DEFAULT_COMMENT_CHAR};
 
     #[test]
     fn prettify() {
+        use crate::{message_prettify, DEFAULT_COMMENT_CHAR};
+
         // This does not attempt to duplicate the extensive tests for
         // git_message_prettify in libgit2, just a few representative values to
         // make sure the interface works as expected.
@@ -58,4 +179,65 @@ mod tests {
             "1\n"
         );
     }
+
+    #[test]
+    fn trailers() {
+        use std::collections::HashMap;
+        use crate::{message_trailers, MessageTrailers};
+
+        // no trailers
+        let message1 = "
+WHAT ARE WE HERE FOR
+
+What are we here for?
+
+Just to be eaten?
+";
+        let expected: HashMap<&str, &str> = HashMap::new();
+        assert_eq!(expected, to_map(&message_trailers(message1).unwrap()));
+
+        // standard PSA
+        let message2 = "
+Attention all
+
+We are out of tomatoes.
+
+Spoken-by: Major Turnips
+Transcribed-by: Seargant Persimmons
+Signed-off-by: Colonel Kale
+";
+        let expected: HashMap<&str, &str> = vec![
+            ("Spoken-by", "Major Turnips"),
+            ("Transcribed-by", "Seargant Persimmons"),
+            ("Signed-off-by", "Colonel Kale")
+        ].into_iter().collect();
+        assert_eq!(expected, to_map(&message_trailers(message2).unwrap()));
+
+        // ignore everything after `---`
+        let message3 = "
+The fate of Seargant Green-Peppers
+
+Seargant Green-Peppers was killed by Caterpillar Battalion 44.
+
+Signed-off-by: Colonel Kale
+---
+I never liked that guy, anyway.
+
+Opined-by: Corporal Garlic
+";
+        let expected: HashMap<&str, &str> = vec![
+            ("Signed-off-by", "Colonel Kale")
+        ].into_iter().collect();
+        assert_eq!(expected, to_map(&message_trailers(message3).unwrap()));
+
+        fn to_map<'pair>(
+            trailers: &'pair MessageTrailers<'pair>
+        ) -> HashMap<&str, &str> {
+            let mut map = HashMap::with_capacity(trailers.len());
+            for (key, value) in trailers.iter() {
+                map.insert(key, value);
+            }
+            map
+        }
+    }
 }

From 5575c3d1903ef09fc7f4bc04d2568bda0889770b Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <haugsbakk@yahoo.no>
Date: Mon, 27 Sep 2021 21:16:27 +0200
Subject: [PATCH 02/20] `cargo fmt`

---
 libgit2-sys/lib.rs |  6 ++----
 src/lib.rs         |  5 ++++-
 src/message.rs     | 50 +++++++++++++++++++++-------------------------
 3 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/libgit2-sys/lib.rs b/libgit2-sys/lib.rs
index 648d8ddd53..5a1c5a8a57 100644
--- a/libgit2-sys/lib.rs
+++ b/libgit2-sys/lib.rs
@@ -1960,7 +1960,7 @@ pub struct git_message_trailer {
 }
 
 #[repr(C)]
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
 pub struct git_message_trailer_array {
     pub trailers: *const git_message_trailer,
     pub count: size_t,
@@ -3697,9 +3697,7 @@ extern "C" {
         message: *const c_char,
     ) -> c_int;
 
-    pub fn git_message_trailer_array_free(
-        trailer: *mut git_message_trailer_array,
-    );
+    pub fn git_message_trailer_array_free(trailer: *mut git_message_trailer_array);
 
     // packbuilder
     pub fn git_packbuilder_new(out: *mut *mut git_packbuilder, repo: *mut git_repository) -> c_int;
diff --git a/src/lib.rs b/src/lib.rs
index d9e4829f9e..6dfc668af6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -101,7 +101,10 @@ pub use crate::indexer::{IndexerProgress, Progress};
 pub use crate::mailmap::Mailmap;
 pub use crate::mempack::Mempack;
 pub use crate::merge::{AnnotatedCommit, MergeOptions};
-pub use crate::message::{message_prettify, DEFAULT_COMMENT_CHAR, message_trailers, MessageTrailers, MessageTrailersIterator};
+pub use crate::message::{
+    message_prettify, message_trailers, MessageTrailers, MessageTrailersIterator,
+    DEFAULT_COMMENT_CHAR,
+};
 pub use crate::note::{Note, Notes};
 pub use crate::object::Object;
 pub use crate::odb::{Odb, OdbObject, OdbPackwriter, OdbReader, OdbWriter};
diff --git a/src/message.rs b/src/message.rs
index e797a21212..077ee74d38 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,7 +1,7 @@
-use std::ffi::CString;
 use std::ffi::CStr;
-use std::ptr;
+use std::ffi::CString;
 use std::marker;
+use std::ptr;
 
 use libc::{c_char, c_int};
 
@@ -73,9 +73,7 @@ impl<'pair> Drop for MessageTrailers<'pair> {
 
 impl<'pair> Binding for MessageTrailers<'pair> {
     type Raw = *mut raw::git_message_trailer_array;
-    unsafe fn from_raw(
-        raw: *mut raw::git_message_trailer_array
-    ) -> MessageTrailers<'pair> {
+    unsafe fn from_raw(raw: *mut raw::git_message_trailer_array) -> MessageTrailers<'pair> {
         MessageTrailers {
             raw: *raw,
             _marker: marker::PhantomData,
@@ -118,11 +116,14 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
             unsafe {
                 let addr = self.trailers.raw.trailers.wrapping_add(self.counter);
                 self.counter += 1;
-                Some(Trailer {
-                    key: (*addr).key,
-                    value: (*addr).value,
-                    _marker: marker::PhantomData,
-                }.to_str_tuple())
+                Some(
+                    Trailer {
+                        key: (*addr).key,
+                        value: (*addr).value,
+                        _marker: marker::PhantomData,
+                    }
+                    .to_str_tuple(),
+                )
             }
         }
     }
@@ -130,20 +131,15 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
 
 /// Get the trailers for the given message.
 pub fn message_trailers<'pair, S: IntoCString>(
-    message: S
+    message: S,
 ) -> Result<MessageTrailers<'pair>, Error> {
     _message_trailers(message.into_c_string()?)
 }
 
-fn _message_trailers<'pair>(
-    message: CString
-) -> Result<MessageTrailers<'pair>, Error> {
+fn _message_trailers<'pair>(message: CString) -> Result<MessageTrailers<'pair>, Error> {
     let ret = MessageTrailers::new();
     unsafe {
-        try_call!(raw::git_message_trailers(
-            ret.raw(),
-            message
-        ));
+        try_call!(raw::git_message_trailers(ret.raw(), message));
     }
     Ok(ret)
 }
@@ -182,8 +178,8 @@ mod tests {
 
     #[test]
     fn trailers() {
-        use std::collections::HashMap;
         use crate::{message_trailers, MessageTrailers};
+        use std::collections::HashMap;
 
         // no trailers
         let message1 = "
@@ -209,8 +205,10 @@ Signed-off-by: Colonel Kale
         let expected: HashMap<&str, &str> = vec![
             ("Spoken-by", "Major Turnips"),
             ("Transcribed-by", "Seargant Persimmons"),
-            ("Signed-off-by", "Colonel Kale")
-        ].into_iter().collect();
+            ("Signed-off-by", "Colonel Kale"),
+        ]
+        .into_iter()
+        .collect();
         assert_eq!(expected, to_map(&message_trailers(message2).unwrap()));
 
         // ignore everything after `---`
@@ -225,14 +223,12 @@ I never liked that guy, anyway.
 
 Opined-by: Corporal Garlic
 ";
-        let expected: HashMap<&str, &str> = vec![
-            ("Signed-off-by", "Colonel Kale")
-        ].into_iter().collect();
+        let expected: HashMap<&str, &str> = vec![("Signed-off-by", "Colonel Kale")]
+            .into_iter()
+            .collect();
         assert_eq!(expected, to_map(&message_trailers(message3).unwrap()));
 
-        fn to_map<'pair>(
-            trailers: &'pair MessageTrailers<'pair>
-        ) -> HashMap<&str, &str> {
+        fn to_map<'pair>(trailers: &'pair MessageTrailers<'pair>) -> HashMap<&str, &str> {
             let mut map = HashMap::with_capacity(trailers.len());
             for (key, value) in trailers.iter() {
                 map.insert(key, value);

From 33ebdcdc1c556a88ae03c9667556fac80bbd6fb5 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <haugsbakk@yahoo.no>
Date: Mon, 11 Oct 2021 20:04:19 +0200
Subject: [PATCH 03/20] Fix pointer mismatch error
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix error from `cargo run --manifest-path systest/Cargo.toml;`.

You can’t just mix and match `*mut` and `*const` like that.
---
 libgit2-sys/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libgit2-sys/lib.rs b/libgit2-sys/lib.rs
index 5a1c5a8a57..7f128cd0db 100644
--- a/libgit2-sys/lib.rs
+++ b/libgit2-sys/lib.rs
@@ -1962,7 +1962,7 @@ pub struct git_message_trailer {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct git_message_trailer_array {
-    pub trailers: *const git_message_trailer,
+    pub trailers: *mut git_message_trailer,
     pub count: size_t,
     pub _trailer_block: *mut c_char,
 }

From f6fd4b7e9a8cf1d3d02747ccfb98d089a49fa9a3 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Tue, 12 Oct 2021 21:09:45 +0200
Subject: [PATCH 04/20] Remove a lot of unnecessary lifetimes

Suggested-by: Alex Crichton <alex@alexcrichton.com>
See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r726550603
---
 src/message.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index 077ee74d38..94f08e86ce 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -34,13 +34,13 @@ fn _message_prettify(message: CString, comment_char: Option<u8>) -> Result<Strin
 /// Collection of trailer key–value pairs.
 ///
 /// Use `iter()` to get access to the values.
-pub struct MessageTrailers<'pair> {
+pub struct MessageTrailers {
     raw: raw::git_message_trailer_array,
-    _marker: marker::PhantomData<&'pair c_char>,
+    _marker: marker::PhantomData<c_char>,
 }
 
-impl<'pair> MessageTrailers<'pair> {
-    fn new() -> MessageTrailers<'pair> {
+impl<'pair> MessageTrailers {
+    fn new() -> MessageTrailers {
         crate::init();
         unsafe {
             Binding::from_raw(&mut raw::git_message_trailer_array {
@@ -63,7 +63,7 @@ impl<'pair> MessageTrailers<'pair> {
     }
 }
 
-impl<'pair> Drop for MessageTrailers<'pair> {
+impl<'pair> Drop for MessageTrailers {
     fn drop(&mut self) {
         unsafe {
             raw::git_message_trailer_array_free(&mut self.raw);
@@ -71,9 +71,9 @@ impl<'pair> Drop for MessageTrailers<'pair> {
     }
 }
 
-impl<'pair> Binding for MessageTrailers<'pair> {
+impl<'pair> Binding for MessageTrailers {
     type Raw = *mut raw::git_message_trailer_array;
-    unsafe fn from_raw(raw: *mut raw::git_message_trailer_array) -> MessageTrailers<'pair> {
+    unsafe fn from_raw(raw: *mut raw::git_message_trailer_array) -> MessageTrailers {
         MessageTrailers {
             raw: *raw,
             _marker: marker::PhantomData,
@@ -101,8 +101,8 @@ impl<'pair> Trailer<'pair> {
 }
 
 /// A borrowed iterator.
-pub struct MessageTrailersIterator<'pair> {
-    trailers: &'pair MessageTrailers<'pair>,
+pub struct MessageTrailersIterator<'a> {
+    trailers: &'a MessageTrailers,
     counter: usize,
 }
 
@@ -132,11 +132,11 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
 /// Get the trailers for the given message.
 pub fn message_trailers<'pair, S: IntoCString>(
     message: S,
-) -> Result<MessageTrailers<'pair>, Error> {
+) -> Result<MessageTrailers, Error> {
     _message_trailers(message.into_c_string()?)
 }
 
-fn _message_trailers<'pair>(message: CString) -> Result<MessageTrailers<'pair>, Error> {
+fn _message_trailers<'pair>(message: CString) -> Result<MessageTrailers, Error> {
     let ret = MessageTrailers::new();
     unsafe {
         try_call!(raw::git_message_trailers(ret.raw(), message));
@@ -228,7 +228,7 @@ Opined-by: Corporal Garlic
             .collect();
         assert_eq!(expected, to_map(&message_trailers(message3).unwrap()));
 
-        fn to_map<'pair>(trailers: &'pair MessageTrailers<'pair>) -> HashMap<&str, &str> {
+        fn to_map(trailers: &MessageTrailers) -> HashMap<&str, &str> {
             let mut map = HashMap::with_capacity(trailers.len());
             for (key, value) in trailers.iter() {
                 map.insert(key, value);

From b0015cccda0d8d086842ad51cdc6063d1edf31f8 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Tue, 12 Oct 2021 21:33:45 +0200
Subject: [PATCH 05/20] Remove another unnecessary lifetime

Suggested-by: Alex Crichton <alex@alexcrichton.com>
See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r726550919
---
 src/message.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/message.rs b/src/message.rs
index 94f08e86ce..cb0952e4f1 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -71,7 +71,7 @@ impl<'pair> Drop for MessageTrailers {
     }
 }
 
-impl<'pair> Binding for MessageTrailers {
+impl Binding for MessageTrailers {
     type Raw = *mut raw::git_message_trailer_array;
     unsafe fn from_raw(raw: *mut raw::git_message_trailer_array) -> MessageTrailers {
         MessageTrailers {

From e94008a00fd1ce2af3df604d722d2cb6d34de6fe Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Tue, 12 Oct 2021 21:46:46 +0200
Subject: [PATCH 06/20] Use `Range<usize>` instead of `usize`

I love it.

Suggested-by: Alex Crichton <alex@alexcrichton.com>
See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r726551294
---
 src/message.rs | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index cb0952e4f1..f4e1e93ec8 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,3 +1,4 @@
+use core::ops::Range;
 use std::ffi::CStr;
 use std::ffi::CString;
 use std::marker;
@@ -54,7 +55,10 @@ impl<'pair> MessageTrailers {
     pub fn iter(&'pair self) -> MessageTrailersIterator<'pair> {
         MessageTrailersIterator {
             trailers: self,
-            counter: 0,
+            range: Range {
+                start: 0,
+                end: self.raw.count,
+            },
         }
     }
     /// The number of trailer key–value pairs.
@@ -103,29 +107,22 @@ impl<'pair> Trailer<'pair> {
 /// A borrowed iterator.
 pub struct MessageTrailersIterator<'a> {
     trailers: &'a MessageTrailers,
-    counter: usize,
+    range: Range<usize>,
 }
 
 impl<'pair> Iterator for MessageTrailersIterator<'pair> {
     type Item = (&'pair str, &'pair str);
 
     fn next(&mut self) -> Option<Self::Item> {
-        if self.counter == self.trailers.raw.count {
-            None
-        } else {
-            unsafe {
-                let addr = self.trailers.raw.trailers.wrapping_add(self.counter);
-                self.counter += 1;
-                Some(
-                    Trailer {
-                        key: (*addr).key,
-                        value: (*addr).value,
-                        _marker: marker::PhantomData,
-                    }
-                    .to_str_tuple(),
-                )
+        self.range.next().map(|index| unsafe {
+            let addr = self.trailers.raw.trailers.wrapping_add(index);
+            Trailer {
+                key: (*addr).key,
+                value: (*addr).value,
+                _marker: marker::PhantomData,
             }
-        }
+            .to_str_tuple()
+        })
     }
 }
 

From e830f7d41d3f380ed5943cbffdc2b266ce19c61d Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Tue, 12 Oct 2021 22:03:34 +0200
Subject: [PATCH 07/20] `cargo fmt`

---
 src/message.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index f4e1e93ec8..8a73abc4a5 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -127,9 +127,7 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
 }
 
 /// Get the trailers for the given message.
-pub fn message_trailers<'pair, S: IntoCString>(
-    message: S,
-) -> Result<MessageTrailers, Error> {
+pub fn message_trailers<'pair, S: IntoCString>(message: S) -> Result<MessageTrailers, Error> {
     _message_trailers(message.into_c_string()?)
 }
 

From 55ea9092cd08dd6bd9e7b9a2246d5b05935672e2 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Tue, 12 Oct 2021 22:07:54 +0200
Subject: [PATCH 08/20] Inline one-off struct

Suggested-by: Alex Crichton <alex@alexcrichton.com>
See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r726551473
---
 src/message.rs | 35 +++++++++++++----------------------
 src/util.rs    |  2 +-
 2 files changed, 14 insertions(+), 23 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index 8a73abc4a5..c799cd218f 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -88,22 +88,6 @@ impl Binding for MessageTrailers {
     }
 }
 
-struct Trailer<'pair> {
-    key: *const c_char,
-    value: *const c_char,
-    _marker: marker::PhantomData<&'pair c_char>,
-}
-
-impl<'pair> Trailer<'pair> {
-    fn to_str_tuple(self) -> (&'pair str, &'pair str) {
-        unsafe {
-            let key = CStr::from_ptr(self.key).to_str().unwrap();
-            let value = CStr::from_ptr(self.value).to_str().unwrap();
-            (key, value)
-        }
-    }
-}
-
 /// A borrowed iterator.
 pub struct MessageTrailersIterator<'a> {
     trailers: &'a MessageTrailers,
@@ -116,16 +100,23 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
     fn next(&mut self) -> Option<Self::Item> {
         self.range.next().map(|index| unsafe {
             let addr = self.trailers.raw.trailers.wrapping_add(index);
-            Trailer {
-                key: (*addr).key,
-                value: (*addr).value,
-                _marker: marker::PhantomData,
-            }
-            .to_str_tuple()
+            to_str_tuple((*addr).key, (*addr).value, marker::PhantomData)
         })
     }
 }
 
+fn to_str_tuple<'pair>(
+    key: *const c_char,
+    value: *const c_char,
+    _marker: marker::PhantomData<&'pair c_char>,
+) -> (&'pair str, &'pair str) {
+    unsafe {
+        let k = CStr::from_ptr(key).to_str().unwrap();
+        let v = CStr::from_ptr(value).to_str().unwrap();
+        (k, v)
+    }
+}
+
 /// Get the trailers for the given message.
 pub fn message_trailers<'pair, S: IntoCString>(message: S) -> Result<MessageTrailers, Error> {
     _message_trailers(message.into_c_string()?)
diff --git a/src/util.rs b/src/util.rs
index 1c6001ddbf..a31e63bce2 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -204,7 +204,7 @@ pub fn c_cmp_to_ordering(cmp: c_int) -> Ordering {
 pub fn path_to_repo_path(path: &Path) -> Result<CString, Error> {
     macro_rules! err {
         ($msg:literal, $path:expr) => {
-            return Err(Error::from_str(&format!($msg, $path.display())))
+            return Err(Error::from_str(&format!($msg, $path.display())));
         };
     }
     match path.components().next() {

From e7b0306a16ac2e09a12fb48d1dc89b41e1f7e3aa Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Wed, 13 Oct 2021 21:16:52 +0200
Subject: [PATCH 09/20] Implement more iterators
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Also change `to_str_tuple(…)` in order to share more code between two of
the iterators.

Suggested-by: Alex Crichton <alex@alexcrichton.com>
See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r726551780
---
 src/message.rs | 39 +++++++++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index c799cd218f..2eb8afa19a 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -98,22 +98,37 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
     type Item = (&'pair str, &'pair str);
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.range.next().map(|index| unsafe {
-            let addr = self.trailers.raw.trailers.wrapping_add(index);
-            to_str_tuple((*addr).key, (*addr).value, marker::PhantomData)
-        })
+        self.range
+            .next()
+            .map(|index| to_str_tuple(&self.trailers, index, marker::PhantomData))
     }
 }
 
-fn to_str_tuple<'pair>(
-    key: *const c_char,
-    value: *const c_char,
-    _marker: marker::PhantomData<&'pair c_char>,
-) -> (&'pair str, &'pair str) {
+#[inline(always)]
+fn to_str_tuple(
+    trailers: &MessageTrailers,
+    index: usize,
+    _marker: marker::PhantomData<c_char>,
+) -> (&str, &str) {
     unsafe {
-        let k = CStr::from_ptr(key).to_str().unwrap();
-        let v = CStr::from_ptr(value).to_str().unwrap();
-        (k, v)
+        let addr = trailers.raw.trailers.wrapping_add(index);
+        let key = CStr::from_ptr((*addr).key).to_str().unwrap();
+        let value = CStr::from_ptr((*addr).value).to_str().unwrap();
+        (key, value)
+    }
+}
+
+impl ExactSizeIterator for MessageTrailersIterator<'_> {
+    fn len(&self) -> usize {
+        self.range.end
+    }
+}
+
+impl DoubleEndedIterator for MessageTrailersIterator<'_> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.range
+            .next_back()
+            .map(|index| to_str_tuple(&self.trailers, index, marker::PhantomData))
     }
 }
 

From cd4c2dbee5f91610011913d3cd10e5786fbceef5 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Thu, 14 Oct 2021 22:42:25 +0200
Subject: [PATCH 10/20] Undo accidental and unrelated edit

---
 src/util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/util.rs b/src/util.rs
index a31e63bce2..1c6001ddbf 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -204,7 +204,7 @@ pub fn c_cmp_to_ordering(cmp: c_int) -> Ordering {
 pub fn path_to_repo_path(path: &Path) -> Result<CString, Error> {
     macro_rules! err {
         ($msg:literal, $path:expr) => {
-            return Err(Error::from_str(&format!($msg, $path.display())));
+            return Err(Error::from_str(&format!($msg, $path.display())))
         };
     }
     match path.components().next() {

From e450945d8dcde6f6c37af3b56e18da0628925603 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Fri, 15 Oct 2021 20:51:26 +0200
Subject: [PATCH 11/20] Less explicit lifetimes

See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r729899152
---
 src/message.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index 2eb8afa19a..d399dec125 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -40,7 +40,7 @@ pub struct MessageTrailers {
     _marker: marker::PhantomData<c_char>,
 }
 
-impl<'pair> MessageTrailers {
+impl MessageTrailers {
     fn new() -> MessageTrailers {
         crate::init();
         unsafe {
@@ -52,7 +52,7 @@ impl<'pair> MessageTrailers {
         }
     }
     /// Create a borrowed iterator.
-    pub fn iter(&'pair self) -> MessageTrailersIterator<'pair> {
+    pub fn iter(&self) -> MessageTrailersIterator<'_> {
         MessageTrailersIterator {
             trailers: self,
             range: Range {

From a0bd0260110a6fa1f701bf9f467f5721c0ee72ea Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Fri, 15 Oct 2021 20:53:05 +0200
Subject: [PATCH 12/20] =?UTF-8?q?Don=E2=80=99t=20need=20`std::marker`=20an?=
 =?UTF-8?q?y=20more?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r729899304
---
 src/message.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index d399dec125..03155aeb23 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,7 +1,6 @@
 use core::ops::Range;
 use std::ffi::CStr;
 use std::ffi::CString;
-use std::marker;
 use std::ptr;
 
 use libc::{c_char, c_int};
@@ -37,7 +36,6 @@ fn _message_prettify(message: CString, comment_char: Option<u8>) -> Result<Strin
 /// Use `iter()` to get access to the values.
 pub struct MessageTrailers {
     raw: raw::git_message_trailer_array,
-    _marker: marker::PhantomData<c_char>,
 }
 
 impl MessageTrailers {
@@ -80,7 +78,6 @@ impl Binding for MessageTrailers {
     unsafe fn from_raw(raw: *mut raw::git_message_trailer_array) -> MessageTrailers {
         MessageTrailers {
             raw: *raw,
-            _marker: marker::PhantomData,
         }
     }
     fn raw(&self) -> *mut raw::git_message_trailer_array {
@@ -100,7 +97,7 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
     fn next(&mut self) -> Option<Self::Item> {
         self.range
             .next()
-            .map(|index| to_str_tuple(&self.trailers, index, marker::PhantomData))
+            .map(|index| to_str_tuple(&self.trailers, index))
     }
 }
 
@@ -108,7 +105,6 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
 fn to_str_tuple(
     trailers: &MessageTrailers,
     index: usize,
-    _marker: marker::PhantomData<c_char>,
 ) -> (&str, &str) {
     unsafe {
         let addr = trailers.raw.trailers.wrapping_add(index);
@@ -128,7 +124,7 @@ impl DoubleEndedIterator for MessageTrailersIterator<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.range
             .next_back()
-            .map(|index| to_str_tuple(&self.trailers, index, marker::PhantomData))
+            .map(|index| to_str_tuple(&self.trailers, index))
     }
 }
 

From 34fa7b51ce6b654be6ab74783cd4e085d6e4cf3b Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Fri, 15 Oct 2021 20:54:02 +0200
Subject: [PATCH 13/20] =?UTF-8?q?Correct=20`len(=E2=80=A6)`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r729900328
---
 src/message.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/message.rs b/src/message.rs
index 03155aeb23..e18bc4a0b4 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -116,7 +116,7 @@ fn to_str_tuple(
 
 impl ExactSizeIterator for MessageTrailersIterator<'_> {
     fn len(&self) -> usize {
-        self.range.end
+        self.range.len()
     }
 }
 

From 023fb9215568f8cdee7c72be16eba3daf9152707 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Fri, 15 Oct 2021 20:56:31 +0200
Subject: [PATCH 14/20] Remove unnecessary annotation

See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r729900889
---
 src/message.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/message.rs b/src/message.rs
index e18bc4a0b4..86c55703ce 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -101,7 +101,6 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
     }
 }
 
-#[inline(always)]
 fn to_str_tuple(
     trailers: &MessageTrailers,
     index: usize,

From 16321f38702ea6398015ec26cd0a55fbc7f644d5 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Fri, 15 Oct 2021 21:11:02 +0200
Subject: [PATCH 15/20] Implement `size_hint()`

Better than the default implementation.

See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r729900533
---
 src/message.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/message.rs b/src/message.rs
index 86c55703ce..5a44249ca7 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -99,6 +99,10 @@ impl<'pair> Iterator for MessageTrailersIterator<'pair> {
             .next()
             .map(|index| to_str_tuple(&self.trailers, index))
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.range.size_hint()
+    }
 }
 
 fn to_str_tuple(

From 70b7ebd968030c48d197eb6b059fac00079ee408 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Fri, 15 Oct 2021 21:16:43 +0200
Subject: [PATCH 16/20] =?UTF-8?q?Split=20into=20=E2=80=9Cbytes=E2=80=9D=20?=
 =?UTF-8?q?and=20=E2=80=9Cstring=E2=80=9D=20iterators?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Support both raw bytes messages as well as normal (UTF-8) messages by
making two iterators.

See: https://github.com/rust-lang/git2-rs/pull/749#discussion_r729951586
---
 src/lib.rs     |   3 +-
 src/message.rs | 198 ++++++++++++++++++++++++++++++++++++++-----------
 src/util.rs    |   2 +-
 3 files changed, 157 insertions(+), 46 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 6dfc668af6..2456877f6a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -102,7 +102,8 @@ pub use crate::mailmap::Mailmap;
 pub use crate::mempack::Mempack;
 pub use crate::merge::{AnnotatedCommit, MergeOptions};
 pub use crate::message::{
-    message_prettify, message_trailers, MessageTrailers, MessageTrailersIterator,
+    message_prettify, message_trailers_bytes, message_trailers_strs, MessageTrailersBytes,
+    MessageTrailersBytesIterator, MessageTrailersStrs, MessageTrailersStrsIterator,
     DEFAULT_COMMENT_CHAR,
 };
 pub use crate::note::{Note, Notes};
diff --git a/src/message.rs b/src/message.rs
index 5a44249ca7..ff346efdfa 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -31,10 +31,72 @@ fn _message_prettify(message: CString, comment_char: Option<u8>) -> Result<Strin
     Ok(ret.as_str().unwrap().to_string())
 }
 
-/// Collection of trailer key–value pairs.
+/// The default comment character for `message_prettify` ('#')
+pub const DEFAULT_COMMENT_CHAR: Option<u8> = Some(b'#');
+
+/// Get the trailers for the given message.
+///
+/// Use this function when you are dealing with a UTF-8-encoded message.
+pub fn message_trailers_strs<'pair>(message: &str) -> Result<MessageTrailersStrs, Error> {
+    _message_trailers(message.into_c_string()?).map(|res| MessageTrailersStrs(res))
+}
+
+/// Get the trailers for the given message.
+///
+/// Use this function when the message might not be UTF-8-encoded,
+/// or if you want to handle the returned trailer key–value pairs
+/// as bytes.
+pub fn message_trailers_bytes<'pair, S: IntoCString>(
+    message: S,
+) -> Result<MessageTrailersBytes, Error> {
+    _message_trailers(message.into_c_string()?).map(|res| MessageTrailersBytes(res))
+}
+
+fn _message_trailers<'pair>(message: CString) -> Result<MessageTrailers, Error> {
+    let ret = MessageTrailers::new();
+    unsafe {
+        try_call!(raw::git_message_trailers(ret.raw(), message));
+    }
+    Ok(ret)
+}
+
+/// Collection of UTF-8-encoded trailer key–value pairs.
 ///
 /// Use `iter()` to get access to the values.
-pub struct MessageTrailers {
+pub struct MessageTrailersStrs(MessageTrailers);
+
+impl MessageTrailersStrs {
+    /// Create a borrowed iterator.
+    pub fn iter(&self) -> MessageTrailersStrsIterator<'_> {
+        MessageTrailersStrsIterator(self.0.iter())
+    }
+    /// The number of trailer key–value pairs.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+    /// Convert to the “bytes” variant.
+    pub fn to_bytes(self) -> MessageTrailersBytes {
+        MessageTrailersBytes(self.0)
+    }
+}
+
+/// Collection of unencoded (bytes) trailer key–value pairs.
+///
+/// Use `iter()` to get access to the values.
+pub struct MessageTrailersBytes(MessageTrailers);
+
+impl MessageTrailersBytes {
+    /// Create a borrowed iterator.
+    pub fn iter(&self) -> MessageTrailersBytesIterator<'_> {
+        MessageTrailersBytesIterator(self.0.iter())
+    }
+    /// The number of trailer key–value pairs.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+struct MessageTrailers {
     raw: raw::git_message_trailer_array,
 }
 
@@ -49,8 +111,7 @@ impl MessageTrailers {
             } as *mut _)
         }
     }
-    /// Create a borrowed iterator.
-    pub fn iter(&self) -> MessageTrailersIterator<'_> {
+    fn iter(&self) -> MessageTrailersIterator<'_> {
         MessageTrailersIterator {
             trailers: self,
             range: Range {
@@ -59,8 +120,7 @@ impl MessageTrailers {
             },
         }
     }
-    /// The number of trailer key–value pairs.
-    pub fn len(&self) -> usize {
+    fn len(&self) -> usize {
         self.raw.count
     }
 }
@@ -76,77 +136,109 @@ impl<'pair> Drop for MessageTrailers {
 impl Binding for MessageTrailers {
     type Raw = *mut raw::git_message_trailer_array;
     unsafe fn from_raw(raw: *mut raw::git_message_trailer_array) -> MessageTrailers {
-        MessageTrailers {
-            raw: *raw,
-        }
+        MessageTrailers { raw: *raw }
     }
     fn raw(&self) -> *mut raw::git_message_trailer_array {
         &self.raw as *const _ as *mut _
     }
 }
 
-/// A borrowed iterator.
-pub struct MessageTrailersIterator<'a> {
+struct MessageTrailersIterator<'a> {
     trailers: &'a MessageTrailers,
     range: Range<usize>,
 }
 
-impl<'pair> Iterator for MessageTrailersIterator<'pair> {
+fn to_raw_tuple(trailers: &MessageTrailers, index: usize) -> (*const c_char, *const c_char) {
+    unsafe {
+        let addr = trailers.raw.trailers.wrapping_add(index);
+        ((*addr).key, (*addr).value)
+    }
+}
+
+/// Borrowed iterator over the UTF-8-encoded trailer.
+pub struct MessageTrailersStrsIterator<'a>(MessageTrailersIterator<'a>);
+
+impl<'pair> Iterator for MessageTrailersStrsIterator<'pair> {
     type Item = (&'pair str, &'pair str);
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.range
+        self.0
+            .range
             .next()
-            .map(|index| to_str_tuple(&self.trailers, index))
+            .map(|index| to_str_tuple(&self.0.trailers, index))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.range.size_hint()
+        self.0.range.size_hint()
+    }
+}
+
+impl ExactSizeIterator for MessageTrailersStrsIterator<'_> {
+    fn len(&self) -> usize {
+        self.0.range.len()
+    }
+}
+
+impl DoubleEndedIterator for MessageTrailersStrsIterator<'_> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.0
+            .range
+            .next_back()
+            .map(|index| to_str_tuple(&self.0.trailers, index))
     }
 }
 
-fn to_str_tuple(
-    trailers: &MessageTrailers,
-    index: usize,
-) -> (&str, &str) {
+fn to_str_tuple(trailers: &MessageTrailers, index: usize) -> (&str, &str) {
     unsafe {
-        let addr = trailers.raw.trailers.wrapping_add(index);
-        let key = CStr::from_ptr((*addr).key).to_str().unwrap();
-        let value = CStr::from_ptr((*addr).value).to_str().unwrap();
+        let (rkey, rvalue) = to_raw_tuple(&trailers, index);
+        let key = CStr::from_ptr(rkey).to_str().unwrap();
+        let value = CStr::from_ptr(rvalue).to_str().unwrap();
         (key, value)
     }
 }
 
-impl ExactSizeIterator for MessageTrailersIterator<'_> {
+/// Borrowed iterator over the raw (bytes) trailer.
+pub struct MessageTrailersBytesIterator<'a>(MessageTrailersIterator<'a>);
+
+impl<'pair> Iterator for MessageTrailersBytesIterator<'pair> {
+    type Item = (&'pair [u8], &'pair [u8]);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0
+            .range
+            .next()
+            .map(|index| to_bytes_tuple(&self.0.trailers, index))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.range.size_hint()
+    }
+}
+
+impl ExactSizeIterator for MessageTrailersBytesIterator<'_> {
     fn len(&self) -> usize {
-        self.range.len()
+        self.0.range.len()
     }
 }
 
-impl DoubleEndedIterator for MessageTrailersIterator<'_> {
+impl DoubleEndedIterator for MessageTrailersBytesIterator<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
-        self.range
+        self.0
+            .range
             .next_back()
-            .map(|index| to_str_tuple(&self.trailers, index))
+            .map(|index| to_bytes_tuple(&self.0.trailers, index))
     }
 }
 
-/// Get the trailers for the given message.
-pub fn message_trailers<'pair, S: IntoCString>(message: S) -> Result<MessageTrailers, Error> {
-    _message_trailers(message.into_c_string()?)
-}
-
-fn _message_trailers<'pair>(message: CString) -> Result<MessageTrailers, Error> {
-    let ret = MessageTrailers::new();
+fn to_bytes_tuple(trailers: &MessageTrailers, index: usize) -> (&[u8], &[u8]) {
     unsafe {
-        try_call!(raw::git_message_trailers(ret.raw(), message));
+        let (rkey, rvalue) = to_raw_tuple(&trailers, index);
+        let key = CStr::from_ptr(rkey).to_bytes();
+        let value = CStr::from_ptr(rvalue).to_bytes();
+        (key, value)
     }
-    Ok(ret)
 }
 
-/// The default comment character for `message_prettify` ('#')
-pub const DEFAULT_COMMENT_CHAR: Option<u8> = Some(b'#');
-
 #[cfg(test)]
 mod tests {
 
@@ -178,7 +270,7 @@ mod tests {
 
     #[test]
     fn trailers() {
-        use crate::{message_trailers, MessageTrailers};
+        use crate::{message_trailers_bytes, message_trailers_strs, MessageTrailersStrs};
         use std::collections::HashMap;
 
         // no trailers
@@ -190,7 +282,7 @@ What are we here for?
 Just to be eaten?
 ";
         let expected: HashMap<&str, &str> = HashMap::new();
-        assert_eq!(expected, to_map(&message_trailers(message1).unwrap()));
+        assert_eq!(expected, to_map(&message_trailers_strs(message1).unwrap()));
 
         // standard PSA
         let message2 = "
@@ -209,7 +301,7 @@ Signed-off-by: Colonel Kale
         ]
         .into_iter()
         .collect();
-        assert_eq!(expected, to_map(&message_trailers(message2).unwrap()));
+        assert_eq!(expected, to_map(&message_trailers_strs(message2).unwrap()));
 
         // ignore everything after `---`
         let message3 = "
@@ -226,9 +318,27 @@ Opined-by: Corporal Garlic
         let expected: HashMap<&str, &str> = vec![("Signed-off-by", "Colonel Kale")]
             .into_iter()
             .collect();
-        assert_eq!(expected, to_map(&message_trailers(message3).unwrap()));
+        assert_eq!(expected, to_map(&message_trailers_strs(message3).unwrap()));
+
+        // Raw bytes message; not valid UTF-8
+        // Source: https://stackoverflow.com/a/3886015/1725151
+        let message4 = b"
+Be honest guys
+
+Am I a malformed brussels sprout?
+
+Signed-off-by: Lieutenant \xe2\x28\xa1prout
+";
+
+        let trailer = message_trailers_bytes(&message4[..]).unwrap();
+        let expected = (
+            &b"Signed-off-by"[..],
+            &b"Lieutenant \xe2\x28\xa1prout"[..],
+        );
+        let actual = trailer.iter().next().unwrap();
+        assert_eq!(expected, actual);
 
-        fn to_map(trailers: &MessageTrailers) -> HashMap<&str, &str> {
+        fn to_map(trailers: &MessageTrailersStrs) -> HashMap<&str, &str> {
             let mut map = HashMap::with_capacity(trailers.len());
             for (key, value) in trailers.iter() {
                 map.insert(key, value);
diff --git a/src/util.rs b/src/util.rs
index 1c6001ddbf..a31e63bce2 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -204,7 +204,7 @@ pub fn c_cmp_to_ordering(cmp: c_int) -> Ordering {
 pub fn path_to_repo_path(path: &Path) -> Result<CString, Error> {
     macro_rules! err {
         ($msg:literal, $path:expr) => {
-            return Err(Error::from_str(&format!($msg, $path.display())))
+            return Err(Error::from_str(&format!($msg, $path.display())));
         };
     }
     match path.components().next() {

From ed11c761d4fa49448e4aacbe69b3e6b9ea467476 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Sat, 16 Oct 2021 09:28:40 +0200
Subject: [PATCH 17/20] Remove more lifetimes

---
 src/message.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index ff346efdfa..e6ff7948af 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -37,7 +37,7 @@ pub const DEFAULT_COMMENT_CHAR: Option<u8> = Some(b'#');
 /// Get the trailers for the given message.
 ///
 /// Use this function when you are dealing with a UTF-8-encoded message.
-pub fn message_trailers_strs<'pair>(message: &str) -> Result<MessageTrailersStrs, Error> {
+pub fn message_trailers_strs(message: &str) -> Result<MessageTrailersStrs, Error> {
     _message_trailers(message.into_c_string()?).map(|res| MessageTrailersStrs(res))
 }
 
@@ -46,13 +46,13 @@ pub fn message_trailers_strs<'pair>(message: &str) -> Result<MessageTrailersStrs
 /// Use this function when the message might not be UTF-8-encoded,
 /// or if you want to handle the returned trailer key–value pairs
 /// as bytes.
-pub fn message_trailers_bytes<'pair, S: IntoCString>(
+pub fn message_trailers_bytes<S: IntoCString>(
     message: S,
 ) -> Result<MessageTrailersBytes, Error> {
     _message_trailers(message.into_c_string()?).map(|res| MessageTrailersBytes(res))
 }
 
-fn _message_trailers<'pair>(message: CString) -> Result<MessageTrailers, Error> {
+fn _message_trailers(message: CString) -> Result<MessageTrailers, Error> {
     let ret = MessageTrailers::new();
     unsafe {
         try_call!(raw::git_message_trailers(ret.raw(), message));
@@ -125,7 +125,7 @@ impl MessageTrailers {
     }
 }
 
-impl<'pair> Drop for MessageTrailers {
+impl Drop for MessageTrailers {
     fn drop(&mut self) {
         unsafe {
             raw::git_message_trailer_array_free(&mut self.raw);

From 958e378cb953977cd3ad44b90f75c873792bd37a Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Sat, 16 Oct 2021 12:04:54 +0200
Subject: [PATCH 18/20] Docs

---
 src/message.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index e6ff7948af..51fa9cf908 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -60,7 +60,7 @@ fn _message_trailers(message: CString) -> Result<MessageTrailers, Error> {
     Ok(ret)
 }
 
-/// Collection of UTF-8-encoded trailer key–value pairs.
+/// Collection of UTF-8-encoded trailers.
 ///
 /// Use `iter()` to get access to the values.
 pub struct MessageTrailersStrs(MessageTrailers);
@@ -80,7 +80,7 @@ impl MessageTrailersStrs {
     }
 }
 
-/// Collection of unencoded (bytes) trailer key–value pairs.
+/// Collection of unencoded (bytes) trailers.
 ///
 /// Use `iter()` to get access to the values.
 pub struct MessageTrailersBytes(MessageTrailers);
@@ -155,7 +155,7 @@ fn to_raw_tuple(trailers: &MessageTrailers, index: usize) -> (*const c_char, *co
     }
 }
 
-/// Borrowed iterator over the UTF-8-encoded trailer.
+/// Borrowed iterator over the UTF-8-encoded trailers.
 pub struct MessageTrailersStrsIterator<'a>(MessageTrailersIterator<'a>);
 
 impl<'pair> Iterator for MessageTrailersStrsIterator<'pair> {
@@ -197,7 +197,7 @@ fn to_str_tuple(trailers: &MessageTrailers, index: usize) -> (&str, &str) {
     }
 }
 
-/// Borrowed iterator over the raw (bytes) trailer.
+/// Borrowed iterator over the raw (bytes) trailers.
 pub struct MessageTrailersBytesIterator<'a>(MessageTrailersIterator<'a>);
 
 impl<'pair> Iterator for MessageTrailersBytesIterator<'pair> {

From 25085063074f16d134bda5e70df498a18e657069 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Sat, 16 Oct 2021 12:19:13 +0200
Subject: [PATCH 19/20] `cargo fmt`

---
 src/message.rs | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index 51fa9cf908..398f11659f 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -46,9 +46,7 @@ pub fn message_trailers_strs(message: &str) -> Result<MessageTrailersStrs, Error
 /// Use this function when the message might not be UTF-8-encoded,
 /// or if you want to handle the returned trailer key–value pairs
 /// as bytes.
-pub fn message_trailers_bytes<S: IntoCString>(
-    message: S,
-) -> Result<MessageTrailersBytes, Error> {
+pub fn message_trailers_bytes<S: IntoCString>(message: S) -> Result<MessageTrailersBytes, Error> {
     _message_trailers(message.into_c_string()?).map(|res| MessageTrailersBytes(res))
 }
 
@@ -331,10 +329,7 @@ Signed-off-by: Lieutenant \xe2\x28\xa1prout
 ";
 
         let trailer = message_trailers_bytes(&message4[..]).unwrap();
-        let expected = (
-            &b"Signed-off-by"[..],
-            &b"Lieutenant \xe2\x28\xa1prout"[..],
-        );
+        let expected = (&b"Signed-off-by"[..], &b"Lieutenant \xe2\x28\xa1prout"[..]);
         let actual = trailer.iter().next().unwrap();
         assert_eq!(expected, actual);
 

From f35b68fd05759720a4168bfce31c709abf388406 Mon Sep 17 00:00:00 2001
From: Kristoffer Haugsbakk <code@khaugsbakk.name>
Date: Thu, 14 Oct 2021 22:42:25 +0200
Subject: [PATCH 20/20] Undo accidental and unrelated edit

(cherry picked from commit cd4c2dbee5f91610011913d3cd10e5786fbceef5)
---
 src/util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/util.rs b/src/util.rs
index a31e63bce2..1c6001ddbf 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -204,7 +204,7 @@ pub fn c_cmp_to_ordering(cmp: c_int) -> Ordering {
 pub fn path_to_repo_path(path: &Path) -> Result<CString, Error> {
     macro_rules! err {
         ($msg:literal, $path:expr) => {
-            return Err(Error::from_str(&format!($msg, $path.display())));
+            return Err(Error::from_str(&format!($msg, $path.display())))
         };
     }
     match path.components().next() {