code_ownership 2.1.2 → 2.1.3

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

@@ -0,0 +1,379 @@
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::hash::{Hash, Hasher};
+use std::ops::{Add, Index, Range};
+
+/// Utility function to check if a range is empty that works on older rust versions
+#[inline(always)]
+#[allow(clippy::neg_cmp_op_on_partial_ord)]
+pub fn is_empty_range<T: PartialOrd<T>>(range: &Range<T>) -> bool {
+    !(range.start < range.end)
+}
+
+/// Represents an item in the vector returned by [`unique`].
+///
+/// It compares like the underlying item does it was created from but
+/// carries the index it was originally created from.
+pub struct UniqueItem<'a, Idx: ?Sized> {
+    lookup: &'a Idx,
+    index: usize,
+}
+
+impl<Idx: ?Sized> UniqueItem<'_, Idx>
+where
+    Idx: Index<usize>,
+{
+    /// Returns the value.
+    #[inline(always)]
+    pub fn value(&self) -> &Idx::Output {
+        &self.lookup[self.index]
+    }
+
+    /// Returns the original index.
+    #[inline(always)]
+    pub fn original_index(&self) -> usize {
+        self.index
+    }
+}
+
+impl<'a, Idx: Index<usize> + 'a> Debug for UniqueItem<'a, Idx>
+where
+    Idx::Output: Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("UniqueItem")
+            .field("value", &self.value())
+            .field("original_index", &self.original_index())
+            .finish()
+    }
+}
+
+impl<'a, 'b, A, B> PartialEq<UniqueItem<'a, A>> for UniqueItem<'b, B>
+where
+    A: Index<usize> + 'b + ?Sized,
+    B: Index<usize> + 'b + ?Sized,
+    B::Output: PartialEq<A::Output>,
+{
+    #[inline(always)]
+    fn eq(&self, other: &UniqueItem<'a, A>) -> bool {
+        self.value() == other.value()
+    }
+}
+
+/// Returns only unique items in the sequence as vector.
+///
+/// Each item is wrapped in a [`UniqueItem`] so that both the value and the
+/// index can be extracted.
+pub fn unique<Idx>(lookup: &Idx, range: Range<usize>) -> Vec<UniqueItem<Idx>>
+where
+    Idx: Index<usize> + ?Sized,
+    Idx::Output: Hash + Eq,
+{
+    let mut by_item = HashMap::new();
+    for index in range {
+        match by_item.entry(&lookup[index]) {
+            Entry::Vacant(entry) => {
+                entry.insert(Some(index));
+            }
+            Entry::Occupied(mut entry) => {
+                let entry = entry.get_mut();
+                if entry.is_some() {
+                    *entry = None
+                }
+            }
+        }
+    }
+    let mut rv = by_item
+        .into_iter()
+        .filter_map(|(_, x)| x)
+        .map(|index| UniqueItem { lookup, index })
+        .collect::<Vec<_>>();
+    rv.sort_by_key(|a| a.original_index());
+    rv
+}
+
+/// Given two lookups and ranges calculates the length of the common prefix.
+pub fn common_prefix_len<Old, New>(
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+) -> usize
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    New::Output: PartialEq<Old::Output>,
+{
+    if is_empty_range(&old_range) || is_empty_range(&new_range) {
+        return 0;
+    }
+    new_range
+        .zip(old_range)
+        .take_while(
+            #[inline(always)]
+            |x| new[x.0] == old[x.1],
+        )
+        .count()
+}
+
+/// Given two lookups and ranges calculates the length of common suffix.
+pub fn common_suffix_len<Old, New>(
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+) -> usize
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    New::Output: PartialEq<Old::Output>,
+{
+    if is_empty_range(&old_range) || is_empty_range(&new_range) {
+        return 0;
+    }
+    new_range
+        .rev()
+        .zip(old_range.rev())
+        .take_while(
+            #[inline(always)]
+            |x| new[x.0] == old[x.1],
+        )
+        .count()
+}
+
+struct OffsetLookup<Int> {
+    offset: usize,
+    vec: Vec<Int>,
+}
+
+impl<Int> Index<usize> for OffsetLookup<Int> {
+    type Output = Int;
+
+    #[inline(always)]
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.vec[index - self.offset]
+    }
+}
+
+/// A utility struct to convert distinct items to unique integers.
+///
+/// This can be helpful on larger inputs to speed up the comparisons
+/// performed by doing a first pass where the data set gets reduced
+/// to (small) integers.
+///
+/// The idea is that instead of passing two sequences to a diffling algorithm
+/// you first pass it via [`IdentifyDistinct`]:
+///
+/// ```rust
+/// use similar::capture_diff;
+/// use similar::algorithms::{Algorithm, IdentifyDistinct};
+///
+/// let old = &["foo", "bar", "baz"][..];
+/// let new = &["foo", "blah", "baz"][..];
+/// let h = IdentifyDistinct::<u32>::new(old, 0..old.len(), new, 0..new.len());
+/// let ops = capture_diff(
+///     Algorithm::Myers,
+///     h.old_lookup(),
+///     h.old_range(),
+///     h.new_lookup(),
+///     h.new_range(),
+/// );
+/// ```
+///
+/// The indexes are the same as with the passed source ranges.
+pub struct IdentifyDistinct<Int> {
+    old: OffsetLookup<Int>,
+    new: OffsetLookup<Int>,
+}
+
+impl<Int> IdentifyDistinct<Int>
+where
+    Int: Add<Output = Int> + From<u8> + Default + Copy,
+{
+    /// Creates an int hasher for two sequences.
+    pub fn new<Old, New>(
+        old: &Old,
+        old_range: Range<usize>,
+        new: &New,
+        new_range: Range<usize>,
+    ) -> Self
+    where
+        Old: Index<usize> + ?Sized,
+        Old::Output: Eq + Hash,
+        New: Index<usize> + ?Sized,
+        New::Output: Eq + Hash + PartialEq<Old::Output>,
+    {
+        enum Key<'old, 'new, Old: ?Sized, New: ?Sized> {
+            Old(&'old Old),
+            New(&'new New),
+        }
+
+        impl<Old, New> Hash for Key<'_, '_, Old, New>
+        where
+            Old: Hash + ?Sized,
+            New: Hash + ?Sized,
+        {
+            fn hash<H: Hasher>(&self, state: &mut H) {
+                match *self {
+                    Key::Old(val) => val.hash(state),
+                    Key::New(val) => val.hash(state),
+                }
+            }
+        }
+
+        impl<Old, New> PartialEq for Key<'_, '_, Old, New>
+        where
+            Old: Eq + ?Sized,
+            New: Eq + PartialEq<Old> + ?Sized,
+        {
+            #[inline(always)]
+            fn eq(&self, other: &Self) -> bool {
+                match (self, other) {
+                    (Key::Old(a), Key::Old(b)) => a == b,
+                    (Key::New(a), Key::New(b)) => a == b,
+                    (Key::Old(a), Key::New(b)) | (Key::New(b), Key::Old(a)) => b == a,
+                }
+            }
+        }
+
+        impl<Old, New> Eq for Key<'_, '_, Old, New>
+        where
+            Old: Eq + ?Sized,
+            New: Eq + PartialEq<Old> + ?Sized,
+        {
+        }
+
+        let mut map = HashMap::new();
+        let mut old_seq = Vec::new();
+        let mut new_seq = Vec::new();
+        let mut next_id = Int::default();
+        let step = Int::from(1);
+        let old_start = old_range.start;
+        let new_start = new_range.start;
+
+        for idx in old_range {
+            let item = Key::Old(&old[idx]);
+            let id = match map.entry(item) {
+                Entry::Occupied(o) => *o.get(),
+                Entry::Vacant(v) => {
+                    let id = next_id;
+                    next_id = next_id + step;
+                    *v.insert(id)
+                }
+            };
+            old_seq.push(id);
+        }
+
+        for idx in new_range {
+            let item = Key::New(&new[idx]);
+            let id = match map.entry(item) {
+                Entry::Occupied(o) => *o.get(),
+                Entry::Vacant(v) => {
+                    let id = next_id;
+                    next_id = next_id + step;
+                    *v.insert(id)
+                }
+            };
+            new_seq.push(id);
+        }
+
+        IdentifyDistinct {
+            old: OffsetLookup {
+                offset: old_start,
+                vec: old_seq,
+            },
+            new: OffsetLookup {
+                offset: new_start,
+                vec: new_seq,
+            },
+        }
+    }
+
+    /// Returns a lookup for the old side.
+    pub fn old_lookup(&self) -> &impl Index<usize, Output = Int> {
+        &self.old
+    }
+
+    /// Returns a lookup for the new side.
+    pub fn new_lookup(&self) -> &impl Index<usize, Output = Int> {
+        &self.new
+    }
+
+    /// Convenience method to get back the old range.
+    pub fn old_range(&self) -> Range<usize> {
+        self.old.offset..self.old.offset + self.old.vec.len()
+    }
+
+    /// Convenience method to get back the new range.
+    pub fn new_range(&self) -> Range<usize> {
+        self.new.offset..self.new.offset + self.new.vec.len()
+    }
+}
+
+#[test]
+fn test_unique() {
+    let u = unique(&vec!['a', 'b', 'c', 'd', 'd', 'b'], 0..6)
+        .into_iter()
+        .map(|x| (*x.value(), x.original_index()))
+        .collect::<Vec<_>>();
+    assert_eq!(u, vec![('a', 0), ('c', 2)]);
+}
+
+#[test]
+fn test_int_hasher() {
+    let ih = IdentifyDistinct::<u8>::new(
+        &["", "foo", "bar", "baz"][..],
+        1..4,
+        &["", "foo", "blah", "baz"][..],
+        1..4,
+    );
+    assert_eq!(ih.old_lookup()[1], 0);
+    assert_eq!(ih.old_lookup()[2], 1);
+    assert_eq!(ih.old_lookup()[3], 2);
+    assert_eq!(ih.new_lookup()[1], 0);
+    assert_eq!(ih.new_lookup()[2], 3);
+    assert_eq!(ih.new_lookup()[3], 2);
+    assert_eq!(ih.old_range(), 1..4);
+    assert_eq!(ih.new_range(), 1..4);
+}
+
+#[test]
+fn test_common_prefix_len() {
+    assert_eq!(
+        common_prefix_len("".as_bytes(), 0..0, "".as_bytes(), 0..0),
+        0
+    );
+    assert_eq!(
+        common_prefix_len("foobarbaz".as_bytes(), 0..9, "foobarblah".as_bytes(), 0..10),
+        7
+    );
+    assert_eq!(
+        common_prefix_len("foobarbaz".as_bytes(), 0..9, "blablabla".as_bytes(), 0..9),
+        0
+    );
+    assert_eq!(
+        common_prefix_len("foobarbaz".as_bytes(), 3..9, "foobarblah".as_bytes(), 3..10),
+        4
+    );
+}
+
+#[test]
+fn test_common_suffix_len() {
+    assert_eq!(
+        common_suffix_len("".as_bytes(), 0..0, "".as_bytes(), 0..0),
+        0
+    );
+    assert_eq!(
+        common_suffix_len("1234".as_bytes(), 0..4, "X0001234".as_bytes(), 0..8),
+        4
+    );
+    assert_eq!(
+        common_suffix_len("1234".as_bytes(), 0..4, "Xxxx".as_bytes(), 0..4),
+        0
+    );
+    assert_eq!(
+        common_suffix_len("1234".as_bytes(), 2..4, "01234".as_bytes(), 2..5),
+        2
+    );
+}

data/ext/cargo-vendor/similar-2.7.0/src/common.rs

@@ -0,0 +1,185 @@
+use std::hash::Hash;
+use std::ops::{Index, Range};
+
+use crate::algorithms::{diff_deadline, Capture, Compact, Replace};
+use crate::deadline_support::Instant;
+use crate::{Algorithm, DiffOp};
+
+/// Creates a diff between old and new with the given algorithm capturing the ops.
+///
+/// This is like [`diff`](crate::algorithms::diff) but instead of using an
+/// arbitrary hook this will always use [`Compact`] + [`Replace`] + [`Capture`]
+/// and return the captured [`DiffOp`]s.
+pub fn capture_diff<Old, New>(
+    alg: Algorithm,
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+) -> Vec<DiffOp>
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    Old::Output: Hash + Eq + Ord,
+    New::Output: PartialEq<Old::Output> + Hash + Eq + Ord,
+{
+    capture_diff_deadline(alg, old, old_range, new, new_range, None)
+}
+
+/// Creates a diff between old and new with the given algorithm capturing the ops.
+///
+/// Works like [`capture_diff`] but with an optional deadline.
+pub fn capture_diff_deadline<Old, New>(
+    alg: Algorithm,
+    old: &Old,
+    old_range: Range<usize>,
+    new: &New,
+    new_range: Range<usize>,
+    deadline: Option<Instant>,
+) -> Vec<DiffOp>
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    Old::Output: Hash + Eq + Ord,
+    New::Output: PartialEq<Old::Output> + Hash + Eq + Ord,
+{
+    let mut d = Compact::new(Replace::new(Capture::new()), old, new);
+    diff_deadline(alg, &mut d, old, old_range, new, new_range, deadline).unwrap();
+    d.into_inner().into_inner().into_ops()
+}
+
+/// Creates a diff between old and new with the given algorithm capturing the ops.
+pub fn capture_diff_slices<T>(alg: Algorithm, old: &[T], new: &[T]) -> Vec<DiffOp>
+where
+    T: Eq + Hash + Ord,
+{
+    capture_diff_slices_deadline(alg, old, new, None)
+}
+
+/// Creates a diff between old and new with the given algorithm capturing the ops.
+///
+/// Works like [`capture_diff_slices`] but with an optional deadline.
+pub fn capture_diff_slices_deadline<T>(
+    alg: Algorithm,
+    old: &[T],
+    new: &[T],
+    deadline: Option<Instant>,
+) -> Vec<DiffOp>
+where
+    T: Eq + Hash + Ord,
+{
+    capture_diff_deadline(alg, old, 0..old.len(), new, 0..new.len(), deadline)
+}
+
+/// Return a measure of similarity in the range `0..=1`.
+///
+/// A ratio of `1.0` means the two sequences are a complete match, a
+/// ratio of `0.0` would indicate completely distinct sequences.  The input
+/// is the sequence of diff operations and the length of the old and new
+/// sequence.
+pub fn get_diff_ratio(ops: &[DiffOp], old_len: usize, new_len: usize) -> f32 {
+    let matches = ops
+        .iter()
+        .map(|op| {
+            if let DiffOp::Equal { len, .. } = *op {
+                len
+            } else {
+                0
+            }
+        })
+        .sum::<usize>();
+    let len = old_len + new_len;
+    if len == 0 {
+        1.0
+    } else {
+        2.0 * matches as f32 / len as f32
+    }
+}
+
+/// Isolate change clusters by eliminating ranges with no changes.
+///
+/// This will leave holes behind in long periods of equal ranges so that
+/// you can build things like unified diffs.
+pub fn group_diff_ops(mut ops: Vec<DiffOp>, n: usize) -> Vec<Vec<DiffOp>> {
+    if ops.is_empty() {
+        return vec![];
+    }
+
+    let mut pending_group = Vec::new();
+    let mut rv = Vec::new();
+
+    if let Some(DiffOp::Equal {
+        old_index,
+        new_index,
+        len,
+    }) = ops.first_mut()
+    {
+        let offset = (*len).saturating_sub(n);
+        *old_index += offset;
+        *new_index += offset;
+        *len -= offset;
+    }
+
+    if let Some(DiffOp::Equal { len, .. }) = ops.last_mut() {
+        *len -= (*len).saturating_sub(n);
+    }
+
+    for op in ops.into_iter() {
+        if let DiffOp::Equal {
+            old_index,
+            new_index,
+            len,
+        } = op
+        {
+            // End the current group and start a new one whenever
+            // there is a large range with no changes.
+            if len > n * 2 {
+                pending_group.push(DiffOp::Equal {
+                    old_index,
+                    new_index,
+                    len: n,
+                });
+                rv.push(pending_group);
+                let offset = len.saturating_sub(n);
+                pending_group = vec![DiffOp::Equal {
+                    old_index: old_index + offset,
+                    new_index: new_index + offset,
+                    len: len - offset,
+                }];
+                continue;
+            }
+        }
+        pending_group.push(op);
+    }
+
+    match &pending_group[..] {
+        &[] | &[DiffOp::Equal { .. }] => {}
+        _ => rv.push(pending_group),
+    }
+
+    rv
+}
+
+#[test]
+fn test_non_string_iter_change() {
+    use crate::ChangeTag;
+
+    let old = vec![1, 2, 3];
+    let new = vec![1, 2, 4];
+    let ops = capture_diff_slices(Algorithm::Myers, &old, &new);
+    let changes: Vec<_> = ops
+        .iter()
+        .flat_map(|x| x.iter_changes(&old, &new))
+        .map(|x| (x.tag(), x.value()))
+        .collect();
+
+    assert_eq!(
+        changes,
+        vec![
+            (ChangeTag::Equal, 1),
+            (ChangeTag::Equal, 2),
+            (ChangeTag::Delete, 3),
+            (ChangeTag::Insert, 4),
+        ]
+    );
+}

data/ext/cargo-vendor/similar-2.7.0/src/deadline_support.rs

@@ -0,0 +1,37 @@
+use std::time::Duration;
+
+#[cfg(not(feature = "wasm32_web_time"))]
+pub use std::time::Instant;
+
+/// WASM (browser) specific instant type.
+///
+/// This type is only available when the `wasm32_web_time` feature is enabled.  In that
+/// case this is an alias for [`web_time::Instant`].
+#[cfg(feature = "wasm32_web_time")]
+pub use web_time::Instant;
+
+/// Checks if a deadline was exeeded.
+pub fn deadline_exceeded(deadline: Option<Instant>) -> bool {
+    #[allow(unreachable_code)]
+    match deadline {
+        Some(deadline) => {
+            #[cfg(all(target_arch = "wasm32", not(feature = "wasm32_web_time")))]
+            {
+                return false;
+            }
+            Instant::now() > deadline
+        }
+        None => false,
+    }
+}
+
+/// Converst a duration into a deadline.  This can be a noop on wasm
+#[allow(unused)]
+pub fn duration_to_deadline(add: Duration) -> Option<Instant> {
+    #[allow(unreachable_code)]
+    #[cfg(all(target_arch = "wasm32", not(feature = "wasm32_web_time")))]
+    {
+        return None;
+    }
+    Instant::now().checked_add(add)
+}