Merge branch 'rename-tracking'

Author: Byron

.github/workflows/ci.yml

@@ -11,8 +11,7 @@ on:
       - 'src/**'
       - 'tests/**'
       - 'cargo-*/**'
-      - 'git*/**'
-      - 'experiments/**'
+      - 'gix*/**'
       - '*.toml'
       - Makefile
   pull_request:
@@ -24,8 +23,7 @@ on:
       - 'src/**'
       - 'tests/**'
       - 'cargo-*/**'
-      - 'git*/**'
-      - 'experiments/**'
+      - 'gix*/**'
       - '*.toml'
       - Makefile
 

crate-status.md

@@ -604,7 +604,19 @@ See its [README.md](https://github.com/Byron/gitoxide/blob/main/gix-lock/README.
     * **diffs/changes**
         * [x] tree with other tree
            * [ ] respect case-sensitivity of host filesystem.
-           * [ ] a way to access various diff related settings or use them
+           * [x] a way to access various diff related settings or use them
+           * **rewrite tracking**
+              * **deviation** - git keeps up to four candidates whereas we use the first-found candidate that matches the similarity percentage.
+                                This can lead to different sources being found. As such, we also don't consider the filename at all.
+              * [ ] handle binary files correctly, and apply filters for that matter
+              * [x] computation limit with observable reduction of precision when it is hit, for copies and renames separately
+              * **by identity** 
+                 * [x] renames (sym-links are only ever compared by identity)
+                 * [x] copies
+              * **by similarity** - similarity factor controllable separately from renames
+                 * [x] renames
+                 * [x] copies
+              * [x] 'find-copies-harder' - find copies with the source being the entire tree.
         * [ ] tree with working tree
         * [x] diffs between modified blobs with various algorithms
         * [ ] tree with index

gitoxide-core/src/hours/mod.rs

@@ -174,14 +174,14 @@ where
                                                 };
                                             from.changes()?
                                                 .track_filename()
-                                                .track_renames(None)
+                                                .track_rewrites(None)
                                                 .for_each_to_obtain_tree(&to, |change| {
                                                     use gix::object::tree::diff::change::Event::*;
                                                     if let Some(c) = change_counter.as_ref() {
                                                         c.fetch_add(1, Ordering::SeqCst);
                                                     }
                                                     match change.event {
-                                                        Copy { .. } | Rename { .. } => {
+                                                        Rewrite { .. } => {
                                                             unreachable!("we turned that off")
                                                         }
                                                         Addition { entry_mode, id } => {

gix-diff/src/tree/mod.rs

@@ -1,6 +1,7 @@
 use std::collections::VecDeque;
 
 use gix_hash::ObjectId;
+use gix_object::bstr::BString;
 use gix_object::TreeRefIter;
 
 /// The state required to visit [Changes] to be instantiated with `State::default()`.
@@ -41,7 +42,15 @@ pub mod visit;
 #[doc(inline)]
 pub use visit::Visit;
 
+/// A [Visit][visit::Visit] implementation to record every observed change and keep track of the changed paths.
+#[derive(Clone, Debug)]
+pub struct Recorder {
+    path_deque: VecDeque<BString>,
+    path: BString,
+    location: Option<recorder::Location>,
+    /// The observed changes.
+    pub records: Vec<recorder::Change>,
+}
+
 /// Useful for use as delegate implementing [`Visit`] to keep track of all seen changes. Useful for debugging or printing primarily.
 pub mod recorder;
-#[doc(inline)]
-pub use recorder::Recorder;

gix-diff/src/tree/recorder.rs

@@ -1,12 +1,21 @@
-use std::collections::VecDeque;
-
 use gix_hash::ObjectId;
 use gix_object::{
     bstr::{BStr, BString, ByteSlice, ByteVec},
     tree,
 };
 
-use crate::tree::visit;
+use crate::tree::{visit, Recorder};
+
+/// Describe how to track the location of a change.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum Location {
+    /// Track the entire path, relative to the repository.
+    Path,
+    /// Keep only the file-name as location, which may be enough for some calculations.
+    ///
+    /// This is less expensive than tracking the entire `Path`.
+    FileName,
+}
 
 /// A Change as observed by a call to [`visit(…)`][visit::Visit::visit()], enhanced with the path affected by the change.
 /// Its similar to [visit::Change] but includes the path that changed.
@@ -34,13 +43,37 @@ pub enum Change {
     },
 }
 
-/// A [Visit][visit::Visit] implementation to record every observed change and keep track of the changed paths.
-#[derive(Clone, Debug, Default)]
-pub struct Recorder {
-    path_deque: VecDeque<BString>,
-    path: BString,
-    /// The observed changes.
-    pub records: Vec<Change>,
+impl Default for Recorder {
+    fn default() -> Self {
+        Recorder {
+            path_deque: Default::default(),
+            path: Default::default(),
+            location: Some(Location::Path),
+            records: vec![],
+        }
+    }
+}
+
+/// Builder
+impl Recorder {
+    /// Obtain a copy of the currently tracked, full path of the entry.
+    pub fn track_location(mut self, location: Option<Location>) -> Self {
+        self.location = location;
+        self
+    }
+}
+
+/// Access
+impl Recorder {
+    /// Obtain a copy of the currently tracked, full path of the entry.
+    pub fn path_clone(&self) -> BString {
+        self.path.clone()
+    }
+
+    /// Return the currently set path.
+    pub fn path(&self) -> &BStr {
+        self.path.as_ref()
+    }
 }
 
 impl Recorder {
@@ -58,28 +91,39 @@ impl Recorder {
         }
         self.path.push_str(name);
     }
-
-    fn path_clone(&self) -> BString {
-        self.path.clone()
-    }
 }
 
 impl visit::Visit for Recorder {
     fn pop_front_tracked_path_and_set_current(&mut self) {
-        self.path = self.path_deque.pop_front().expect("every parent is set only once");
+        if let Some(Location::Path) = self.location {
+            self.path = self.path_deque.pop_front().expect("every parent is set only once");
+        }
     }
 
     fn push_back_tracked_path_component(&mut self, component: &BStr) {
-        self.push_element(component);
-        self.path_deque.push_back(self.path.clone());
+        if let Some(Location::Path) = self.location {
+            self.push_element(component);
+            self.path_deque.push_back(self.path.clone());
+        }
     }
 
     fn push_path_component(&mut self, component: &BStr) {
-        self.push_element(component);
+        match self.location {
+            None => {}
+            Some(Location::Path) => {
+                self.push_element(component);
+            }
+            Some(Location::FileName) => {
+                self.path.clear();
+                self.path.extend_from_slice(component);
+            }
+        }
     }
 
     fn pop_path_component(&mut self) {
-        self.pop_element();
+        if let Some(Location::Path) = self.location {
+            self.pop_element();
+        }
     }
 
     fn visit(&mut self, change: visit::Change) -> visit::Action {

gix-diff/src/tree/visit.rs

@@ -1,4 +1,5 @@
 use gix_hash::ObjectId;
+use gix_object::tree::EntryMode;
 use gix_object::{bstr::BStr, tree};
 
 /// Represents any possible change in order to turn one tree into another.
@@ -33,6 +34,31 @@ pub enum Change {
     },
 }
 
+impl Change {
+    /// Return the current object id.
+    pub fn oid(&self) -> &gix_hash::oid {
+        match self {
+            Change::Addition { oid, .. } | Change::Deletion { oid, .. } | Change::Modification { oid, .. } => oid,
+        }
+    }
+    /// Return the current tree entry mode.
+    pub fn entry_mode(&self) -> EntryMode {
+        match self {
+            Change::Addition { entry_mode, .. }
+            | Change::Deletion { entry_mode, .. }
+            | Change::Modification { entry_mode, .. } => *entry_mode,
+        }
+    }
+    /// Return the current object id and tree entry mode of a change.
+    pub fn oid_and_entry_mode(&self) -> (&gix_hash::oid, EntryMode) {
+        match self {
+            Change::Addition { oid, entry_mode }
+            | Change::Deletion { oid, entry_mode }
+            | Change::Modification { oid, entry_mode, .. } => (oid, *entry_mode),
+        }
+    }
+}
+
 /// What to do after a [Change] was [recorded][Visit::visit()].
 #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
 pub enum Action {

gix-diff/tests/tree/mod.rs

@@ -1,5 +1,6 @@
 mod changes {
     mod to_obtain_tree {
+        use gix_diff::tree::recorder::Location;
         use gix_diff::tree::{recorder, recorder::Change::*};
         use gix_hash::{oid, ObjectId};
         use gix_object::{bstr::ByteSlice, tree::EntryMode, TreeRefIter};
@@ -40,14 +41,19 @@ mod changes {
                 .expect("id to be a tree"))
         }
 
-        fn diff_commits(db: &gix_odb::Handle, lhs: impl Into<Option<ObjectId>>, rhs: &oid) -> crate::Result<Changes> {
+        fn diff_commits(
+            db: &gix_odb::Handle,
+            lhs: impl Into<Option<ObjectId>>,
+            rhs: &oid,
+            location: Option<Location>,
+        ) -> crate::Result<Changes> {
             let mut buf = Vec::new();
             let lhs_tree = lhs
                 .into()
                 .and_then(|lhs| locate_tree_by_commit(db, &lhs, &mut buf).ok());
             let mut buf2 = Vec::new();
             let rhs_tree = locate_tree_by_commit(db, rhs, &mut buf2)?;
-            let mut recorder = gix_diff::tree::Recorder::default();
+            let mut recorder = gix_diff::tree::Recorder::default().track_location(location);
             gix_diff::tree::Changes::from(lhs_tree).needed_to_obtain(
                 rhs_tree,
                 gix_diff::tree::State::default(),
@@ -512,31 +518,33 @@ mod changes {
                 diff_commits(
                     &db,
                     all_commits[0].to_owned(),
-                    all_commits.last().expect("we have many commits")
+                    all_commits.last().expect("we have many commits"),
+                    None
                 )?,
                 vec![
                     Addition {
                         entry_mode: EntryMode::Blob,
                         oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"),
-                        path: "b".into()
+                        path: "".into()
                     },
                     Addition {
                         entry_mode: EntryMode::Tree,
                         oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba"),
-                        path: "g".into()
+                        path: "".into()
                     },
                     Addition {
                         entry_mode: EntryMode::Blob,
                         oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"),
-                        path: "g/a".into()
+                        path: "".into()
                     }
                 ]
             );
             assert_eq!(
                 diff_commits(
                     &db,
                     all_commits.last().expect("we have many commits").to_owned(),
-                    &all_commits[0]
+                    &all_commits[0],
+                    Location::FileName.into()
                 )?,
                 vec![
                     Deletion {
@@ -552,7 +560,7 @@ mod changes {
                     Deletion {
                         entry_mode: EntryMode::Blob,
                         oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"),
-                        path: "g/a".into()
+                        path: "a".into()
                     }
                 ]
             );
@@ -565,7 +573,12 @@ mod changes {
             let all_commits = all_commits(&db);
 
             assert_eq!(
-                diff_commits(&db, None::<ObjectId>, &all_commits[all_commits.len() - 6])?,
+                diff_commits(
+                    &db,
+                    None::<ObjectId>,
+                    &all_commits[all_commits.len() - 6],
+                    Some(Location::Path)
+                )?,
                 vec![
                     Addition {
                         entry_mode: EntryMode::Tree,

gix-object/src/tree/mod.rs

@@ -44,6 +44,11 @@ impl EntryMode {
         matches!(self, EntryMode::Blob | EntryMode::BlobExecutable)
     }
 
+    /// Return true if the entry is any kind of blob or symlink.
+    pub fn is_blob_or_symlink(&self) -> bool {
+        matches!(self, EntryMode::Blob | EntryMode::BlobExecutable | EntryMode::Link)
+    }
+
     /// Represent the mode as descriptive string.
     pub fn as_str(&self) -> &'static str {
         use EntryMode::*;

gix-traverse/src/tree/mod.rs

@@ -28,10 +28,14 @@ pub trait Visit {
 }
 
 /// A [Visit][Visit] implementation to record every observed change and keep track of the changed paths.
-#[derive(Clone, Debug, Default)]
+///
+/// Recorders can also be instructed to track the filename only, or no location at all.
+#[derive(Clone, Debug)]
 pub struct Recorder {
     path_deque: VecDeque<BString>,
     path: BString,
+    /// How to track the location.
+    location: Option<recorder::Location>,
     /// The observed entries.
     pub records: Vec<recorder::Entry>,
 }