sketch of mailmap snapshot for lookups (#366)

Author: Byron

git-mailmap/src/entry.rs

@@ -4,15 +4,15 @@ use bstr::BStr;
 impl<'a> Entry<'a> {
     pub fn change_name_by_email(proper_name: impl Into<&'a BStr>, commit_email: impl Into<&'a BStr>) -> Self {
         Entry {
-            canonical_name: Some(proper_name.into()),
-            commit_email: Some(commit_email.into()),
+            new_name: Some(proper_name.into()),
+            old_email: Some(commit_email.into()),
             ..Default::default()
         }
     }
     pub fn change_email_by_email(proper_email: impl Into<&'a BStr>, commit_email: impl Into<&'a BStr>) -> Self {
         Entry {
-            canonical_email: Some(proper_email.into()),
-            commit_email: Some(commit_email.into()),
+            new_email: Some(proper_email.into()),
+            old_email: Some(commit_email.into()),
             ..Default::default()
         }
     }
@@ -22,9 +22,9 @@ impl<'a> Entry<'a> {
         commit_email: impl Into<&'a BStr>,
     ) -> Self {
         Entry {
-            canonical_name: Some(proper_name.into()),
-            canonical_email: Some(proper_email.into()),
-            commit_email: Some(commit_email.into()),
+            new_name: Some(proper_name.into()),
+            new_email: Some(proper_email.into()),
+            old_email: Some(commit_email.into()),
             ..Default::default()
         }
     }
@@ -36,10 +36,10 @@ impl<'a> Entry<'a> {
         commit_email: impl Into<&'a BStr>,
     ) -> Self {
         Entry {
-            canonical_name: Some(proper_name.into()),
-            canonical_email: Some(proper_email.into()),
-            commit_name: Some(commit_name.into()),
-            commit_email: Some(commit_email.into()),
+            new_name: Some(proper_name.into()),
+            new_email: Some(proper_email.into()),
+            old_name: Some(commit_name.into()),
+            old_email: Some(commit_email.into()),
         }
     }
 }

git-mailmap/src/lib.rs

@@ -10,16 +10,24 @@ pub fn parse(buf: &[u8]) -> parse::Lines<'_> {
 
 mod entry;
 
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Default)]
+mod snapshot;
+
+#[derive(Default, Clone)]
+pub struct Snapshot {
+    /// Sorted by `old_email`
+    entries_by_old_email: Vec<snapshot::EmailEntry>,
+}
+
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy, Default)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Entry<'a> {
     #[cfg_attr(feature = "serde1", serde(borrow))]
     /// The name to map to.
-    canonical_name: Option<&'a BStr>,
+    new_name: Option<&'a BStr>,
     /// The email map to.
-    canonical_email: Option<&'a BStr>,
+    new_email: Option<&'a BStr>,
     /// The name to look for and replace.
-    commit_name: Option<&'a BStr>,
+    old_name: Option<&'a BStr>,
     /// The email to look for and replace.
-    commit_email: Option<&'a BStr>,
+    old_email: Option<&'a BStr>,
 }

git-mailmap/src/snapshot.rs

@@ -0,0 +1,84 @@
+use bstr::{BString, ByteSlice};
+use std::cmp::Ordering;
+use std::ops::Deref;
+
+#[cfg_attr(test, derive(Debug))]
+#[derive(Clone)]
+enum EncodedString {
+    Utf8(String),
+    Unknown(BString),
+}
+
+impl Eq for EncodedString {}
+
+impl PartialEq<Self> for EncodedString {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other) == Ordering::Equal
+    }
+}
+
+impl PartialOrd<Self> for EncodedString {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.cmp(other).into()
+    }
+}
+
+impl Ord for EncodedString {
+    fn cmp(&self, other: &Self) -> Ordering {
+        use EncodedString::*;
+        match (self, other) {
+            (Utf8(a), Utf8(b)) => {
+                let a = a.chars().map(|c| c.to_ascii_lowercase());
+                let b = b.chars().map(|c| c.to_ascii_lowercase());
+                a.cmp(b)
+            }
+            (Unknown(a), Unknown(b)) => a.cmp(b),
+            (Utf8(a), Unknown(b)) => a.as_bytes().cmp(b.as_ref()),
+            (Unknown(a), Utf8(b)) => a.deref().as_bytes().cmp(b.as_bytes()),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct NameEntry {
+    new_name: Option<BString>,
+    new_email: Option<BString>,
+    old_name: EncodedString,
+}
+
+#[derive(Clone)]
+pub(crate) struct EmailEntry {
+    new_name: Option<BString>,
+    new_email: Option<BString>,
+    old_email: EncodedString,
+
+    entries_by_old_name: Vec<NameEntry>,
+}
+
+#[cfg(test)]
+mod encoded_string {
+    use crate::snapshot::EncodedString;
+
+    #[test]
+    fn basic_ascii_case_folding() {
+        assert_eq!(
+            EncodedString::Utf8("FooBar".into()),
+            EncodedString::Utf8("foobar".into())
+        )
+    }
+
+    #[test]
+    fn no_advanced_unicode_folding() {
+        assert_ne!(EncodedString::Utf8("Masse".into()), EncodedString::Utf8("Maße".into()))
+    }
+
+    #[test]
+    fn unknown_encoding_pairs_do_not_try_to_ignore_cases() {
+        assert_ne!(EncodedString::Utf8("Foo".into()), EncodedString::Unknown("foo".into()));
+        assert_ne!(EncodedString::Unknown("Foo".into()), EncodedString::Utf8("foo".into()));
+        assert_ne!(
+            EncodedString::Unknown("Foo".into()),
+            EncodedString::Unknown("foo".into())
+        );
+    }
+}