Use imara-diff-v2 by default

Cargo.toml

@@ -242,7 +242,6 @@ members = [
     "gix-object",
     "gix-glob",
     "gix-diff",
-    "gix-imara-diff-01",
     "gix-imara-diff",
     "gix-merge",
     "gix-date",

gitoxide-core/src/organize.rs

@@ -101,7 +101,7 @@ pub fn find_git_repository_workdirs(
         // Only return paths which are repositories are further participating in the traversal
         // Don't let bare repositories cause siblings to be pruned.
         if found_any_repo && !found_bare_repo {
-            siblings.retain(|e| e.as_ref().map(|e| e.client_state.info.is_some()).unwrap_or(false));
+            siblings.retain(|e| e.as_ref().is_ok_and(|e| e.client_state.info.is_some()));
         }
     })
     .into_iter()

gitoxide-core/src/query/engine/command.rs

@@ -98,7 +98,7 @@ impl query::Engine {
                     }
                 }
 
-                info.sort_by(|a, b| a.id.cmp(&b.id));
+                info.sort_by_key(|a| a.id);
                 let max_diff_lines = info
                     .iter()
                     .map(|i| i.diff.map_or(0, |d| d.lines_removed + d.lines_added))

gitoxide-core/src/query/engine/update.rs

@@ -256,17 +256,16 @@ pub fn update(
                                                                     let tokens = prep.interned_input();
                                                                     match prep.operation {
                                                                         Operation::InternalDiff { algorithm } => {
-                                                                            let counts = gix::diff::blob::diff(
-                                                                                algorithm,
-                                                                                &tokens,
-                                                                                gix::diff::blob::sink::Counter::default(
-                                                                                ),
+                                                                            let diff = gix::diff::blob::Diff::compute(
+                                                                                algorithm, &tokens,
                                                                             );
-                                                                            nl += counts.insertions as usize
-                                                                                + counts.removals as usize;
+                                                                            let added = diff.count_additions() as usize;
+                                                                            let removed =
+                                                                                diff.count_removals() as usize;
+                                                                            nl += added + removed;
                                                                             let lines = LineStats {
-                                                                                added: counts.insertions as usize,
-                                                                                removed: counts.removals as usize,
+                                                                                added,
+                                                                                removed,
                                                                                 before: tokens.before.len(),
                                                                                 after: tokens.after.len(),
                                                                             };
@@ -312,8 +311,8 @@ pub fn update(
                                                             lines: diff.map(|d| LineStats {
                                                                 added: d.insertions as usize,
                                                                 removed: d.removals as usize,
-                                                                before: d.before as usize,
-                                                                after: d.after as usize,
+                                                                before: d.before,
+                                                                after: d.after,
                                                             }),
                                                         });
                                                     }

gitoxide-core/src/repository/diff.rs

@@ -1,8 +1,6 @@
 use anyhow::Context;
-use gix::diff::blob::unified_diff::ConsumeBinaryHunk;
 use gix::{
     bstr::{BString, ByteSlice},
-    diff::blob::{intern::TokenSource, unified_diff::ContextSize, UnifiedDiff},
     objs::tree::EntryMode,
     odb::store::RefreshMode,
     prelude::ObjectIdExt,
@@ -202,24 +200,24 @@ pub fn file(
         }
     };
 
-    let interner = gix::diff::blob::intern::InternedInput::new(
+    let interner = gix::diff::blob::InternedInput::new(
         tokens_for_diffing(outcome.old.data.as_slice().unwrap_or_default()),
         tokens_for_diffing(outcome.new.data.as_slice().unwrap_or_default()),
     );
 
-    let unified_diff = UnifiedDiff::new(
+    let diff = gix::diff::blob::diff_with_slider_heuristics(algorithm, &interner);
+    let rendered = gix::diff::blob::UnifiedDiff::new(
+        &diff,
         &interner,
-        ConsumeBinaryHunk::new(BString::default(), "\n"),
-        ContextSize::symmetrical(3),
-    );
-
-    let unified_diff = gix::diff::blob::diff(algorithm, &interner, unified_diff)?;
-
-    out.write_all(unified_diff.as_bytes())?;
+        gix::diff::blob::unified_diff::ConsumeBinaryHunk::new(BString::default(), "\n"),
+        gix::diff::blob::unified_diff::ContextSize::symmetrical(3),
+    )
+    .consume()?;
+    write!(out, "{rendered}")?;
 
     Ok(())
 }
 
-pub(crate) fn tokens_for_diffing(data: &[u8]) -> impl TokenSource<Token = &[u8]> {
-    gix::diff::blob::sources::byte_lines(data)
+pub(crate) fn tokens_for_diffing(data: &[u8]) -> gix::diff::blob::platform::resource::ByteLinesWithoutTerminator<'_> {
+    gix::diff::blob::platform::resource::ByteLinesWithoutTerminator::new(data)
 }

gitoxide-core/src/repository/exclude.rs

@@ -38,7 +38,7 @@ pub fn query(
     let mut cache = repo.excludes(
         &index,
         Some(gix::ignore::Search::from_overrides(
-            overrides.into_iter(),
+            overrides,
             repo.ignore_pattern_parser()?,
         )),
         Default::default(),

gix-attributes/tests/search/mod.rs

@@ -309,8 +309,7 @@ mod baseline {
 
         let mut buf = Vec::new();
         let mut collection = MetadataCollection::default();
-        let group =
-            gix_attributes::Search::new_globals([base.join("user.attributes")].into_iter(), &mut buf, &mut collection)?;
+        let group = gix_attributes::Search::new_globals([base.join("user.attributes")], &mut buf, &mut collection)?;
 
         Ok((group, collection, base, input))
     }

gix-blame/Cargo.toml

@@ -29,7 +29,7 @@ gix-commitgraph = { version = "^0.35.0", path = "../gix-commitgraph" }
 gix-revwalk = { version = "^0.29.0", path = "../gix-revwalk" }
 gix-trace = { version = "^0.1.18", path = "../gix-trace" }
 gix-date = { version = "^0.15.1", path = "../gix-date" }
-gix-diff = { version = "^0.61.0", path = "../gix-diff", default-features = false, features = ["blob", "blob-experimental"] }
+gix-diff = { version = "^0.61.0", path = "../gix-diff", default-features = false, features = ["blob"] }
 gix-object = { version = "^0.58.0", path = "../gix-object" }
 gix-hash = { version = "^0.23.0", path = "../gix-hash" }
 gix-worktree = { version = "^0.50.0", path = "../gix-worktree", default-features = false, features = ["attributes"] }

gix-blame/src/file/function.rs

@@ -1,6 +1,6 @@
 use std::num::NonZeroU32;
 
-use gix_diff::{blob::intern::TokenSource, tree::Visit};
+use gix_diff::{blob::TokenSource, tree::Visit};
 use gix_hash::ObjectId;
 use gix_object::{
     bstr::{BStr, BString},
@@ -204,13 +204,13 @@ pub fn file(
         #[cfg(debug_assertions)]
         {
             let source_blob = odb.find_blob(&entry_id, &mut buf)?.data.to_vec();
-            let mut source_interner = gix_diff::blob::intern::Interner::new(source_blob.len() / 100);
+            let mut source_interner = gix_diff::blob::Interner::new(source_blob.len() / 100);
             let source_lines_as_tokens: Vec<_> = tokens_for_diffing(&source_blob)
                 .tokenize()
                 .map(|token| source_interner.intern(token))
                 .collect();
 
-            let mut blamed_interner = gix_diff::blob::intern::Interner::new(blamed_file_blob.len() / 100);
+            let mut blamed_interner = gix_diff::blob::Interner::new(blamed_file_blob.len() / 100);
             let blamed_lines_as_tokens: Vec<_> = tokens_for_diffing(&blamed_file_blob)
                 .tokenize()
                 .map(|token| blamed_interner.intern(token))
@@ -407,7 +407,7 @@ pub fn file(
 
     // I don’t know yet whether it would make sense to use a data structure instead that preserves
     // order on insertion.
-    out.sort_by(|a, b| a.start_in_blamed_file.cmp(&b.start_in_blamed_file));
+    out.sort_by_key(|a| a.start_in_blamed_file);
     Ok(Outcome {
         entries: coalesce_blame_entries(out),
         blob: blamed_file_blob,
@@ -758,7 +758,7 @@ fn blob_changes(
     diff_algorithm: gix_diff::blob::Algorithm,
     stats: &mut Statistics,
 ) -> Result<Vec<Change>, Error> {
-    use gix_diff::blob::v2::Hunk;
+    use gix_diff::blob::Hunk;
 
     resource_cache.set_resource(
         previous_oid,
@@ -776,17 +776,12 @@ fn blob_changes(
     )?;
 
     let outcome = resource_cache.prepare_diff()?;
-    let input = gix_diff::blob::v2::InternedInput::new(
+    let input = gix_diff::blob::InternedInput::new(
         outcome.old.data.as_slice().unwrap_or_default(),
         outcome.new.data.as_slice().unwrap_or_default(),
     );
 
-    let diff_algorithm: gix_diff::blob::v2::Algorithm = match diff_algorithm {
-        gix_diff::blob::Algorithm::Histogram => gix_diff::blob::v2::Algorithm::Histogram,
-        gix_diff::blob::Algorithm::Myers => gix_diff::blob::v2::Algorithm::Myers,
-        gix_diff::blob::Algorithm::MyersMinimal => gix_diff::blob::v2::Algorithm::MyersMinimal,
-    };
-    let mut diff = gix_diff::blob::v2::Diff::compute(diff_algorithm, &input);
+    let mut diff = gix_diff::blob::Diff::compute(diff_algorithm, &input);
     diff.postprocess_lines(&input);
 
     let mut last_seen_after_end = 0;
@@ -882,5 +877,5 @@ fn collect_parents(
 /// Return an iterator over tokens for use in diffing. These are usually lines, but it's important
 /// to unify them so the later access shows the right thing.
 pub(crate) fn tokens_for_diffing(data: &[u8]) -> impl TokenSource<Token = &[u8]> {
-    gix_diff::blob::sources::byte_lines_with_terminator(data)
+    gix_diff::blob::sources::byte_lines(data)
 }

gix-blame/src/types.rs

@@ -119,7 +119,7 @@ impl BlameRanges {
                 non_overlapping.push(merged_range);
 
                 *ranges = non_overlapping;
-                ranges.sort_by(|a, b| a.start.cmp(&b.start));
+                ranges.sort_by_key(|a| a.start);
             }
             Self::WholeFile => *self = Self::PartialFile(vec![new_range]),
         }
@@ -230,8 +230,8 @@ impl Outcome {
     /// Note that [`Self::blob`] must be tokenized in exactly the same way as the tokenizer that was used
     /// to perform the diffs, which is what this method assures.
     pub fn entries_with_lines(&self) -> impl Iterator<Item = (BlameEntry, Vec<BString>)> + '_ {
-        use gix_diff::blob::intern::TokenSource;
-        let mut interner = gix_diff::blob::intern::Interner::new(self.blob.len() / 100);
+        use gix_diff::blob::TokenSource;
+        let mut interner = gix_diff::blob::Interner::new(self.blob.len() / 100);
         let lines_as_tokens: Vec<_> = tokens_for_diffing(&self.blob)
             .tokenize()
             .map(|token| interner.intern(token))

gix-diff/Cargo.toml

@@ -28,9 +28,6 @@ blob = [
     "dep:gix-trace",
     "dep:gix-traverse"
 ]
-## An experimental use of the v0.2 branch of `imara-diff` to allow trying it out, and for writing tests against it more easily.
-## We will decide later how it should actually be exposed.
-blob-experimental = ["dep:imara-diff-v2"]
 ## Enable diffing of two indices, which also allows for a generic rewrite tracking implementation.
 index = ["dep:gix-index", "dep:gix-pathspec", "dep:gix-attributes"]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
@@ -44,7 +41,7 @@ doctest = false
 [[bench]]
 name = "line-count"
 harness = false
-required-features = ["blob-experimental"]
+required-features = ["blob"]
 path = "./benches/line_count.rs"
 
 [dependencies]
@@ -61,8 +58,7 @@ gix-fs = { version = "^0.19.2", path = "../gix-fs", optional = true }
 gix-tempfile = { version = "^21.0.0", path = "../gix-tempfile", optional = true }
 gix-trace = { version = "^0.1.18", path = "../gix-trace", optional = true }
 gix-traverse = { version = "^0.55.0", path = "../gix-traverse", optional = true }
-imara-diff = { package = "gix-imara-diff-01", version = "0.1.8", optional = true, path = "../gix-imara-diff-01" }
-imara-diff-v2 = { package = "gix-imara-diff", version = "0.2.0", optional = true, path = "../gix-imara-diff" }
+imara-diff = { package = "gix-imara-diff", version = "0.2.0", optional = true, path = "../gix-imara-diff" }
 
 thiserror = "2.0.18"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }