[tree-diff] The first proper test with an API I like

Author: Byron

git-diff/src/lib.rs

@@ -74,14 +74,14 @@ pub mod visit {
         }
 
         #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
-        pub enum PathComponentMode {
+        pub enum PathComponentUpdateMode {
             Replace,
             Push,
         }
 
         #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
         pub struct PathComponent<'a> {
-            pub component: &'a BStr,
+            pub name: &'a BStr,
             /// An ID referring uniquely to the path built thus far. Used to keep track of source paths
             /// in case of [renames][Change::Rename] and [copies][Change::Copy].
             pub id: usize,
@@ -94,9 +94,9 @@ pub mod visit {
         }
 
         pub trait Record {
-            fn update_path_component(&mut self, component: PathComponent<'_>, mode: PathComponentMode);
+            fn update_path_component(&mut self, component: PathComponent<'_>, mode: PathComponentUpdateMode);
             fn pop_path_component(&mut self);
-            fn record(change: Change) -> Action;
+            fn record(&mut self, change: Change) -> Action;
         }
 
         #[cfg(test)]
@@ -117,25 +117,74 @@ pub mod visit {
 
     pub mod recorder {
         use crate::visit::record;
+        use git_hash::ObjectId;
+        use git_object::{
+            bstr::{BStr, BString, ByteSlice, ByteVec},
+            tree,
+        };
+        use std::{ops::Deref, path::PathBuf};
+
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub enum Change {
+            Addition {
+                mode: tree::Mode,
+                oid: ObjectId,
+                path: PathBuf,
+            },
+        }
 
-        #[derive(Clone, Default)]
-        pub struct Recorder;
+        pub type Changes = Vec<Change>;
+
+        #[derive(Clone, Debug, Default)]
+        pub struct Recorder {
+            current_component: BString,
+            pub records: Vec<Change>,
+        }
+
+        impl Recorder {
+            fn pop_element(&mut self) {
+                if let Some(pos) = self.current_component.rfind_byte(b'/') {
+                    self.current_component.resize(pos, 0);
+                }
+            }
+
+            fn push_element(&mut self, name: &BStr) {
+                self.current_component.push(b'/');
+                self.current_component.push_str(name);
+            }
+        }
 
         impl record::Record for Recorder {
             fn update_path_component(
                 &mut self,
-                _component: record::PathComponent<'_>,
-                _mode: record::PathComponentMode,
+                component: record::PathComponent<'_>,
+                mode: record::PathComponentUpdateMode,
             ) {
-                todo!()
+                use record::PathComponentUpdateMode::*;
+                match mode {
+                    Push => self.push_element(component.name),
+                    Replace => {
+                        self.pop_element();
+                        self.push_element(component.name);
+                    }
+                }
             }
 
             fn pop_path_component(&mut self) {
-                todo!()
+                self.pop_element();
             }
 
-            fn record(_change: record::Change) -> record::Action {
-                todo!()
+            fn record(&mut self, change: record::Change) -> record::Action {
+                use record::Change::*;
+                self.records.push(match change {
+                    Addition { mode, oid } => Change::Addition {
+                        mode,
+                        oid,
+                        path: self.current_component.deref().clone().into_path_buf_lossy(),
+                    },
+                    _ => todo!("record other kinds of changes"),
+                });
+                record::Action::Continue
             }
         }
     }

git-diff/tests/diff.rs

@@ -1,3 +1,7 @@
 pub type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 
-mod tree;
+pub fn hex_to_id(hex: &str) -> git_hash::ObjectId {
+    git_hash::ObjectId::from_hex(hex.as_bytes()).expect("40 bytes hex")
+}
+
+mod visit;

git-diff/tests/visit/mod.rs

@@ -1,70 +1,73 @@
-mod with_tree {
-    use crate::hex_to_id;
-    use git_diff::visit::recorder;
-    use git_odb::{pack, Locate};
+mod changes {
+    mod to_obtain_tree {
+        use crate::hex_to_id;
+        use git_diff::visit::recorder;
+        use git_odb::{pack, Locate};
 
-    const FIRST_COMMIT: &str = "055df97e18cd537da3cb16bcbdf1733fdcdfb430";
+        const FIRST_COMMIT: &str = "055df97e18cd537da3cb16bcbdf1733fdcdfb430";
 
-    fn diff_at(commit_id: &str) -> crate::Result<recorder::Changes> {
-        let db = git_odb::linked::Db::at(
-            test_tools::scripted_fixture_repo_read_only("make_diff_repo.sh")?
-                .join(".git")
-                .join("objects"),
-        )?;
-        let commit_id = git_hash::ObjectId::from_hex(commit_id.as_bytes())?;
-        let mut buf = Vec::new();
-        let (main_tree_id, parent_commit_id) = {
-            let commit = db
-                .locate(commit_id, &mut buf, &mut pack::cache::Never)?
-                .expect("start commit to be present")
+        fn diff_at(commit_id: &str) -> crate::Result<recorder::Changes> {
+            let db = git_odb::linked::Db::at(
+                test_tools::scripted_fixture_repo_read_only("make_diff_repo.sh")?
+                    .join(".git")
+                    .join("objects"),
+            )?;
+            let commit_id = git_hash::ObjectId::from_hex(commit_id.as_bytes())?;
+            let mut buf = Vec::new();
+            let (main_tree_id, parent_commit_id) = {
+                let commit = db
+                    .locate(commit_id, &mut buf, &mut pack::cache::Never)?
+                    .expect("start commit to be present")
+                    .decode()?
+                    .into_commit()
+                    .expect("id is actually a commit");
+
+                (commit.tree(), {
+                    let p = commit.parents().next();
+                    p
+                })
+            };
+            let main_tree = db
+                .locate(main_tree_id, &mut buf, &mut pack::cache::Never)?
+                .expect("main tree present")
                 .decode()?
-                .into_commit()
-                .expect("id is actually a commit");
+                .into_tree()
+                .expect("id to be a tree");
+            let mut buf2 = Vec::new();
+            let previous_tree: Option<_> = {
+                parent_commit_id
+                    .and_then(|id| db.locate(id, &mut buf2, &mut pack::cache::Never).ok().flatten())
+                    .and_then(|c| c.decode().ok())
+                    .and_then(|c| c.into_commit())
+                    .map(|c| c.tree())
+                    .and_then(|tree| db.locate(tree, &mut buf2, &mut pack::cache::Never).ok().flatten())
+                    .and_then(|tree| tree.decode().ok())
+                    .and_then(|tree| tree.into_tree())
+            };
 
-            (commit.tree(), {
-                let p = commit.parents().next();
-                p
-            })
-        };
-        let main_tree = db
-            .locate(main_tree_id, &mut buf, &mut pack::cache::Never)?
-            .expect("main tree present")
-            .decode()?
-            .into_tree()
-            .expect("id to be a tree");
-        let mut buf2 = Vec::new();
-        let previous_tree: Option<_> = {
-            parent_commit_id
-                .and_then(|id| db.locate(id, &mut buf2, &mut pack::cache::Never).ok().flatten())
-                .and_then(|c| c.decode().ok())
-                .and_then(|c| c.into_commit())
-                .map(|c| c.tree())
-                .and_then(|tree| db.locate(tree, &mut buf2, &mut pack::cache::Never).ok().flatten())
-                .and_then(|tree| tree.decode().ok())
-                .and_then(|tree| tree.into_tree())
-        };
+            let mut recorder = git_diff::visit::Recorder::default();
+            git_diff::visit::Changes::from(previous_tree.as_ref()).to_obtain_tree(
+                &main_tree,
+                &mut git_diff::visit::State::default(),
+                |_oid, _buf| todo!("Actual lookup in db"),
+                &mut recorder,
+            )?;
+            Ok(recorder.records)
+        }
 
-        let mut recorder = git_diff::visit::Recorder::default();
-        git_diff::visit::Changes::from(previous_tree.as_ref()).to_obtain_tree(
-            &main_tree,
-            &mut git_diff::visit::State::default(),
-            |_oid, _buf| todo!("Actual lookup in db"),
-            &mut recorder,
-        )?;
-        Ok(recorder.records)
-    }
-    #[test]
-    #[should_panic]
-    fn file_added() {
-        // :000000 100644 0000000000000000000000000000000000000000 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 A      f
-        assert_eq!(
-            diff_at(FIRST_COMMIT).unwrap(),
-            vec![recorder::Change::Addition {
-                mode: git_object::tree::Mode::Tree,
-                oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"),
-                path: "f".into()
-            }]
-        );
-        todo!("detect an added file in the root tree")
+        #[test]
+        #[should_panic]
+        fn file_added() {
+            // :000000 100644 0000000000000000000000000000000000000000 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 A      f
+            assert_eq!(
+                diff_at(FIRST_COMMIT).unwrap(),
+                vec![recorder::Change::Addition {
+                    mode: git_object::tree::Mode::Tree,
+                    oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"),
+                    path: "f".into()
+                }]
+            );
+            todo!("detect an added file in the root tree")
+        }
     }
 }