provide a platform for multiple queries at a dir cache level (#301)

This allows to perform work only once while allowing subsequent queries to the cached information, like `is_excluded()` or `attributes()`.

Sebastian Thiel committed 4 years ago

Commit 48be3821 parent dc12f883 files · +29 −20Browse files

Unified · Split

3 files

git-worktree/src/fs/cache.rs +21 −4
git-worktree/src/index/entry.rs +1 −1
git-worktree/tests/worktree/fs/cache.rs +7 −15

git-worktree/src/fs/cache.rs+21−4

     ProvideAttributesAndIgnore,
 }
+pub struct Platform<'a> {
+    parent: &'a Cache,
+}
+impl<'a> Platform<'a> {
+    /// The full path to `relative` will be returned for use on the file system.
+    pub fn leading_dir(&self) -> &'a Path {
+        self.parent.stack.current()
+    }
+}
+impl<'a> std::fmt::Debug for Platform<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.leading_dir(), f)
+    }
+}
 impl Cache {
     /// Create a new instance with `root` being the base for all future paths we handle, assuming it to be valid which includes
     /// symbolic links to be included in it as well.
     /// Append the `relative` path to the root directory the cache contains and efficiently create leading directories
     /// unless `mode` indicates `relative` points to a directory itself in which case the entire resulting path is created as directory.
     ///
-    /// The full path to `relative` will be returned for use on the file system.
+    /// Provide access to cached information for that `relative` entry via the platform returned.
-    pub fn append_relative_path_assure_leading_dir(
+    pub fn at_entry(
         &mut self,
         relative: impl AsRef<Path>,
         mode: git_index::entry::Mode,
-    ) -> std::io::Result<&Path> {
+    ) -> std::io::Result<Platform<'_>> {
         #[cfg(debug_assertions)]
         let mkdir_calls = &mut self.test_mkdir_calls;
         let unlink_on_collision = self.unlink_on_collision;
             },
             |_| {},
         )?;
-        Ok(self.stack.current())
+        Ok(Platform { parent: self })
     }
 }

git-worktree/src/index/entry.rs+1−1

@@ -37,7 +37,7 @@ where · 36 unmodified lines
37	git_features::path::from_byte_slice(entry_path).map_err(\|_\| index::checkout::Error::IllformedUtf8 {	37	git_features::path::from_byte_slice(entry_path).map_err(\|_\| index::checkout::Error::IllformedUtf8 {
38	path: entry_path.to_owned(),	38	path: entry_path.to_owned(),
39	})?;	39	})?;
40	let dest = path_cache.append_relative_path_assure_leading_dir(dest_relative, entry.mode)?;	40	let dest = path_cache.at_entry(dest_relative, entry.mode)?.leading_dir();
41		41
42	let object_size = match entry.mode {	42	let object_size = match entry.mode {
43	git_index::entry::Mode::FILE \| git_index::entry::Mode::FILE_EXECUTABLE => {	43	git_index::entry::Mode::FILE \| git_index::entry::Mode::FILE_EXECUTABLE => {

git-worktree/tests/worktree/fs/cache.rs+7−15

         );
         assert_eq!(cache.test_mkdir_calls, 0);
-        let path = cache
+        let path = cache.at_entry("hello", Mode::FILE).unwrap().leading_dir();
-            .append_relative_path_assure_leading_dir("hello", Mode::FILE)
-            .unwrap();
         assert!(!path.parent().unwrap().exists(), "prefix itself is never created");
         assert_eq!(cache.test_mkdir_calls, 0);
     }
             ("link", Mode::SYMLINK),
         ] {
             let path = cache
-                .append_relative_path_assure_leading_dir(Path::new("dir").join(name), *mode)
+                .at_entry(Path::new("dir").join(name), *mode)
-                .unwrap();
+                .unwrap()
+                .leading_dir();
             assert!(path.parent().unwrap().is_dir(), "dir exists");
         }
         let (mut cache, tmp) = new_cache();
         std::fs::create_dir(tmp.path().join("dir")).unwrap();
-        let path = cache
+        let path = cache.at_entry("dir/file", Mode::FILE).unwrap().leading_dir();
-            .append_relative_path_assure_leading_dir("dir/file", Mode::FILE)
-            .unwrap();
         assert!(path.parent().unwrap().is_dir(), "directory is still present");
         assert!(!path.exists(), "it won't create the file");
         assert_eq!(cache.test_mkdir_calls, 1);
             cache.unlink_on_collision = false;
             let relative_path = format!("{}/file", dirname);
             assert_eq!(
-                cache
+                cache.at_entry(&relative_path, Mode::FILE).unwrap_err().kind(),
-                    .append_relative_path_assure_leading_dir(&relative_path, Mode::FILE)
-                    .unwrap_err()
-                    .kind(),
                 std::io::ErrorKind::AlreadyExists
             );
         }
         for dirname in &["link-to-dir", "file-in-dir"] {
             cache.unlink_on_collision = true;
             let relative_path = format!("{}/file", dirname);
-            let path = cache
+            let path = cache.at_entry(&relative_path, Mode::FILE).unwrap().leading_dir();
-                .append_relative_path_assure_leading_dir(&relative_path, Mode::FILE)
-                .unwrap();
             assert!(path.parent().unwrap().is_dir(), "directory was forcefully created");
             assert!(!path.exists());
         }