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

Unified · Split

6 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/tests/worktree/fs/cache.rs +39 −19

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 => {

git-worktree/tests/worktree/fs/cache.rs+39−19

     use git_worktree::fs;
     use tempfile::{tempdir, TempDir};
+    fn panic_on_find<'buf>(
+        _oid: &git_hash::oid,
+        _buf: &'buf mut Vec<u8>,
+    ) -> std::io::Result<git_object::BlobRef<'buf>> {
+        unreachable!("find should nto be called")
+    }
     #[test]
     fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() {
         let dir = tempdir().unwrap();
         );
         assert_eq!(cache.num_mkdir_calls(), 0);
-        let path = cache.at_entry("hello", Some(false)).unwrap().path();
+        let path = cache.at_entry("hello", Some(false), panic_on_find).unwrap().path();
         assert!(!path.parent().unwrap().exists(), "prefix itself is never created");
         assert_eq!(cache.num_mkdir_calls(), 0);
     }
             ("exe", Some(false)),
             ("link", None),
         ] {
-            let path = cache.at_entry(Path::new("dir").join(name), *is_dir).unwrap().path();
+            let path = cache
+                .at_entry(Path::new("dir").join(name), *is_dir, panic_on_find)
+                .unwrap()
+                .path();
             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.at_entry("dir/file", Some(false)).unwrap().path();
+        let path = cache.at_entry("dir/file", Some(false), panic_on_find).unwrap().path();
         assert!(path.parent().unwrap().is_dir(), "directory is still present");
         assert!(!path.exists(), "it won't create the file");
         assert_eq!(cache.num_mkdir_calls(), 1);
             cache.unlink_on_collision(false);
             let relative_path = format!("{}/file", dirname);
             assert_eq!(
-                cache.at_entry(&relative_path, Some(false)).unwrap_err().kind(),
+                cache
+                    .at_entry(&relative_path, Some(false), panic_on_find)
+                    .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.at_entry(&relative_path, Some(false)).unwrap().path();
+            let path = cache
+                .at_entry(&relative_path, Some(false), panic_on_find)
+                .unwrap()
+                .path();
             assert!(path.parent().unwrap().is_dir(), "directory was forcefully created");
             assert!(!path.exists());
         }
     use std::path::Path;
     use git_index::entry::Mode;
+    use git_odb::pack::bundle::write::Options;
+    use git_odb::FindExt;
     use git_worktree::fs;
     use tempfile::{tempdir, TempDir};
     }
     #[test]
-    #[ignore]
     fn check_against_baseline() {
         let dir = git_testtools::scripted_fixture_repo_read_only("make_ignore_and_attributes_setup.sh").unwrap();
         let worktree_dir = dir.join("repo");
         let user_exclude_path = dir.join("user.exclude");
         assert!(user_exclude_path.is_file());
-        let mut cache = fs::Cache::new(
+        let mut index = git_index::File::at(git_dir.join("index"), Default::default()).unwrap();
-            &worktree_dir,
+        let odb = git_odb::at(git_dir.join("objects")).unwrap();
-            git_worktree::fs::cache::State::for_add(
+        let state = git_worktree::fs::cache::State::for_add(
-                Default::default(),
+            Default::default(), // TODO: attribute tests
-                git_worktree::fs::cache::state::Ignore::new(
+            git_worktree::fs::cache::state::Ignore::new(
-                    git_attributes::MatchGroup::from_overrides(vec!["!force-include"]),
+                git_attributes::MatchGroup::from_overrides(vec!["!force-include"]),
-                    git_attributes::MatchGroup::from_git_dir(&git_dir, Some(user_exclude_path), &mut buf).unwrap(),
+                git_attributes::MatchGroup::from_git_dir(&git_dir, Some(user_exclude_path), &mut buf).unwrap(),
-                    None,
+                None,
-                ),
             ),
-            Default::default(),
-            buf,
-            Default::default(), // TODO: get the index, use it to ask state to get the attributes files LUT
         );
+        let case = git_glob::pattern::Case::Sensitive;
+        let paths_storage = index.take_path_backing();
+        let attribute_files_in_index = state.build_attribute_list(&index.state, &paths_storage, case);
+        assert_eq!(attribute_files_in_index, vec![]);
+        let mut cache = fs::Cache::new(&worktree_dir, state, case, buf, attribute_files_in_index);
         for (relative_path, source_and_line) in (IgnoreExpectations {
             lines: baseline.lines(),
             // TODO: ignore file in index only
             // TODO: dir-excludes
             // TODO: a sibling dir to exercise pop() impl.
-            let platform = cache.at_entry(relative_path, is_dir).unwrap();
+            let platform = cache
+                .at_entry(relative_path, is_dir, |oid, buf| odb.find_blob(oid, buf))
+                .unwrap();
             let match_ = platform.matching_exclude_pattern();
             let is_excluded = platform.is_excluded();