sketch Snapshot API to implement map building and signature resolution (#366)

Author: Byron

Cargo.lock

@@ -12,11 +12,12 @@ doctest = false
 
 [features]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde1 = ["serde", "bstr/serde1"]
+serde1 = ["serde", "bstr/serde1", "git-actor/serde1"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+git-actor = { version = "^0.8.1", path = "../git-actor" }
 bstr = { version = "0.2.13", default-features = false, features = ["std", "unicode"]}
 quick-error = "2.0.0"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}

git-mailmap/Cargo.toml

@@ -8,6 +8,10 @@ pub fn parse(buf: &[u8]) -> parse::Lines<'_> {
     parse::Lines::new(buf)
 }
 
+pub fn parse_ignore_errors(buf: &[u8]) -> impl Iterator<Item = Entry<'_>> {
+    parse(buf).filter_map(Result::ok)
+}
+
 mod entry;
 
 mod snapshot;

git-mailmap/src/lib.rs

@@ -1,4 +1,5 @@
-use bstr::{BString, ByteSlice};
+use crate::Snapshot;
+use bstr::{BStr, BString, ByteSlice};
 use std::cmp::Ordering;
 use std::ops::Deref;
 
@@ -9,6 +10,36 @@ enum EncodedString {
     Unknown(BString),
 }
 
+impl EncodedString {
+    fn cmp_ref(&self, other: EncodedStringRef<'_>) -> Ordering {
+        match (self, other) {
+            (EncodedString::Utf8(a), EncodedStringRef::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)
+            }
+            (EncodedString::Unknown(a), EncodedStringRef::Unknown(b)) => a.deref().as_bstr().cmp(b),
+            (EncodedString::Utf8(a), EncodedStringRef::Unknown(b)) => a.as_bytes().cmp(b.as_ref()),
+            (EncodedString::Unknown(a), EncodedStringRef::Utf8(b)) => a.deref().as_bytes().cmp(b.as_bytes()),
+        }
+    }
+}
+
+#[cfg_attr(test, derive(Debug))]
+enum EncodedStringRef<'a> {
+    Utf8(&'a str),
+    Unknown(&'a BStr),
+}
+
+impl EncodedString {
+    fn to_ref(&self) -> EncodedStringRef<'_> {
+        match self {
+            EncodedString::Unknown(v) => EncodedStringRef::Unknown(v.deref().as_bstr()),
+            EncodedString::Utf8(v) => EncodedStringRef::Utf8(v),
+        }
+    }
+}
+
 impl Eq for EncodedString {}
 
 impl PartialEq<Self> for EncodedString {
@@ -25,22 +56,12 @@ impl PartialOrd<Self> for EncodedString {
 
 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()),
-        }
+        self.cmp_ref(other.to_ref())
     }
 }
 
 #[derive(Clone)]
-pub(crate) struct NameEntry {
+struct NameEntry {
     new_name: Option<BString>,
     new_email: Option<BString>,
     old_name: EncodedString,
@@ -55,6 +76,30 @@ pub(crate) struct EmailEntry {
     entries_by_old_name: Vec<NameEntry>,
 }
 
+impl Snapshot {
+    pub fn from_bytes(buf: &[u8]) -> Self {
+        Self::new(crate::parse_ignore_errors(buf))
+    }
+
+    pub fn new<'a>(entries: impl IntoIterator<Item = crate::Entry<'a>>) -> Self {
+        let mut snapshot = Self::default();
+        snapshot.extend(entries);
+        snapshot
+    }
+
+    pub fn extend<'a>(&mut self, entries: impl IntoIterator<Item = crate::Entry<'a>>) -> &mut Self {
+        todo!()
+    }
+
+    pub fn try_resolve(&self, signature: &git_actor::SignatureRef<'_>) -> Option<git_actor::Signature> {
+        todo!()
+    }
+
+    pub fn resolve(&self, signature: &git_actor::SignatureRef<'_>) -> git_actor::Signature {
+        self.try_resolve(signature).unwrap_or_else(|| signature.to_owned())
+    }
+}
+
 #[cfg(test)]
 mod encoded_string {
     use crate::snapshot::EncodedString;

git-mailmap/src/snapshot.rs

@@ -1 +1,2 @@
 mod parse;
+mod snapshot;

git-mailmap/tests/mailmap.rs

@@ -1,9 +1,9 @@
 use git_mailmap::{parse, Entry};
-use git_testtools::fixture_path;
+use git_testtools::fixture_bytes;
 
 #[test]
 fn line_numbers_are_counted_correctly_in_errors() {
-    let input = std::fs::read(fixture_path("invalid.txt")).unwrap();
+    let input = fixture_bytes("invalid.txt");
     let mut actual = git_mailmap::parse(&input).collect::<Vec<_>>().into_iter();
     assert_eq!(actual.len(), 2);
 
@@ -16,7 +16,7 @@ fn line_numbers_are_counted_correctly_in_errors() {
 
 #[test]
 fn a_typical_mailmap() {
-    let input = std::fs::read(fixture_path("typical.txt")).unwrap();
+    let input = fixture_bytes("typical.txt");
     let actual = git_mailmap::parse(&input).map(Result::unwrap).collect::<Vec<_>>();
     assert_eq!(
         actual,

git-mailmap/tests/parse/mod.rs

@@ -0,0 +1,31 @@
+use git_mailmap::Snapshot;
+use git_testtools::fixture_bytes;
+
+#[test]
+#[ignore]
+fn try_resolve() {
+    let snapshot = snapshot();
+    let sig = signature("Foo", "Joe@example.com");
+    assert_eq!(
+        snapshot.try_resolve(&sig.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"
+    );
+}
+
+fn snapshot() -> Snapshot {
+    Snapshot::from_bytes(&fixture_bytes("typical.txt"))
+}
+
+fn signature(name: &str, email: &str) -> git_actor::Signature {
+    git_actor::Signature {
+        name: name.into(),
+        email: email.into(),
+        time: git_actor::Time {
+            // marker
+            time: 42,
+            offset: 53,
+            sign: git_actor::Sign::Minus,
+        },
+    }
+}