code_ownership 2.1.2 → 2.1.3

data/ext/cargo-vendor/similar-2.7.0/Makefile

@@ -0,0 +1,31 @@
+all: test
+
+build:
+	@cargo build --all-features
+
+doc:
+	@cargo doc --all-features
+
+test:
+	@cargo test
+	@cargo test --all-features
+	@cargo test --no-default-features
+	@cargo test --no-default-features --features bytes
+
+.PHONY: wasi-test
+wasi-test:
+	@cargo test --all-features --target=wasm32-wasip1 -- --nocapture
+
+format:
+	@rustup component add rustfmt 2> /dev/null
+	@cargo fmt --all
+
+format-check:
+	@rustup component add rustfmt 2> /dev/null
+	@cargo fmt --all -- --check
+
+lint:
+	@rustup component add clippy 2> /dev/null
+	@cargo clippy
+
+.PHONY: all doc test format format-check lint

data/ext/cargo-vendor/similar-2.7.0/README.md

@@ -0,0 +1,59 @@
+# Similar: A Diffing Library
+
+[![Crates.io](https://img.shields.io/crates/d/similar.svg)](https://crates.io/crates/similar)
+[![License](https://img.shields.io/github/license/mitsuhiko/similar)](https://github.com/mitsuhiko/similar/blob/main/LICENSE)
+[![rustc 1.60.0](https://img.shields.io/badge/rust-1.60%2B-orange.svg)](https://img.shields.io/badge/rust-1.60%2B-orange.svg)
+[![Documentation](https://docs.rs/similar/badge.svg)](https://docs.rs/similar)
+
+Similar is a dependency free crate for Rust that implements different diffing
+algorithms and high level interfaces for it. It is based on the
+[pijul](https://pijul.org/) implementation of the Patience algorithm and
+inherits some ideas from there. It also incorporates the Myer's diff
+algorithm which was largely written by Brandon Williams.  This library was
+built for the [insta snapshot testing library](https://insta.rs).
+
+```rust
+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 change in diff.iter_all_changes() {
+        let sign = match change.tag() {
+            ChangeTag::Delete => "-",
+            ChangeTag::Insert => "+",
+            ChangeTag::Equal => " ",
+        };
+        print!("{}{}", sign, change);
+    }
+}
+```
+
+## Screenshot
+
+![terminal highlighting](https://raw.githubusercontent.com/mitsuhiko/similar/main/assets/terminal-inline.png)
+
+## What's in the box?
+
+* Myer's diff
+* Patience diff
+* Hunt–McIlroy / Hunt–Szymanski LCS diff
+* Diffing on arbitrary comparable sequences
+* Line, word, character and grapheme level diffing
+* Text and Byte diffing
+* Unified diff generation
+
+## Related Projects
+
+* [insta](https://insta.rs) snapshot testing library
+* [similar-asserts](https://github.com/mitsuhiko/similar-asserts) assertion library
+
+## License and Links
+
+* [Documentation](https://docs.rs/similar/)
+* [Issue Tracker](https://github.com/mitsuhiko/similar/issues)
+* [Examples](https://github.com/mitsuhiko/similar/tree/main/examples)
+* License: [Apache-2.0](https://github.com/mitsuhiko/similar/blob/main/LICENSE)

data/ext/cargo-vendor/similar-2.7.0/clippy.toml

@@ -0,0 +1 @@
+msrv = "1.60.0"

data/ext/cargo-vendor/similar-2.7.0/examples/close-matches.rs

@@ -0,0 +1,15 @@
+use similar::get_close_matches;
+
+fn main() {
+    let words = vec![
+        "apple",
+        "appu",
+        "appal",
+        "apparitor",
+        "beer",
+        "beeb",
+        "beeline",
+    ];
+    println!("{:?}", get_close_matches("app", &words, 3, 0.7));
+    println!("{:?}", get_close_matches("bee", &words, 3, 0.7));
+}

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

@@ -0,0 +1,8 @@
+use similar::TextDiff;
+
+fn main() {
+    let x = "abc".repeat(2000);
+    let y = "abd".repeat(2000);
+    let diff = TextDiff::from_chars(&x, &y);
+    println!("{}", diff.unified_diff());
+}

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

@@ -0,0 +1,13 @@
+use similar::{capture_diff_slices, Algorithm};
+
+fn main() {
+    let old = vec![1, 2, 3];
+    let new = vec![1, 2, 4];
+    let ops = capture_diff_slices(Algorithm::Myers, &old, &new);
+
+    for op in ops {
+        for change in op.iter_changes(&old, &new) {
+            println!("{:?}", change);
+        }
+    }
+}

data/ext/cargo-vendor/similar-2.7.0/examples/original-slices.rs

@@ -0,0 +1,11 @@
+use similar::utils::diff_chars;
+use similar::Algorithm;
+
+fn main() {
+    let old = "1234567890abcdef".to_string();
+    let new = "0123456789Oabzdef".to_string();
+
+    for (change_tag, value) in diff_chars(Algorithm::Myers, &old, &new) {
+        println!("{}{:?}", change_tag, value);
+    }
+}

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

@@ -0,0 +1,48 @@
+use similar::{Algorithm, TextDiff};
+
+const OLD: &str = r#"
+[
+    (
+        Major,
+        2,
+    ),
+    (
+        Minor,
+        20,
+    ),
+    (
+        Value,
+        0,
+    ),
+]
+"#;
+const NEW: &str = r#"
+[
+    (
+        Major,
+        2,
+    ),
+    (
+        Minor,
+        0,
+    ),
+    (
+        Value,
+        0,
+    ),
+    (
+        Value,
+        1,
+    ),
+]
+"#;
+
+fn main() {
+    println!(
+        "{}",
+        TextDiff::configure()
+            .algorithm(Algorithm::Patience)
+            .diff_lines(OLD, NEW)
+            .unified_diff()
+    );
+}

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

@@ -0,0 +1,15 @@
+use similar::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",
+    );
+
+    let all_changes = diff
+        .ops()
+        .iter()
+        .flat_map(|op| diff.iter_changes(op))
+        .collect::<Vec<_>>();
+    println!("{}", serde_json::to_string_pretty(&all_changes).unwrap());
+}

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);
+}