feat!: support for precompose_unicode, which is now an extra argument in the Store constructor.

Author: Byron

gix-ref/src/store/file/loose/iter.rs

@@ -13,13 +13,18 @@ pub(in crate::store_impl::file) struct SortedLoosePaths {
 }
 
 impl SortedLoosePaths {
-    pub fn at(path: &Path, base: PathBuf, filename_prefix: Option<BString>) -> Self {
+    pub fn at(path: &Path, base: PathBuf, filename_prefix: Option<BString>, precompose_unicode: bool) -> Self {
         SortedLoosePaths {
             base,
             filename_prefix,
             file_walk: path.is_dir().then(|| {
                 // serial iteration as we expect most refs in packed-refs anyway.
-                gix_features::fs::walkdir_sorted_new(path, gix_features::fs::walkdir::Parallelism::Serial).into_iter()
+                gix_features::fs::walkdir_sorted_new(
+                    path,
+                    gix_features::fs::walkdir::Parallelism::Serial,
+                    precompose_unicode,
+                )
+                .into_iter()
             }),
         }
     }
@@ -32,10 +37,10 @@ impl Iterator for SortedLoosePaths {
         for entry in self.file_walk.as_mut()?.by_ref() {
             match entry {
                 Ok(entry) => {
-                    if !entry.file_type().is_file() {
+                    if !entry.file_type().map_or(false, |ft| ft.is_file()) {
                         continue;
                     }
-                    let full_path = entry.path().to_owned();
+                    let full_path = entry.path().into_owned();
                     if let Some((prefix, name)) = self
                         .filename_prefix
                         .as_deref()

gix-ref/src/store/file/loose/mod.rs

@@ -33,7 +33,13 @@ mod init {
         /// Create a new instance at the given `git_dir`, which commonly is a standard git repository with a
         /// `refs/` subdirectory.
         /// The `object_hash` defines which kind of hash we should recognize.
-        pub fn at(git_dir: PathBuf, write_reflog: file::WriteReflog, object_hash: gix_hash::Kind) -> Self {
+        /// `precompose_unicode` is used to set to the value of [`Self::precompose_unicode].
+        pub fn at(
+            git_dir: PathBuf,
+            write_reflog: file::WriteReflog,
+            object_hash: gix_hash::Kind,
+            precompose_unicode: bool,
+        ) -> Self {
             file::Store {
                 git_dir,
                 packed_buffer_mmap_threshold: packed_refs_mmap_threshold(),
@@ -42,6 +48,7 @@ mod init {
                 namespace: None,
                 packed: gix_fs::SharedFileSnapshotMut::new().into(),
                 object_hash,
+                precompose_unicode,
             }
         }
 
@@ -52,6 +59,7 @@ mod init {
             common_dir: PathBuf,
             write_reflog: file::WriteReflog,
             object_hash: gix_hash::Kind,
+            precompose_unicode: bool,
         ) -> Self {
             file::Store {
                 git_dir,
@@ -61,6 +69,7 @@ mod init {
                 namespace: None,
                 packed: gix_fs::SharedFileSnapshotMut::new().into(),
                 object_hash,
+                precompose_unicode,
             }
         }
     }

gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs

@@ -17,7 +17,7 @@ fn hex_to_id(hex: &str) -> gix_hash::ObjectId {
 
 fn empty_store(writemode: WriteReflog) -> Result<(TempDir, file::Store)> {
     let dir = TempDir::new()?;
-    let store = file::Store::at(dir.path().into(), writemode, gix_hash::Kind::Sha1);
+    let store = file::Store::at(dir.path().into(), writemode, gix_hash::Kind::Sha1, false);
     Ok((dir, store))
 }
 

gix-ref/src/store/file/mod.rs

@@ -27,6 +27,9 @@ pub struct Store {
     pub write_reflog: WriteReflog,
     /// The namespace to use for edits and reads
     pub namespace: Option<Namespace>,
+    /// If set, we will convert decomposed unicode like `a\u308` into precomposed unicode like `ä` when reading
+    /// ref names from disk.
+    pub precompose_unicode: bool,
     /// A packed buffer which can be mapped in one version and shared as such.
     /// It's updated only in one spot, which is prior to reading it based on file stamps.
     /// Doing it like this has the benefit of being able to hand snapshots out to people without blocking others from updating it.

gix-ref/src/store/file/overlay_iter.rs

@@ -220,15 +220,18 @@ impl file::Store {
 pub(crate) enum IterInfo<'a> {
     Base {
         base: &'a Path,
+        precompose_unicode: bool,
     },
     BaseAndIterRoot {
         base: &'a Path,
         iter_root: PathBuf,
         prefix: Cow<'a, Path>,
+        precompose_unicode: bool,
     },
     PrefixAndBase {
         base: &'a Path,
         prefix: &'a Path,
+        precompose_unicode: bool,
     },
     ComputedIterationRoot {
         /// The root to iterate over
@@ -239,6 +242,8 @@ pub(crate) enum IterInfo<'a> {
         prefix: Cow<'a, Path>,
         /// The remainder of the prefix that wasn't a valid path
         remainder: Option<BString>,
+        /// If `true`, we will convert decomposed into precomposed unicode.
+        precompose_unicode: bool,
     },
 }
 
@@ -255,24 +260,33 @@ impl<'a> IterInfo<'a> {
 
     fn into_iter(self) -> Peekable<SortedLoosePaths> {
         match self {
-            IterInfo::Base { base } => SortedLoosePaths::at(&base.join("refs"), base.into(), None),
+            IterInfo::Base {
+                base,
+                precompose_unicode,
+            } => SortedLoosePaths::at(&base.join("refs"), base.into(), None, precompose_unicode),
             IterInfo::BaseAndIterRoot {
                 base,
                 iter_root,
                 prefix: _,
-            } => SortedLoosePaths::at(&iter_root, base.into(), None),
-            IterInfo::PrefixAndBase { base, prefix } => SortedLoosePaths::at(&base.join(prefix), base.into(), None),
+                precompose_unicode,
+            } => SortedLoosePaths::at(&iter_root, base.into(), None, precompose_unicode),
+            IterInfo::PrefixAndBase {
+                base,
+                prefix,
+                precompose_unicode,
+            } => SortedLoosePaths::at(&base.join(prefix), base.into(), None, precompose_unicode),
             IterInfo::ComputedIterationRoot {
                 iter_root,
                 base,
                 prefix: _,
                 remainder,
-            } => SortedLoosePaths::at(&iter_root, base.into(), remainder),
+                precompose_unicode,
+            } => SortedLoosePaths::at(&iter_root, base.into(), remainder, precompose_unicode),
         }
         .peekable()
     }
 
-    fn from_prefix(base: &'a Path, prefix: Cow<'a, Path>) -> std::io::Result<Self> {
+    fn from_prefix(base: &'a Path, prefix: Cow<'a, Path>, precompose_unicode: bool) -> std::io::Result<Self> {
         if prefix.is_absolute() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
@@ -292,6 +306,7 @@ impl<'a> IterInfo<'a> {
                 base,
                 iter_root,
                 prefix,
+                precompose_unicode,
             })
         } else {
             let filename_prefix = iter_root
@@ -314,6 +329,7 @@ impl<'a> IterInfo<'a> {
                 prefix,
                 iter_root,
                 remainder: filename_prefix,
+                precompose_unicode,
             })
         }
     }
@@ -332,16 +348,24 @@ impl file::Store {
                 IterInfo::PrefixAndBase {
                     base: self.git_dir(),
                     prefix: namespace.to_path(),
+                    precompose_unicode: self.precompose_unicode,
                 },
                 self.common_dir().map(|base| IterInfo::PrefixAndBase {
                     base,
                     prefix: namespace.to_path(),
+                    precompose_unicode: self.precompose_unicode,
                 }),
                 packed,
             ),
             None => self.iter_from_info(
-                IterInfo::Base { base: self.git_dir() },
-                self.common_dir().map(|base| IterInfo::Base { base }),
+                IterInfo::Base {
+                    base: self.git_dir(),
+                    precompose_unicode: self.precompose_unicode,
+                },
+                self.common_dir().map(|base| IterInfo::Base {
+                    base,
+                    precompose_unicode: self.precompose_unicode,
+                }),
                 packed,
             ),
         }
@@ -357,19 +381,20 @@ impl file::Store {
     ) -> std::io::Result<LooseThenPacked<'p, 's>> {
         match self.namespace.as_ref() {
             None => {
-                let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix.into())?;
+                let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix.into(), self.precompose_unicode)?;
                 let common_dir_info = self
                     .common_dir()
-                    .map(|base| IterInfo::from_prefix(base, prefix.into()))
+                    .map(|base| IterInfo::from_prefix(base, prefix.into(), self.precompose_unicode))
                     .transpose()?;
                 self.iter_from_info(git_dir_info, common_dir_info, packed)
             }
             Some(namespace) => {
                 let prefix = namespace.to_owned().into_namespaced_prefix(prefix);
-                let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix.clone().into())?;
+                let git_dir_info =
+                    IterInfo::from_prefix(self.git_dir(), prefix.clone().into(), self.precompose_unicode)?;
                 let common_dir_info = self
                     .common_dir()
-                    .map(|base| IterInfo::from_prefix(base, prefix.into()))
+                    .map(|base| IterInfo::from_prefix(base, prefix.into(), self.precompose_unicode))
                     .transpose()?;
                 self.iter_from_info(git_dir_info, common_dir_info, packed)
             }

gix-ref/src/store/general/init.rs

@@ -21,12 +21,18 @@ impl crate::Store {
     /// Create a new store at the given location, typically the `.git/` directory.
     ///
     /// `object_hash` defines the kind of hash to assume when dealing with refs.
-    pub fn at(git_dir: PathBuf, reflog_mode: WriteReflog, object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    /// `precompose_unicode` is used to set to the value of [`crate::file::Store::precompose_unicode].
+    pub fn at(
+        git_dir: PathBuf,
+        reflog_mode: WriteReflog,
+        object_hash: gix_hash::Kind,
+        precompose_unicode: bool,
+    ) -> Result<Self, Error> {
         // for now, just try to read the directory - later we will do that naturally as we have to figure out if it's a ref-table or not.
         std::fs::read_dir(&git_dir)?;
         Ok(crate::Store {
             inner: crate::store::State::Loose {
-                store: file::Store::at(git_dir, reflog_mode, object_hash),
+                store: file::Store::at(git_dir, reflog_mode, object_hash, precompose_unicode),
             },
         })
     }

gix-ref/tests/file/mod.rs

@@ -19,6 +19,7 @@ pub fn store_at(name: &str) -> crate::Result<Store> {
         path.join(".git"),
         gix_ref::store::WriteReflog::Normal,
         gix_hash::Kind::Sha1,
+        false,
     ))
 }
 
@@ -27,7 +28,12 @@ fn store_writable(name: &str) -> crate::Result<(gix_testtools::tempfile::TempDir
     let git_dir = dir.path().join(".git");
     Ok((
         dir,
-        Store::at(git_dir, gix_ref::store::WriteReflog::Normal, gix_hash::Kind::Sha1),
+        Store::at(
+            git_dir,
+            gix_ref::store::WriteReflog::Normal,
+            gix_hash::Kind::Sha1,
+            false,
+        ),
     ))
 }
 

gix-ref/tests/file/store/reflog.rs

@@ -3,6 +3,7 @@ fn store() -> crate::Result<crate::file::Store> {
         gix_testtools::scripted_fixture_read_only_standalone("make_repo_for_reflog.sh")?.join(".git"),
         gix_ref::store::WriteReflog::Disable,
         gix_hash::Kind::Sha1,
+        false,
     ))
 }
 

gix-ref/tests/file/transaction/mod.rs

@@ -28,6 +28,7 @@ pub(crate) mod prepare_and_commit {
             dir.path().into(),
             gix_ref::store::WriteReflog::Normal,
             gix_hash::Kind::Sha1,
+            false,
         );
         Ok((dir, store))
     }

gix-ref/tests/file/worktree.rs

@@ -29,7 +29,7 @@ fn main_store(
     let (dir, tmp) = dir(packed, writable)?;
     let git_dir = dir.join("repo").join(".git");
     Ok((
-        gix_ref::file::Store::at(git_dir.clone(), Default::default(), Default::default()),
+        gix_ref::file::Store::at(git_dir.clone(), Default::default(), Default::default(), false),
         gix_odb::at(git_dir.join("objects"))?,
         tmp,
     ))
@@ -50,7 +50,13 @@ fn worktree_store(
         .into_repository_and_work_tree_directories();
     let common_dir = git_dir.join("../..");
     Ok((
-        gix_ref::file::Store::for_linked_worktree(git_dir, common_dir.clone(), Default::default(), Default::default()),
+        gix_ref::file::Store::for_linked_worktree(
+            git_dir,
+            common_dir.clone(),
+            Default::default(),
+            Default::default(),
+            false,
+        ),
         gix_odb::at(common_dir.join("objects"))?,
         tmp,
     ))