More aggressive mailmap substitution for better results (#364)

This is not what git seems to do, but it yields better results
as more entries are unified and assigned to their respective authors.

And it's valid, as emails are case-insensitive so they should match
that way when unifying them.

Author: Byron

git-mailmap/src/snapshot.rs

@@ -14,7 +14,15 @@ pub struct ResolvedSignature<'a> {
 }
 
 impl<'a> ResolvedSignature<'a> {
-    fn try_new(new_email: Option<&'a BString>, new_name: Option<&'a BString>) -> Option<Self> {
+    fn try_new(
+        new_email: Option<&'a BString>,
+        matched_email: &'a BStr,
+        current_email: &'_ BStr,
+        new_name: Option<&'a BString>,
+    ) -> Option<Self> {
+        let new_email = new_email
+            .map(|n| n.as_bstr())
+            .or_else(|| (matched_email != current_email).then(|| matched_email));
         match (new_email, new_name) {
             (None, None) => None,
             (new_email, new_name) => Some(ResolvedSignature {
@@ -244,6 +252,10 @@ impl Snapshot {
     /// 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.
     ///
+    /// Note that opposed to what git seems to do, we also normalize the case of email addresses to match the one
+    /// given in the mailmap. That is, if `Alex@example.com` is the current email, it will be matched and replaced with
+    /// `alex@example.com`. This leads to better mapping results and saves entries in the mailmap.
+    ///
     /// This is the fastest possible lookup as there is no allocation.
     pub fn try_resolve_ref<'a>(&'a self, signature: git_actor::SignatureRef<'_>) -> Option<ResolvedSignature<'a>> {
         let email: EncodedStringRef<'_> = signature.email.into();
@@ -257,10 +269,20 @@ impl Snapshot {
 
         match entry.entries_by_old_name.binary_search_by(|e| e.old_name.cmp_ref(name)) {
             Ok(pos) => {
-                let entry = &entry.entries_by_old_name[pos];
-                ResolvedSignature::try_new(entry.new_email.as_ref(), entry.new_name.as_ref())
+                let name_entry = &entry.entries_by_old_name[pos];
+                ResolvedSignature::try_new(
+                    name_entry.new_email.as_ref(),
+                    entry.old_email.as_bstr(),
+                    signature.email,
+                    name_entry.new_name.as_ref(),
+                )
             }
-            Err(_) => ResolvedSignature::try_new(entry.new_email.as_ref(), entry.new_name.as_ref()),
+            Err(_) => ResolvedSignature::try_new(
+                entry.new_email.as_ref(),
+                entry.old_email.as_bstr(),
+                signature.email,
+                entry.new_name.as_ref(),
+            ),
         }
     }
 

git-mailmap/tests/snapshot/mod.rs

@@ -6,8 +6,8 @@ fn try_resolve() {
     let snapshot = Snapshot::from_bytes(&fixture_bytes("typical.txt"));
     assert_eq!(
         snapshot.try_resolve(signature("Foo", "Joe@example.com").to_ref()),
-        Some(signature("Joe R. Developer", "Joe@example.com")),
-        "resolved signatures contain all original fields, but normalizes only what's in the mapping, lookup is case-insensitive"
+        Some(signature("Joe R. Developer", "joe@example.com")),
+        "resolved signatures contain all original fields, and normalize the email as well to match the one that it was looked up with"
     );
     assert_eq!(
         snapshot.try_resolve(signature("Joe", "bugs@example.com").to_ref()),
@@ -56,7 +56,7 @@ fn try_resolve() {
 fn non_name_and_name_mappings_will_not_clash() {
     let entries = vec![
         // add mapping from email
-        git_mailmap::Entry::change_name_and_email_by_email("new-name", "new-email", "old-email"),
+        git_mailmap::Entry::change_name_by_email("new-name", "old-email"),
         // add mapping from name and email
         git_mailmap::Entry::change_name_and_email_by_name_and_email(
             "other-new-name",
@@ -69,12 +69,12 @@ fn non_name_and_name_mappings_will_not_clash() {
         let snapshot = Snapshot::new(entries);
 
         assert_eq!(
-            snapshot.try_resolve(signature("replace-by-email", "old-email").to_ref()),
-            Some(signature("new-name", "new-email")),
-            "it can match by email only"
+            snapshot.try_resolve(signature("replace-by-email", "Old-Email").to_ref()),
+            Some(signature("new-name", "old-email")),
+            "it can match by email only, and the email is normalized"
         );
         assert_eq!(
-            snapshot.try_resolve(signature("old-name", "old-email").to_ref()),
+            snapshot.try_resolve(signature("old-name", "Old-Email").to_ref()),
             Some(signature("other-new-name", "other-new-email")),
             "it can match by email and name as well"
         );