code_ownership 2.1.2 → 2.1.3

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/lcs.rs

@@ -0,0 +1,294 @@
+//! LCS diff algorithm.
+//!
+//! * time: `O((NM)D log (M)D)`
+//! * space `O(MN)`
+use std::collections::BTreeMap;
+use std::ops::{Index, Range};
+
+use crate::algorithms::utils::{common_prefix_len, common_suffix_len, is_empty_range};
+use crate::algorithms::DiffHook;
+use crate::deadline_support::{deadline_exceeded, Instant};
+
+/// LCS diff algorithm.
+///
+/// Diff `old`, between indices `old_range` and `new` between indices `new_range`.
+///
+/// This diff is done with an optional deadline that defines the maximal
+/// execution time permitted before it bails and falls back to an very bad
+/// approximation.  Deadlines with LCS do not make a lot of sense and should
+/// not be used.
+pub fn diff<Old, New, D>(
+    d: &mut D,
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+) -> Result<(), D::Error>
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    D: DiffHook,
+    New::Output: PartialEq<Old::Output>,
+{
+    diff_deadline(d, old, old_range, new, new_range, None)
+}
+
+/// LCS diff algorithm.
+///
+/// Diff `old`, between indices `old_range` and `new` between indices `new_range`.
+///
+/// This diff is done with an optional deadline that defines the maximal
+/// execution time permitted before it bails and falls back to an approximation.
+pub fn diff_deadline<Old, New, D>(
+    d: &mut D,
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+    deadline: Option<Instant>,
+) -> Result<(), D::Error>
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    D: DiffHook,
+    New::Output: PartialEq<Old::Output>,
+{
+    if is_empty_range(&new_range) {
+        d.delete(old_range.start, old_range.len(), new_range.start)?;
+        d.finish()?;
+        return Ok(());
+    } else if is_empty_range(&old_range) {
+        d.insert(old_range.start, new_range.start, new_range.len())?;
+        d.finish()?;
+        return Ok(());
+    }
+
+    let common_prefix_len = common_prefix_len(old, old_range.clone(), new, new_range.clone());
+    let common_suffix_len = common_suffix_len(
+        old,
+        old_range.start + common_prefix_len..old_range.end,
+        new,
+        new_range.start + common_prefix_len..new_range.end,
+    );
+
+    // If the sequences are not different then we're done
+    if common_prefix_len == old_range.len() && (old_range.len() == new_range.len()) {
+        d.equal(0, 0, old_range.len())?;
+        d.finish()?;
+        return Ok(());
+    }
+
+    let maybe_table = make_table(
+        old,
+        common_prefix_len..(old_range.len() - common_suffix_len),
+        new,
+        common_prefix_len..(new_range.len() - common_suffix_len),
+        deadline,
+    );
+    let mut old_idx = 0;
+    let mut new_idx = 0;
+    let new_len = new_range.len() - common_prefix_len - common_suffix_len;
+    let old_len = old_range.len() - common_prefix_len - common_suffix_len;
+
+    if common_prefix_len > 0 {
+        d.equal(old_range.start, new_range.start, common_prefix_len)?;
+    }
+
+    if let Some(table) = maybe_table {
+        while new_idx < new_len && old_idx < old_len {
+            let old_orig_idx = old_range.start + common_prefix_len + old_idx;
+            let new_orig_idx = new_range.start + common_prefix_len + new_idx;
+
+            if new[new_orig_idx] == old[old_orig_idx] {
+                d.equal(old_orig_idx, new_orig_idx, 1)?;
+                old_idx += 1;
+                new_idx += 1;
+            } else if table.get(&(new_idx, old_idx + 1)).unwrap_or(&0)
+                >= table.get(&(new_idx + 1, old_idx)).unwrap_or(&0)
+            {
+                d.delete(old_orig_idx, 1, new_orig_idx)?;
+                old_idx += 1;
+            } else {
+                d.insert(old_orig_idx, new_orig_idx, 1)?;
+                new_idx += 1;
+            }
+        }
+    } else {
+        let old_orig_idx = old_range.start + common_prefix_len + old_idx;
+        let new_orig_idx = new_range.start + common_prefix_len + new_idx;
+        d.delete(old_orig_idx, old_len, new_orig_idx)?;
+        d.insert(old_orig_idx, new_orig_idx, new_len)?;
+    }
+
+    if old_idx < old_len {
+        d.delete(
+            old_range.start + common_prefix_len + old_idx,
+            old_len - old_idx,
+            new_range.start + common_prefix_len + new_idx,
+        )?;
+        old_idx += old_len - old_idx;
+    }
+
+    if new_idx < new_len {
+        d.insert(
+            old_range.start + common_prefix_len + old_idx,
+            new_range.start + common_prefix_len + new_idx,
+            new_len - new_idx,
+        )?;
+    }
+
+    if common_suffix_len > 0 {
+        d.equal(
+            old_range.start + old_len + common_prefix_len,
+            new_range.start + new_len + common_prefix_len,
+            common_suffix_len,
+        )?;
+    }
+
+    d.finish()
+}
+
+fn make_table<Old, New>(
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+    deadline: Option<Instant>,
+) -> Option<BTreeMap<(usize, usize), u32>>
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    New::Output: PartialEq<Old::Output>,
+{
+    let old_len = old_range.len();
+    let new_len = new_range.len();
+    let mut table = BTreeMap::new();
+
+    for i in (0..new_len).rev() {
+        // are we running for too long?  give up on the table
+        if deadline_exceeded(deadline) {
+            return None;
+        }
+
+        for j in (0..old_len).rev() {
+            let val = if new[i] == old[j] {
+                table.get(&(i + 1, j + 1)).unwrap_or(&0) + 1
+            } else {
+                *table
+                    .get(&(i + 1, j))
+                    .unwrap_or(&0)
+                    .max(table.get(&(i, j + 1)).unwrap_or(&0))
+            };
+            if val > 0 {
+                table.insert((i, j), val);
+            }
+        }
+    }
+
+    Some(table)
+}
+
+#[test]
+fn test_table() {
+    let table = make_table(&vec![2, 3], 0..2, &vec![0, 1, 2], 0..3, None).unwrap();
+    let expected = {
+        let mut m = BTreeMap::new();
+        m.insert((1, 0), 1);
+        m.insert((0, 0), 1);
+        m.insert((2, 0), 1);
+        m
+    };
+    assert_eq!(table, expected);
+}
+
+#[test]
+fn test_diff() {
+    let a: &[usize] = &[0, 1, 2, 3, 4];
+    let b: &[usize] = &[0, 1, 2, 9, 4];
+
+    let mut d = crate::algorithms::Replace::new(crate::algorithms::Capture::new());
+    diff(&mut d, a, 0..a.len(), b, 0..b.len()).unwrap();
+    insta::assert_debug_snapshot!(d.into_inner().ops());
+}
+
+#[test]
+fn test_contiguous() {
+    let a: &[usize] = &[0, 1, 2, 3, 4, 4, 4, 5];
+    let b: &[usize] = &[0, 1, 2, 8, 9, 4, 4, 7];
+
+    let mut d = crate::algorithms::Replace::new(crate::algorithms::Capture::new());
+    diff(&mut d, a, 0..a.len(), b, 0..b.len()).unwrap();
+    insta::assert_debug_snapshot!(d.into_inner().ops());
+}
+
+#[test]
+fn test_pat() {
+    let a: &[usize] = &[0, 1, 3, 4, 5];
+    let b: &[usize] = &[0, 1, 4, 5, 8, 9];
+
+    let mut d = crate::algorithms::Capture::new();
+    diff(&mut d, a, 0..a.len(), b, 0..b.len()).unwrap();
+    insta::assert_debug_snapshot!(d.ops());
+}
+
+#[test]
+fn test_same() {
+    let a: &[usize] = &[0, 1, 2, 3, 4, 4, 4, 5];
+    let b: &[usize] = &[0, 1, 2, 3, 4, 4, 4, 5];
+
+    let mut d = crate::algorithms::Capture::new();
+    diff(&mut d, a, 0..a.len(), b, 0..b.len()).unwrap();
+    insta::assert_debug_snapshot!(d.ops());
+}
+
+#[test]
+fn test_finish_called() {
+    struct HasRunFinish(bool);
+
+    impl DiffHook for HasRunFinish {
+        type Error = ();
+        fn finish(&mut self) -> Result<(), Self::Error> {
+            self.0 = true;
+            Ok(())
+        }
+    }
+
+    let mut d = HasRunFinish(false);
+    let slice = &[1, 2];
+    let slice2 = &[1, 2, 3];
+    diff(&mut d, slice, 0..slice.len(), slice2, 0..slice2.len()).unwrap();
+    assert!(d.0);
+
+    let mut d = HasRunFinish(false);
+    let slice = &[1, 2];
+    diff(&mut d, slice, 0..slice.len(), slice, 0..slice.len()).unwrap();
+    assert!(d.0);
+
+    let mut d = HasRunFinish(false);
+    let slice: &[u8] = &[];
+    diff(&mut d, slice, 0..slice.len(), slice, 0..slice.len()).unwrap();
+    assert!(d.0);
+}
+
+#[test]
+fn test_bad_range_regression() {
+    use crate::algorithms::Capture;
+    use crate::DiffOp;
+    let mut d = Capture::new();
+    diff(&mut d, &[0], 0..1, &[0, 0], 0..2).unwrap();
+    assert_eq!(
+        d.into_ops(),
+        vec![
+            DiffOp::Equal {
+                old_index: 0,
+                new_index: 0,
+                len: 1
+            },
+            DiffOp::Insert {
+                old_index: 1,
+                new_index: 1,
+                new_len: 1
+            }
+        ]
+    );
+}

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/mod.rs

@@ -0,0 +1,134 @@
+//! Various diff (longest common subsequence) algorithms.
+//!
+//! The implementations of the algorithms in this module are relatively low
+//! level and expose the most generic bounds possible for the algorithm.  To
+//! use them you would typically use the higher level API if possible but
+//! direct access to these algorithms can be useful in some cases.
+//!
+//! All these algorithms provide a `diff` function which takes two indexable
+//! objects (for instance slices) and a [`DiffHook`].  As the
+//! diff is generated the diff hook is invoked.  Note that the diff hook does
+//! not get access to the actual values but only the indexes.  This is why the
+//! diff hook is not used outside of the raw algorithm implementations as for
+//! most situations access to the values is useful of required.
+//!
+//! The algorithms module really is the most low-level module in similar and
+//! generally not the place to start.
+//!
+//! # Example
+//!
+//! This is a simple example that shows how you can calculate the difference
+//! between two sequences and capture the ops into a vector.
+//!
+//! ```rust
+//! use similar::algorithms::{Algorithm, Replace, Capture, diff_slices};
+//!
+//! let a = vec![1, 2, 3, 4, 5];
+//! let b = vec![1, 2, 3, 4, 7];
+//! let mut d = Replace::new(Capture::new());
+//! diff_slices(Algorithm::Myers, &mut d, &a, &b).unwrap();
+//! let ops = d.into_inner().into_ops();
+//! ```
+//!
+//! The above example is equivalent to using
+//! [`capture_diff_slices`](crate::capture_diff_slices).
+
+mod capture;
+mod compact;
+mod hook;
+mod replace;
+pub(crate) mod utils;
+
+use std::hash::Hash;
+use std::ops::{Index, Range};
+
+use crate::deadline_support::Instant;
+pub use capture::Capture;
+pub use compact::Compact;
+pub use hook::{DiffHook, NoFinishHook};
+pub use replace::Replace;
+pub use utils::IdentifyDistinct;
+
+#[doc(no_inline)]
+pub use crate::Algorithm;
+
+pub mod lcs;
+pub mod myers;
+pub mod patience;
+
+/// Creates a diff between old and new with the given algorithm.
+///
+/// Diffs `old`, between indices `old_range` and `new` between indices `new_range`.
+pub fn diff<Old, New, D>(
+    alg: Algorithm,
+    d: &mut D,
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+) -> Result<(), D::Error>
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    D: DiffHook,
+    Old::Output: Hash + Eq + Ord,
+    New::Output: PartialEq<Old::Output> + Hash + Eq + Ord,
+{
+    diff_deadline(alg, d, old, old_range, new, new_range, None)
+}
+
+/// Creates a diff between old and new with the given algorithm with deadline.
+///
+/// Diffs `old`, between indices `old_range` and `new` between indices `new_range`.
+///
+/// This diff is done with an optional deadline that defines the maximal
+/// execution time permitted before it bails and falls back to an approximation.
+/// Note that not all algorithms behave well if they reach the deadline (LCS
+/// for instance produces a very simplistic diff when the deadline is reached
+/// in all cases).
+pub fn diff_deadline<Old, New, D>(
+    alg: Algorithm,
+    d: &mut D,
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+    deadline: Option<Instant>,
+) -> Result<(), D::Error>
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    D: DiffHook,
+    Old::Output: Hash + Eq + Ord,
+    New::Output: PartialEq<Old::Output> + Hash + Eq + Ord,
+{
+    match alg {
+        Algorithm::Myers => myers::diff_deadline(d, old, old_range, new, new_range, deadline),
+        Algorithm::Patience => patience::diff_deadline(d, old, old_range, new, new_range, deadline),
+        Algorithm::Lcs => lcs::diff_deadline(d, old, old_range, new, new_range, deadline),
+    }
+}
+
+/// Shortcut for diffing slices with a specific algorithm.
+pub fn diff_slices<D, T>(alg: Algorithm, d: &mut D, old: &[T], new: &[T]) -> Result<(), D::Error>
+where
+    D: DiffHook,
+    T: Eq + Hash + Ord,
+{
+    diff(alg, d, old, 0..old.len(), new, 0..new.len())
+}
+
+/// Shortcut for diffing slices with a specific algorithm.
+pub fn diff_slices_deadline<D, T>(
+    alg: Algorithm,
+    d: &mut D,
+    old: &[T],
+    new: &[T],
+    deadline: Option<Instant>,
+) -> Result<(), D::Error>
+where
+    D: DiffHook,
+    T: Eq + Hash + Ord,
+{
+    diff_deadline(alg, d, old, 0..old.len(), new, 0..new.len(), deadline)
+}