wire everything up to have all data where it needs to be, but… (#301)

proper error handling needs more bounds on error E which can be done but really is a lot of typing. Nothing to be done here except for doing it I guess.

Sebastian Thiel committed 4 years ago

Commit 34d0d5c1 parent 883d78d6 files · +100 −37Browse files

Showing the changes to git-worktree/src (5 of 6 files). Show all

Unified · Split

5 files

git-worktree/src/fs/cache/mod.rs +11 −4
git-worktree/src/fs/cache/platform.rs +13 −2
git-worktree/src/fs/cache/state.rs +34 −9
git-worktree/src/fs/mod.rs +2 −2
git-worktree/src/index/entry.rs +1 −1

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

 use super::Cache;
 use crate::fs;
-use crate::fs::PathIdMapping;
+use crate::fs::PathOidMapping;
+use git_hash::oid;
 use std::path::{Path, PathBuf};
 #[derive(Clone)]
         state: State,
         case: git_glob::pattern::Case,
         buf: Vec<u8>,
-        attribute_files_in_index: Vec<PathIdMapping<'paths>>,
+        attribute_files_in_index: Vec<PathOidMapping<'paths>>,
     ) -> Self {
         let root = worktree_root.into();
         Cache {
     /// path is created as directory. If it's not known it is assumed to be a file.
     ///
     /// Provide access to cached information for that `relative` entry via the platform returned.
-    pub fn at_entry(
+    pub fn at_entry<Find, E>(
         &mut self,
         relative: impl AsRef<Path>,
         is_dir: Option<bool>,
-    ) -> std::io::Result<Platform<'_, 'paths>> {
+        find: Find,
+    ) -> std::io::Result<Platform<'_, 'paths>>
+    where
+        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E>,
+    {
         let mut platform = platform::StackDelegate {
             state: &mut self.state,
             buf: &mut self.buf,
             is_dir,
+            attribute_files_in_index: &self.attribute_files_in_index,
+            find,
         };
         self.stack.make_relative_path_current(relative, &mut platform)?;
         Ok(Platform { parent: self, is_dir })

git-worktree/src/fs/cache/platform.rs+13−2

 use crate::fs;
 use crate::fs::cache::{Platform, State};
+use crate::fs::PathOidMapping;
+use git_hash::oid;
 use std::path::Path;
 impl<'a, 'paths> Platform<'a, 'paths> {
     }
 }
-pub struct StackDelegate<'a> {
+pub struct StackDelegate<'a, 'paths, Find> {
     pub state: &'a mut State,
     pub buf: &'a mut Vec<u8>,
     pub is_dir: Option<bool>,
+    pub attribute_files_in_index: &'a Vec<PathOidMapping<'paths>>,
+    pub find: Find,
 }
-impl<'a> fs::stack::Delegate for StackDelegate<'a> {
+impl<'a, 'paths, Find, E> fs::stack::Delegate for StackDelegate<'a, 'paths, Find>
+where
+    Find: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Result<git_object::BlobRef<'b>, E>,
+{
     fn push(&mut self, is_last_component: bool, stack: &fs::Stack) -> std::io::Result<()> {
         match &mut self.state {
             State::CreateDirectoryAndAttributesStack {
                 &stack.root,
                 stack.current.parent().expect("component was just pushed"),
                 self.buf,
+                self.attribute_files_in_index,
+                &mut self.find,
             )?,
             State::IgnoreStack(ignore) => ignore.push(
                 &stack.root,
                 stack.current.parent().expect("component was just pushed"),
                 self.buf,
+                self.attribute_files_in_index,
+                &mut self.find,
             )?,
         }
         Ok(())

git-worktree/src/fs/cache/state.rs+34−9

 use crate::fs::cache::{state, State};
-use crate::fs::PathIdMapping;
+use crate::fs::PathOidMapping;
 use bstr::{BStr, BString, ByteSlice};
 use git_glob::pattern::Case;
+use git_hash::oid;
 use std::path::Path;
 type AttributeMatchGroup = git_attributes::MatchGroup<git_attributes::Attributes>;
         }
     }
-    pub fn push(&mut self, root: &Path, dir: &Path, buf: &mut Vec<u8>) -> std::io::Result<()> {
+    pub fn push<Find, E>(
-        let follow_symlinks = true;
+        &mut self,
+        root: &Path,
+        dir: &Path,
+        buf: &mut Vec<u8>,
+        attribute_files_in_index: &Vec<PathOidMapping<'_>>,
+        _find: Find,
+    ) -> std::io::Result<()>
+    where
+        Find: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Result<git_object::BlobRef<'b>, E>,
+    {
+        let ignore_path = git_features::path::convert::to_unix_separators(
+            git_features::path::into_bytes_or_panic_on_windows(dir.join(".gitignore")),
+        );
+        let ignore_file_in_index = attribute_files_in_index.binary_search_by(|t| t.0.cmp(ignore_path.as_bstr()));
+        let ignore_path = git_features::path::from_byte_vec_or_panic_on_windows(ignore_path);
+        let follow_symlinks = ignore_file_in_index.is_err();
         if !self
             .stack
-            .add_patterns_file(dir.join(".gitignore"), follow_symlinks, Some(root), buf)?
+            .add_patterns_file(ignore_path, follow_symlinks, Some(root), buf)?
         {
-            // Need one stack level per component so push and pop matches.
+            match ignore_file_in_index {
-            self.stack.patterns.push(Default::default());
+                Ok(_idx) => {
+                    // let ignore_blob = find(&attribute_files_in_index[0].1, buf)
+                    //     .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+                    // self.stack.add_patterns_buffer(ignore_blob.data);
+                    todo!()
+                }
+                Err(_) => {
+                    // Need one stack level per component so push and pop matches.
+                    self.stack.patterns.push(Default::default())
+                }
+            }
         }
-        // TODO: from index
         Ok(())
     }
 }
     /// - ignores entries which aren't blobs
     /// - ignores ignore entries which are not skip-worktree
     /// - within merges, picks 'our' stage both for ignore and attribute files.
-    pub(crate) fn build_attribute_list<'paths>(
+    pub fn build_attribute_list<'paths>(
         &self,
         index: &git_index::State,
         paths: &'paths git_index::PathStorage,
         case: git_glob::pattern::Case,
-    ) -> Vec<PathIdMapping<'paths>> {
+    ) -> Vec<PathOidMapping<'paths>> {
         let a1_backing;
         let a2_backing;
         let names = match self {

git-worktree/src/fs/mod.rs+2−2

@@ -65,10 +65,10 @@ pub struct Cache<'paths> { · 64 unmodified lines
65	/// If case folding should happen when looking up attributes or exclusions.	65	/// If case folding should happen when looking up attributes or exclusions.
66	case: git_glob::pattern::Case,	66	case: git_glob::pattern::Case,
67	/// A lookup table for object ids to read from in some situations when looking up attributes or exclusions.	67	/// A lookup table for object ids to read from in some situations when looking up attributes or exclusions.
68	attribute_files_in_index: Vec<PathIdMapping<'paths>>,	68	attribute_files_in_index: Vec<PathOidMapping<'paths>>,
69	}	69	}
70		70
71	pub(crate) type PathIdMapping<'paths> = (&'paths BStr, git_hash::ObjectId);	71	pub(crate) type PathOidMapping<'paths> = (&'paths BStr, git_hash::ObjectId);
72		72
73	///	73	///
74	pub mod cache;	74	pub mod cache;

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

@@ -38,7 +38,7 @@ where · 37 unmodified lines
38	path: entry_path.to_owned(),	38	path: entry_path.to_owned(),
39	})?;	39	})?;
40	let is_dir = Some(entry.mode == git_index::entry::Mode::COMMIT \|\| entry.mode == git_index::entry::Mode::DIR);	40	let is_dir = Some(entry.mode == git_index::entry::Mode::COMMIT \|\| entry.mode == git_index::entry::Mode::DIR);
41	let dest = path_cache.at_entry(dest_relative, is_dir)?.path();	41	let dest = path_cache.at_entry(dest_relative, is_dir, &mut *find)?.path();
42		42
43	let object_size = match entry.mode {	43	let object_size = match entry.mode {
44	git_index::entry::Mode::FILE \| git_index::entry::Mode::FILE_EXECUTABLE => {	44	git_index::entry::Mode::FILE \| git_index::entry::Mode::FILE_EXECUTABLE => {