code_ownership 2.1.2 → 2.1.4

data/ext/cargo-vendor/similar-2.7.0/examples/terminal-inline.rs

@@ -0,0 +1,60 @@
+use std::fmt;
+use std::fs::read;
+use std::process::exit;
+
+use console::{style, Style};
+use similar::{ChangeTag, TextDiff};
+
+struct Line(Option<usize>);
+
+impl fmt::Display for Line {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.0 {
+            None => write!(f, "    "),
+            Some(idx) => write!(f, "{:<4}", idx + 1),
+        }
+    }
+}
+
+fn main() {
+    let args: Vec<_> = std::env::args_os().collect();
+    if args.len() != 3 {
+        eprintln!("usage: terminal-inline [old] [new]");
+        exit(1);
+    }
+
+    let old = read(&args[1]).unwrap();
+    let new = read(&args[2]).unwrap();
+    let diff = TextDiff::from_lines(&old, &new);
+
+    for (idx, group) in diff.grouped_ops(3).iter().enumerate() {
+        if idx > 0 {
+            println!("{:-^1$}", "-", 80);
+        }
+        for op in group {
+            for change in diff.iter_inline_changes(op) {
+                let (sign, s) = match change.tag() {
+                    ChangeTag::Delete => ("-", Style::new().red()),
+                    ChangeTag::Insert => ("+", Style::new().green()),
+                    ChangeTag::Equal => (" ", Style::new().dim()),
+                };
+                print!(
+                    "{}{} |{}",
+                    style(Line(change.old_index())).dim(),
+                    style(Line(change.new_index())).dim(),
+                    s.apply_to(sign).bold(),
+                );
+                for (emphasized, value) in change.iter_strings_lossy() {
+                    if emphasized {
+                        print!("{}", s.apply_to(value).underlined().on_black());
+                    } else {
+                        print!("{}", s.apply_to(value));
+                    }
+                }
+                if change.missing_newline() {
+                    println!();
+                }
+            }
+        }
+    }
+}

data/ext/cargo-vendor/similar-2.7.0/examples/terminal.rs

@@ -0,0 +1,20 @@
+use console::Style;
+use similar::{ChangeTag, TextDiff};
+
+fn main() {
+    let diff = TextDiff::from_lines(
+        "Hello World\nThis is the second line.\nThis is the third.",
+        "Hallo Welt\nThis is the second line.\nThis is life.\nMoar and more",
+    );
+
+    for op in diff.ops() {
+        for change in diff.iter_changes(op) {
+            let (sign, style) = match change.tag() {
+                ChangeTag::Delete => ("-", Style::new().red()),
+                ChangeTag::Insert => ("+", Style::new().green()),
+                ChangeTag::Equal => (" ", Style::new()),
+            };
+            print!("{}{}", style.apply_to(sign).bold(), style.apply_to(change));
+        }
+    }
+}

data/ext/cargo-vendor/similar-2.7.0/examples/udiff.rs

@@ -0,0 +1,24 @@
+use std::fs::read;
+use std::io;
+use std::process::exit;
+
+use similar::TextDiff;
+
+fn main() {
+    let args: Vec<_> = std::env::args_os().collect();
+    if args.len() != 3 {
+        eprintln!("usage: udiff [old] [new]");
+        exit(1);
+    }
+
+    let old = read(&args[1]).unwrap();
+    let new = read(&args[2]).unwrap();
+    TextDiff::from_lines(&old, &new)
+        .unified_diff()
+        .header(
+            &args[1].as_os_str().to_string_lossy(),
+            &args[2].as_os_str().to_string_lossy(),
+        )
+        .to_writer(io::stdout())
+        .unwrap();
+}

data/ext/cargo-vendor/similar-2.7.0/scripts/wasmtime-wrapper.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+cd $SCRIPT_DIR/..
+wasmtime run --max-wasm-stack=4194304 --env INSTA_WORKSPACE_ROOT=/ --mapdir "/::$(pwd)" -- "$@"

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

@@ -0,0 +1,117 @@
+use std::convert::Infallible;
+
+use crate::algorithms::DiffHook;
+use crate::{group_diff_ops, DiffOp};
+
+/// A [`DiffHook`] that captures all diff operations.
+#[derive(Default, Clone)]
+pub struct Capture(Vec<DiffOp>);
+
+impl Capture {
+    /// Creates a new capture hook.
+    pub fn new() -> Capture {
+        Capture::default()
+    }
+
+    /// Converts the capture hook into a vector of ops.
+    pub fn into_ops(self) -> Vec<DiffOp> {
+        self.0
+    }
+
+    /// Isolate change clusters by eliminating ranges with no changes.
+    ///
+    /// This is equivalent to calling [`group_diff_ops`] on [`Capture::into_ops`].
+    pub fn into_grouped_ops(self, n: usize) -> Vec<Vec<DiffOp>> {
+        group_diff_ops(self.into_ops(), n)
+    }
+
+    /// Accesses the captured operations.
+    pub fn ops(&self) -> &[DiffOp] {
+        &self.0
+    }
+}
+
+impl DiffHook for Capture {
+    type Error = Infallible;
+
+    #[inline(always)]
+    fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), Self::Error> {
+        self.0.push(DiffOp::Equal {
+            old_index,
+            new_index,
+            len,
+        });
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn delete(
+        &mut self,
+        old_index: usize,
+        old_len: usize,
+        new_index: usize,
+    ) -> Result<(), Self::Error> {
+        self.0.push(DiffOp::Delete {
+            old_index,
+            old_len,
+            new_index,
+        });
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn insert(
+        &mut self,
+        old_index: usize,
+        new_index: usize,
+        new_len: usize,
+    ) -> Result<(), Self::Error> {
+        self.0.push(DiffOp::Insert {
+            old_index,
+            new_index,
+            new_len,
+        });
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn replace(
+        &mut self,
+        old_index: usize,
+        old_len: usize,
+        new_index: usize,
+        new_len: usize,
+    ) -> Result<(), Self::Error> {
+        self.0.push(DiffOp::Replace {
+            old_index,
+            old_len,
+            new_index,
+            new_len,
+        });
+        Ok(())
+    }
+}
+
+#[test]
+fn test_capture_hook_grouping() {
+    use crate::algorithms::{diff_slices, Algorithm, Replace};
+
+    let rng = (1..100).collect::<Vec<_>>();
+    let mut rng_new = rng.clone();
+    rng_new[10] = 1000;
+    rng_new[13] = 1000;
+    rng_new[16] = 1000;
+    rng_new[34] = 1000;
+
+    let mut d = Replace::new(Capture::new());
+    diff_slices(Algorithm::Myers, &mut d, &rng, &rng_new).unwrap();
+
+    let ops = d.into_inner().into_grouped_ops(3);
+    let tags = ops
+        .iter()
+        .map(|group| group.iter().map(|x| x.as_tag_tuple()).collect::<Vec<_>>())
+        .collect::<Vec<_>>();
+
+    insta::assert_debug_snapshot!(ops);
+    insta::assert_debug_snapshot!(tags);
+}

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

@@ -0,0 +1,351 @@
+//! Implements basic compacting.  This is based on the compaction logic from
+//! diffy by Brandon Williams.
+use std::ops::Index;
+
+use crate::{DiffOp, DiffTag};
+
+use super::utils::{common_prefix_len, common_suffix_len};
+use super::DiffHook;
+
+/// Performs semantic cleanup operations on a diff.
+///
+/// This merges similar ops together but also tries to move hunks up and
+/// down the diff with the desire to connect as many hunks as possible.
+/// It still needs to be combined with [`Replace`](crate::algorithms::Replace)
+/// to get actual replace diff ops out.
+#[derive(Debug)]
+pub struct Compact<'old, 'new, Old: ?Sized, New: ?Sized, D> {
+    d: D,
+    ops: Vec<DiffOp>,
+    old: &'old Old,
+    new: &'new New,
+}
+
+impl<'old, 'new, Old, New, D> Compact<'old, 'new, Old, New, D>
+where
+    D: DiffHook,
+    Old: Index<usize> + ?Sized + 'old,
+    New: Index<usize> + ?Sized + 'new,
+    New::Output: PartialEq<Old::Output>,
+{
+    /// Creates a new compact hook wrapping another hook.
+    pub fn new(d: D, old: &'old Old, new: &'new New) -> Self {
+        Compact {
+            d,
+            ops: Vec::new(),
+            old,
+            new,
+        }
+    }
+
+    /// Extracts the inner hook.
+    pub fn into_inner(self) -> D {
+        self.d
+    }
+}
+
+impl<Old: ?Sized, New: ?Sized, D: DiffHook> AsRef<D> for Compact<'_, '_, Old, New, D> {
+    fn as_ref(&self) -> &D {
+        &self.d
+    }
+}
+
+impl<Old: ?Sized, New: ?Sized, D: DiffHook> AsMut<D> for Compact<'_, '_, Old, New, D> {
+    fn as_mut(&mut self) -> &mut D {
+        &mut self.d
+    }
+}
+
+impl<'old, 'new, Old, New, D> DiffHook for Compact<'old, 'new, Old, New, D>
+where
+    D: DiffHook,
+    Old: Index<usize> + ?Sized + 'old,
+    New: Index<usize> + ?Sized + 'new,
+    New::Output: PartialEq<Old::Output>,
+{
+    type Error = D::Error;
+
+    #[inline(always)]
+    fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), Self::Error> {
+        self.ops.push(DiffOp::Equal {
+            old_index,
+            new_index,
+            len,
+        });
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn delete(
+        &mut self,
+        old_index: usize,
+        old_len: usize,
+        new_index: usize,
+    ) -> Result<(), Self::Error> {
+        self.ops.push(DiffOp::Delete {
+            old_index,
+            old_len,
+            new_index,
+        });
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn insert(
+        &mut self,
+        old_index: usize,
+        new_index: usize,
+        new_len: usize,
+    ) -> Result<(), Self::Error> {
+        self.ops.push(DiffOp::Insert {
+            old_index,
+            new_index,
+            new_len,
+        });
+        Ok(())
+    }
+
+    fn finish(&mut self) -> Result<(), Self::Error> {
+        cleanup_diff_ops(self.old, self.new, &mut self.ops);
+        for op in &self.ops {
+            op.apply_to_hook(&mut self.d)?;
+        }
+        self.d.finish()
+    }
+}
+
+// Walks through all edits and shifts them up and then down, trying to see if
+// they run into similar edits which can be merged.
+pub fn cleanup_diff_ops<Old, New>(old: &Old, new: &New, ops: &mut Vec<DiffOp>)
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    New::Output: PartialEq<Old::Output>,
+{
+    // First attempt to compact all Deletions
+    let mut pointer = 0;
+    while let Some(&op) = ops.get(pointer) {
+        if let DiffTag::Delete = op.tag() {
+            pointer = shift_diff_ops_up(ops, old, new, pointer);
+            pointer = shift_diff_ops_down(ops, old, new, pointer);
+        }
+        pointer += 1;
+    }
+
+    // Then attempt to compact all Insertions
+    let mut pointer = 0;
+    while let Some(&op) = ops.get(pointer) {
+        if let DiffTag::Insert = op.tag() {
+            pointer = shift_diff_ops_up(ops, old, new, pointer);
+            pointer = shift_diff_ops_down(ops, old, new, pointer);
+        }
+        pointer += 1;
+    }
+}
+
+fn shift_diff_ops_up<Old, New>(
+    ops: &mut Vec<DiffOp>,
+    old: &Old,
+    new: &New,
+    mut pointer: usize,
+) -> usize
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    New::Output: PartialEq<Old::Output>,
+{
+    while let Some(&prev_op) = pointer.checked_sub(1).and_then(|idx| ops.get(idx)) {
+        let this_op = ops[pointer];
+        match (this_op.tag(), prev_op.tag()) {
+            // Shift Inserts Upwards
+            (DiffTag::Insert, DiffTag::Equal) => {
+                let suffix_len =
+                    common_suffix_len(old, prev_op.old_range(), new, this_op.new_range());
+                if suffix_len > 0 {
+                    if let Some(DiffTag::Equal) = ops.get(pointer + 1).map(|x| x.tag()) {
+                        ops[pointer + 1].grow_left(suffix_len);
+                    } else {
+                        ops.insert(
+                            pointer + 1,
+                            DiffOp::Equal {
+                                old_index: prev_op.old_range().end - suffix_len,
+                                new_index: this_op.new_range().end - suffix_len,
+                                len: suffix_len,
+                            },
+                        );
+                    }
+                    ops[pointer].shift_left(suffix_len);
+                    ops[pointer - 1].shrink_left(suffix_len);
+
+                    if ops[pointer - 1].is_empty() {
+                        ops.remove(pointer - 1);
+                        pointer -= 1;
+                    }
+                } else if ops[pointer - 1].is_empty() {
+                    ops.remove(pointer - 1);
+                    pointer -= 1;
+                } else {
+                    // We can't shift upwards anymore
+                    break;
+                }
+            }
+            // Shift Deletions Upwards
+            (DiffTag::Delete, DiffTag::Equal) => {
+                // check common suffix for the amount we can shift
+                let suffix_len =
+                    common_suffix_len(old, prev_op.old_range(), new, this_op.new_range());
+                if suffix_len != 0 {
+                    if let Some(DiffTag::Equal) = ops.get(pointer + 1).map(|x| x.tag()) {
+                        ops[pointer + 1].grow_left(suffix_len);
+                    } else {
+                        let old_range = prev_op.old_range();
+                        ops.insert(
+                            pointer + 1,
+                            DiffOp::Equal {
+                                old_index: old_range.end - suffix_len,
+                                new_index: this_op.new_range().end - suffix_len,
+                                len: old_range.len() - suffix_len,
+                            },
+                        );
+                    }
+                    ops[pointer].shift_left(suffix_len);
+                    ops[pointer - 1].shrink_left(suffix_len);
+
+                    if ops[pointer - 1].is_empty() {
+                        ops.remove(pointer - 1);
+                        pointer -= 1;
+                    }
+                } else if ops[pointer - 1].is_empty() {
+                    ops.remove(pointer - 1);
+                    pointer -= 1;
+                } else {
+                    // We can't shift upwards anymore
+                    break;
+                }
+            }
+            // Swap the Delete and Insert
+            (DiffTag::Insert, DiffTag::Delete) | (DiffTag::Delete, DiffTag::Insert) => {
+                ops.swap(pointer - 1, pointer);
+                pointer -= 1;
+            }
+            // Merge the two ranges
+            (DiffTag::Insert, DiffTag::Insert) => {
+                ops[pointer - 1].grow_right(this_op.new_range().len());
+                ops.remove(pointer);
+                pointer -= 1;
+            }
+            (DiffTag::Delete, DiffTag::Delete) => {
+                ops[pointer - 1].grow_right(this_op.old_range().len());
+                ops.remove(pointer);
+                pointer -= 1;
+            }
+            _ => unreachable!("unexpected tag"),
+        }
+    }
+    pointer
+}
+
+fn shift_diff_ops_down<Old, New>(
+    ops: &mut Vec<DiffOp>,
+    old: &Old,
+    new: &New,
+    mut pointer: usize,
+) -> usize
+where
+    Old: Index<usize> + ?Sized,
+    New: Index<usize> + ?Sized,
+    New::Output: PartialEq<Old::Output>,
+{
+    while let Some(&next_op) = pointer.checked_add(1).and_then(|idx| ops.get(idx)) {
+        let this_op = ops[pointer];
+        match (this_op.tag(), next_op.tag()) {
+            // Shift Inserts Downwards
+            (DiffTag::Insert, DiffTag::Equal) => {
+                let prefix_len =
+                    common_prefix_len(old, next_op.old_range(), new, this_op.new_range());
+                if prefix_len > 0 {
+                    if let Some(DiffTag::Equal) = pointer
+                        .checked_sub(1)
+                        .and_then(|x| ops.get(x))
+                        .map(|x| x.tag())
+                    {
+                        ops[pointer - 1].grow_right(prefix_len);
+                    } else {
+                        ops.insert(
+                            pointer,
+                            DiffOp::Equal {
+                                old_index: next_op.old_range().start,
+                                new_index: this_op.new_range().start,
+                                len: prefix_len,
+                            },
+                        );
+                        pointer += 1;
+                    }
+                    ops[pointer].shift_right(prefix_len);
+                    ops[pointer + 1].shrink_right(prefix_len);
+
+                    if ops[pointer + 1].is_empty() {
+                        ops.remove(pointer + 1);
+                    }
+                } else if ops[pointer + 1].is_empty() {
+                    ops.remove(pointer + 1);
+                } else {
+                    // We can't shift upwards anymore
+                    break;
+                }
+            }
+            // Shift Deletions Downwards
+            (DiffTag::Delete, DiffTag::Equal) => {
+                // check common suffix for the amount we can shift
+                let prefix_len =
+                    common_prefix_len(old, next_op.old_range(), new, this_op.new_range());
+                if prefix_len > 0 {
+                    if let Some(DiffTag::Equal) = pointer
+                        .checked_sub(1)
+                        .and_then(|x| ops.get(x))
+                        .map(|x| x.tag())
+                    {
+                        ops[pointer - 1].grow_right(prefix_len);
+                    } else {
+                        ops.insert(
+                            pointer,
+                            DiffOp::Equal {
+                                old_index: next_op.old_range().start,
+                                new_index: this_op.new_range().start,
+                                len: prefix_len,
+                            },
+                        );
+                        pointer += 1;
+                    }
+                    ops[pointer].shift_right(prefix_len);
+                    ops[pointer + 1].shrink_right(prefix_len);
+
+                    if ops[pointer + 1].is_empty() {
+                        ops.remove(pointer + 1);
+                    }
+                } else if ops[pointer + 1].is_empty() {
+                    ops.remove(pointer + 1);
+                } else {
+                    // We can't shift downwards anymore
+                    break;
+                }
+            }
+            // Swap the Delete and Insert
+            (DiffTag::Insert, DiffTag::Delete) | (DiffTag::Delete, DiffTag::Insert) => {
+                ops.swap(pointer, pointer + 1);
+                pointer += 1;
+            }
+            // Merge the two ranges
+            (DiffTag::Insert, DiffTag::Insert) => {
+                ops[pointer].grow_right(next_op.new_range().len());
+                ops.remove(pointer + 1);
+            }
+            (DiffTag::Delete, DiffTag::Delete) => {
+                ops[pointer].grow_right(next_op.old_range().len());
+                ops.remove(pointer + 1);
+            }
+            _ => unreachable!("unexpected tag"),
+        }
+    }
+    pointer
+}