refactor

Author: Byron

git-diff/src/lib.rs

@@ -2,191 +2,4 @@
 #![forbid(unsafe_code, rust_2018_idioms)]
 
 ///
-pub mod visit {
-    use git_object::immutable;
-
-    #[derive(Default, Clone)]
-    pub struct State {
-        buf1: Vec<u8>,
-        buf2: Vec<u8>,
-    }
-
-    pub struct Changes<'a>(Option<&'a immutable::Tree<'a>>);
-
-    impl<'a, T> From<T> for Changes<'a>
-    where
-        T: Into<Option<&'a immutable::Tree<'a>>>,
-    {
-        fn from(v: T) -> Self {
-            Changes(v.into())
-        }
-    }
-
-    mod changes {
-        use crate::visit;
-        use git_hash::{oid, ObjectId};
-        use git_object::immutable;
-        use quick_error::quick_error;
-
-        const EMPTY_TREE: immutable::Tree<'static> = immutable::Tree::empty();
-
-        quick_error! {
-            #[derive(Debug)]
-            pub enum Error {
-                NotFound(oid: ObjectId) {
-                    display("The object {} referenced by the tree was not found in the database", oid)
-                }
-                Cancelled {
-                    display("The delegate cancelled the operation")
-                }
-            }
-        }
-
-        impl<'a> visit::Changes<'a> {
-            /// Returns the changes that need to be applied to `self` to get `other`.
-            pub fn to_obtain_tree<LocateFn>(
-                &self,
-                _other: &git_object::immutable::Tree<'_>,
-                _state: &mut visit::State,
-                _locate: LocateFn,
-                _delegate: &mut impl visit::Record,
-            ) -> Result<(), Error>
-            where
-                LocateFn: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Option<immutable::Object<'b>>,
-            {
-                let _this = *self.0.as_ref().unwrap_or(&&EMPTY_TREE);
-                todo!("changes tree to tree")
-            }
-        }
-    }
-
-    pub mod record {
-        use git_hash::ObjectId;
-        use git_object::{bstr::BStr, tree};
-
-        pub enum Change {
-            Addition { mode: tree::Mode, oid: ObjectId },
-            Copy,
-            Deletion,
-            Modification,
-            Renaming,
-            Type,
-        }
-
-        #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
-        pub enum PathComponentUpdateMode {
-            Replace,
-            Push,
-        }
-
-        #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
-        pub struct PathComponent<'a> {
-            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,
-        }
-
-        #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
-        pub enum Action {
-            Continue,
-            Cancel,
-        }
-
-        pub trait Record {
-            fn update_path_component(&mut self, component: PathComponent<'_>, mode: PathComponentUpdateMode);
-            fn pop_path_component(&mut self);
-            fn record(&mut self, change: Change) -> Action;
-        }
-
-        #[cfg(test)]
-        mod tests {
-            use super::*;
-
-            #[test]
-            fn size_of_change() {
-                assert_eq!(
-                    std::mem::size_of::<Change>(),
-                    22,
-                    "this type shouldn't grow without us knowing"
-                )
-            }
-        }
-    }
-    pub use record::Record;
-
-    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,
-            },
-        }
-
-        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::PathComponentUpdateMode,
-            ) {
-                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) {
-                self.pop_element();
-            }
-
-            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
-            }
-        }
-    }
-    pub use recorder::Recorder;
-}
+pub mod visit;

git-diff/src/visit/changes.rs

@@ -0,0 +1,35 @@
+use crate::visit;
+use git_hash::{oid, ObjectId};
+use git_object::immutable;
+use quick_error::quick_error;
+
+const EMPTY_TREE: immutable::Tree<'static> = immutable::Tree::empty();
+
+quick_error! {
+    #[derive(Debug)]
+    pub enum Error {
+        NotFound(oid: ObjectId) {
+            display("The object {} referenced by the tree was not found in the database", oid)
+        }
+        Cancelled {
+            display("The delegate cancelled the operation")
+        }
+    }
+}
+
+impl<'a> visit::Changes<'a> {
+    /// Returns the changes that need to be applied to `self` to get `other`.
+    pub fn to_obtain_tree<LocateFn>(
+        &self,
+        _other: &git_object::immutable::Tree<'_>,
+        _state: &mut visit::State,
+        _locate: LocateFn,
+        _delegate: &mut impl visit::Record,
+    ) -> Result<(), Error>
+    where
+        LocateFn: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Option<immutable::Object<'b>>,
+    {
+        let _this = *self.0.as_ref().unwrap_or(&&EMPTY_TREE);
+        todo!("changes tree to tree")
+    }
+}

git-diff/src/visit/mod.rs

@@ -0,0 +1,26 @@
+use git_object::immutable;
+
+#[derive(Default, Clone)]
+pub struct State {
+    buf1: Vec<u8>,
+    buf2: Vec<u8>,
+}
+
+pub struct Changes<'a>(Option<&'a immutable::Tree<'a>>);
+
+impl<'a, T> From<T> for Changes<'a>
+where
+    T: Into<Option<&'a immutable::Tree<'a>>>,
+{
+    fn from(v: T) -> Self {
+        Changes(v.into())
+    }
+}
+
+mod changes;
+
+pub mod record;
+pub use record::Record;
+
+pub mod recorder;
+pub use recorder::Recorder;

git-diff/src/visit/record.rs

@@ -0,0 +1,51 @@
+use git_hash::ObjectId;
+use git_object::{bstr::BStr, tree};
+
+pub enum Change {
+    Addition { mode: tree::Mode, oid: ObjectId },
+    Copy,
+    Deletion,
+    Modification,
+    Renaming,
+    Type,
+}
+
+#[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
+pub enum PathComponentUpdateMode {
+    Replace,
+    Push,
+}
+
+#[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
+pub struct PathComponent<'a> {
+    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,
+}
+
+#[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
+pub enum Action {
+    Continue,
+    Cancel,
+}
+
+pub trait Record {
+    fn update_path_component(&mut self, component: PathComponent<'_>, mode: PathComponentUpdateMode);
+    fn pop_path_component(&mut self);
+    fn record(&mut self, change: Change) -> Action;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn size_of_change() {
+        assert_eq!(
+            std::mem::size_of::<Change>(),
+            22,
+            "this type shouldn't grow without us knowing"
+        )
+    }
+}

git-diff/src/visit/recorder.rs

@@ -0,0 +1,67 @@
+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,
+    },
+}
+
+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::PathComponentUpdateMode) {
+        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) {
+        self.pop_element();
+    }
+
+    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/visit/mod.rs

@@ -67,7 +67,6 @@ mod changes {
                     path: "f".into()
                 }]
             );
-            todo!("detect an added file in the root tree")
         }
     }
 }