feat: gix repository mailmap entries (#366)

Author: Byron

git-mailmap/src/snapshot.rs

@@ -32,6 +32,12 @@ enum EncodedString {
 }
 
 impl EncodedString {
+    fn as_bstr(&self) -> &BStr {
+        match self {
+            EncodedString::Utf8(v) => v.as_str().into(),
+            EncodedString::Unknown(v) => v.as_bstr(),
+        }
+    }
     fn cmp_ref(&self, other: EncodedStringRef<'_>) -> Ordering {
         match (self, other) {
             (EncodedString::Utf8(a), EncodedStringRef::Utf8(b)) => {
@@ -206,6 +212,34 @@ impl Snapshot {
         self
     }
 
+    /// Transform our acceleration structure into a list of entries.
+    ///
+    /// Note that the order is different from how they were obtained initially, and are explicitly ordered by
+    /// (old_email, old_name).
+    pub fn entries(&self) -> Vec<crate::Entry<'_>> {
+        let mut out = Vec::with_capacity(self.entries_by_old_email.len());
+        for entry in &self.entries_by_old_email {
+            if entry.new_email.is_some() || entry.new_name.is_some() {
+                out.push(crate::Entry {
+                    new_name: entry.new_name.as_ref().map(|b| b.as_bstr()),
+                    new_email: entry.new_email.as_ref().map(|b| b.as_bstr()),
+                    old_name: None,
+                    old_email: entry.old_email.as_bstr(),
+                });
+            }
+
+            for name_entry in &entry.entries_by_old_name {
+                out.push(crate::Entry {
+                    new_name: name_entry.new_name.as_ref().map(|b| b.as_bstr()),
+                    new_email: name_entry.new_email.as_ref().map(|b| b.as_bstr()),
+                    old_name: name_entry.old_name.as_bstr().into(),
+                    old_email: entry.old_email.as_bstr(),
+                });
+            }
+        }
+        out
+    }
+
     /// Try to resolve `signature` by its contained email and name and provide resolved/mapped names as reference.
     /// Return `None` if no such mapping was found.
     ///

git-mailmap/tests/snapshot/mod.rs

@@ -3,7 +3,7 @@ use git_testtools::fixture_bytes;
 
 #[test]
 fn try_resolve() {
-    let snapshot = snapshot();
+    let snapshot = Snapshot::from_bytes(&fixture_bytes("typical.txt"));
     assert_eq!(
         snapshot.try_resolve(&signature("Foo", "[email protected]").to_ref()),
         Some(signature("Joe R. Developer", "[email protected]")),
@@ -48,6 +48,8 @@ fn try_resolve() {
         "matched email, unmatched name"
     );
     assert_eq!(snapshot.resolve(&sig.to_ref()), sig);
+
+    assert_eq!(snapshot.entries().len(), 5);
 }
 
 #[test]
@@ -76,6 +78,8 @@ fn non_name_and_name_mappings_will_not_clash() {
             Some(signature("other-new-name", "other-new-email")),
             "it can match by email and name as well"
         );
+
+        assert_eq!(snapshot.entries().len(), 2);
     }
 }
 
@@ -105,10 +109,8 @@ fn overwrite_entries() {
         Some(signature("unchanged", "new-d-email-overwritten")),
         "email by email"
     );
-}
 
-fn snapshot() -> Snapshot {
-    Snapshot::from_bytes(&fixture_bytes("typical.txt"))
+    assert_eq!(snapshot.entries().len(), 4);
 }
 
 fn signature(name: &str, email: &str) -> git_actor::Signature {

git-repository/Cargo.toml

@@ -41,7 +41,7 @@ one-stop-shop = [ "local", "local-time-support" ]
 #! ### Other
 
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde1 = ["git-pack/serde1", "git-object/serde1", "git-protocol/serde1", "git-transport/serde1", "git-ref/serde1", "git-odb/serde1", "git-index/serde1"]
+serde1 = ["git-pack/serde1", "git-object/serde1", "git-protocol/serde1", "git-transport/serde1", "git-ref/serde1", "git-odb/serde1", "git-index/serde1", "git-mailmap/serde1"]
 ## Activate other features that maximize performance, like usage of threads, `zlib-ng` and access to caching in object databases.
 ## **Note** that
 max-performance = ["git-features/parallel", "git-features/zlib-ng-compat", "git-pack/pack-cache-lru-static", "git-pack/pack-cache-lru-dynamic"]

git-repository/src/lib.rs

@@ -247,11 +247,11 @@ pub mod mailmap {
 
     ///
     pub mod load {
-        /// The error returned by [`crate::Repository::load_mailmap()`].
+        /// The error returned by [`crate::Repository::load_mailmap_into()`].
         #[derive(Debug, thiserror::Error)]
         #[allow(missing_docs)]
         pub enum Error {
-            #[error("A mailmap file could not be loaded from disk")]
+            #[error("The mailmap file declared in `mailmap.file` could not be read")]
             Io(#[from] std::io::Error),
             #[error("The configured mailmap.blob could not be parsed")]
             BlobSpec(#[from] git_hash::decode::Error),

git-repository/src/repository/snapshots.rs

@@ -96,11 +96,7 @@ impl crate::Repository {
         {
             buf.clear();
             std::io::copy(&mut file, &mut buf)
-                .map_err(|e| {
-                    if e.kind() != std::io::ErrorKind::NotFound {
-                        err.get_or_insert(e.into());
-                    }
-                })
+                .map_err(|e| err.get_or_insert(e.into()))
                 .ok();
             target.merge(git_mailmap::parse_ignore_errors(&buf));
         }

gitoxide-core/src/repository/mailmap.rs

@@ -1,12 +1,35 @@
 use crate::OutputFormat;
 use git_repository as git;
+use git_repository::bstr::ByteSlice;
+use git_repository::mailmap::Entry;
 use std::io;
 use std::path::PathBuf;
 
+#[cfg(feature = "serde1")]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize))]
+struct JsonEntry {
+    new_name: Option<String>,
+    new_email: Option<String>,
+    old_name: Option<String>,
+    old_email: String,
+}
+
+#[cfg(feature = "serde1")]
+impl<'a> From<Entry<'a>> for JsonEntry {
+    fn from(v: Entry<'a>) -> Self {
+        JsonEntry {
+            new_name: v.new_name().map(|s| s.to_str_lossy().into_owned()),
+            new_email: v.new_email().map(|s| s.to_str_lossy().into_owned()),
+            old_name: v.old_name().map(|s| s.to_str_lossy().into_owned()),
+            old_email: v.old_email().to_str_lossy().into_owned(),
+        }
+    }
+}
+
 pub fn entries(
     repository: PathBuf,
     format: OutputFormat,
-    mut out: impl io::Write,
+    out: impl io::Write,
     mut err: impl io::Write,
 ) -> anyhow::Result<()> {
     if format == OutputFormat::Human {
@@ -16,8 +39,14 @@ pub fn entries(
     let repo = git::open(repository)?.apply_environment();
     let mut mailmap = git::mailmap::Snapshot::default();
     if let Err(e) = repo.load_mailmap_into(&mut mailmap) {
-        writeln!(err, "Error while loading mailmap: {}", e).ok();
+        writeln!(err, "Error while loading mailmap, the first error is: {}", e).ok();
     }
 
+    #[cfg(feature = "serde1")]
+    serde_json::to_writer_pretty(
+        out,
+        &mailmap.entries().into_iter().map(JsonEntry::from).collect::<Vec<_>>(),
+    )?;
+
     Ok(())
 }