Use a separate path mapping to enable clone-avoidance (#301)

Sebastian Thiel committed 4 years ago

Commit e525b5e1 parent 645ed503 files · +27 −3Browse files

Unified · Split

3 files

git-worktree/src/fs/cache/state.rs +2 −1
git-worktree/src/index/mod.rs +22 −2
git-worktree/tests/worktree/fs/cache.rs +3 −0

     pub(crate) fn build_attribute_list(
         &self,
         index: &git_index::State,
+        paths: &git_index::PathStorage,
         case: git_glob::pattern::Case,
     ) -> Vec<PathIdMapping> {
         let a1_backing;
             .entries()
             .iter()
             .filter_map(move |entry| {
-                let path = entry.path(index);
+                let path = entry.path_in(paths);
                 // Stage 0 means there is no merge going on, stage 2 means it's 'our' side of the merge, but then
                 // there won't be a stage 0.

git-worktree/src/index/mod.rs+22−2

     should_interrupt: &AtomicBool,
     options: checkout::Options,
 ) -> Result<checkout::Outcome, checkout::Error<E>>
+where
+    Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E> + Send + Clone,
+    E: std::error::Error + Send + Sync + 'static,
+{
+    let paths = index.take_path_backing();
+    let res = checkout_inner(index, &paths, dir, find, files, bytes, should_interrupt, options);
+    index.return_path_backing(paths);
+    res
+}
+#[allow(clippy::too_many_arguments)]
+fn checkout_inner<Find, E>(
+    index: &mut git_index::State,
+    paths: &git_index::PathStorage,
+    dir: impl Into<std::path::PathBuf>,
+    find: Find,
+    files: &mut impl Progress,
+    bytes: &mut impl Progress,
+    should_interrupt: &AtomicBool,
+    options: checkout::Options,
+) -> Result<checkout::Outcome, checkout::Error<E>>
 where
     Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E> + Send + Clone,
     E: std::error::Error + Send + Sync + 'static,
         git_glob::pattern::Case::Sensitive
     };
     let state = fs::cache::State::for_checkout(options.overwrite_existing, options.attribute_globals.clone().into());
-    let attribute_files = state.build_attribute_list(index, case);
+    let attribute_files = state.build_attribute_list(index, paths, case);
     let mut ctx = chunk::Context {
         buf: Vec::new(),
         path_cache: fs::Cache::new(
         None,
     );
-    let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths(), should_interrupt);
+    let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths_in(paths), should_interrupt);
     let chunk::Outcome {
         mut collisions,
         mut errors,

git-worktree/tests/worktree/fs/cache.rs+3−0

             fs::cache::State::for_checkout(false, Default::default()),
             Default::default(),
             Vec::new(),
+            Default::default(),
         );
         assert_eq!(cache.num_mkdir_calls(), 0);
             fs::cache::State::for_checkout(false, Default::default()),
             Default::default(),
             Vec::new(),
+            Default::default(),
         );
         (cache, dir)
     }
             ),
             Default::default(),
             buf,
+            Default::default(), // TODO: get the index, use it to ask state to get the attributes files LUT
         );
         for (relative_path, source_and_line) in (IgnoreExpectations {