[package]

name = "diff-match-patch-rs"

edition = "2021"

authors = ["Anubhab Bandyopadhyay"]

repository = "https://github.com/AnubhabB/diff-match-patch-rs.git"

description = "A high-performance port of Myer's diff algorithm to perform the operations required for synchronizing plain text."

readme = "README.md"

categories = ["algorithms", "text-processing", "text-editors", "wasm"]

[dependencies]

percent-encoding = "2"

[package.metadata.docs.rs]

rustdoc-args = ["--generate-link-to-definition"]

[[example]]

```toml

[dependencies]

```

### `Effitient` mode

| Lang. | Library | Diff Avg. | Patch Avg. | Bencher | Mode | Correct |

|:-------:|:----------------------------------------------------------------------------------------:|:---------:|:----------:|:----------:|:-----------:|:-------:|

| `rust` | [diff_match_patch v0.1.1](https://crates.io/crates/diff_match_patch)[^2] | 68.108 ms | 10.596 ms | Criterion | - | ✅ |

| `rust` | [dmp v0.2.0](https://crates.io/crates/dmp) | 69.019 ms | 14.654 ms | Criterion | - | ✅ |

| `node` | [diff-match-patch](https://www.npmjs.com/package/diff-match-patch) | 246.90 ms | 1.07 ms | tinybench | - | ✅ |

| `python`| [diff-match-patch](https://pypi.org/project/diff-match-patch/) | 1.01 s | 0.25 ms | timeit | - | ✅ |

[^1]: [go-diff](https://github.com/sergi/go-diff) seems to generate wrong diffs for emoticons. This benchmark is on the text with the emoticons removed.

[^2]: Adds an extra clone to the iterator because the `patch_apply` method takes mutable refc. to `diffs`.

## Related projects

use core::str;

use std::{char, collections::HashMap, fmt::Display};

use chrono::{NaiveTime, TimeDelta, Utc};

use crate::{errors::Error, html::HtmlConfig, DType, PatchInput};

}

/// creates a deadline from the given timeout

self.timeout()

.and_then(|t| Utc::now().checked_add_signed(TimeDelta::milliseconds(t)))

.map(|t| t.time())

}

// returns configured match_threshold

fn match_threshold(&self) -> f32 {

self.match_threshold

old_bytes: &'a [T],

new_bytes: &'a [T],

linemode: bool,

) -> Result<Vec<Diff<T>>, crate::errors::Error> {

// First, check if lhs and rhs are equal

if old_bytes == new_bytes {

old: &'a [T],

new: &'a [T],

linemode: bool,

) -> Result<Vec<Diff<T>>, crate::errors::Error> {

// returning all of the new part

if old.is_empty() {

&self,

old: &'a [T],

new: &'a [T],

) -> Result<Vec<Diff<T>>, crate::errors::Error> {

let mut diffs = {

let to_chars = Self::lines_to_chars(old, new);

&self,

old: &'a [usize],

new: &'a [usize],

) -> Result<Vec<Diff<usize>>, crate::errors::Error> {

if old == new {

if old.is_empty() {

&self,

old: &'a [usize],

new: &'a [usize],

) -> Result<Vec<Diff<usize>>, crate::errors::Error> {

// returning all of the new part

if old.is_empty() {

&self,

old: &'a [T],

new: &'a [T],

) -> Result<Vec<Diff<T>>, crate::errors::Error> {

// let text1_length = old.len() as isize;

// let text2_length = new.len() as isize;

for d in 0..max_d {

// Bail out if deadline is reached.

if let Some(tout) = deadline {

if Utc::now().time() > tout {

break;

}

}

// Walk the front path one step.

// of the previous patch. If there are patches expected at positions 10 and

// 20, but the first patch was found at 12, delta is 2 and the second patch

// has an effective expected position of 22.

let mut results = vec![false; patches.len()];

// patches.iter().enumerate().for_each(|(x, p)| {

for (x, p) in patches.iter().enumerate() {

let txt_old = Self::diff_text_old(&p.diffs);

let (start_loc, end_loc) = if txt_old.len() > self.match_max_bits() {

// patch_splitMax will only provide an oversized pattern in the case of

if let Some(sl) = start_loc {

// Found a match. :)

results[x] = true;

} else {

};

if txt_old == txt_new {

// Perfect match, just shove the replacement text in.

source = [

// No match found. :(

results[x] = false;

// Subtract the delta for this failed patch from subsequent patches.

}

}

/// `insert_style`, `delete_style` and `equality_style` would add css style property to the output.

/// E.g. if `insert_style: Some("background: yellow; color: purple")` is set the

/// `insert` part of the pretty html would look like `<ins style="background: yellow; color: purple">insert text</ins>`

/// [`pretty_html`]: struct.DiffMatchPatch.html/method.diff_pretty_html

pub struct HtmlConfig<'a> {

insert_tag: &'a str,

//! # Efficient port of Google's diff-match-patch implemented in Rust

//! [<img alt="github" src="https://img.shields.io/badge/github-Anubhab/diff_match_patch_rs-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/AnubhabB/diff-match-patch-rs)

//! [<img alt="crates.io" src="https://img.shields.io/crates/v/diff-match-patch-rs" height="20">](https://crates.io/crates/diff-match-patch-rs)

//! [<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-diff_match_patch_rs?style=for-the-badge&logo=docs.rs&labelColor=%23555555" height="20">](https://docs.rs/diff-match-patch-rs)

//! A very **fast**, **accurate** and **wasm ready** port of [Diff Match Patch](https://github.com/dmsnell/diff-match-patch) in Rust. The

//! diff implementation is based on [Myers' diff algorithm](https://neil.fraser.name/writing/diff/myers.pdf).

//! ## Highlights of this crate

//! - Exposes two modes of operating with `diff-match-patch`, a `Efficient` mode and `Compat` mode. While the `Efficient` mode squeezes out the max performance the `Compat` mode ensures compatibility across other libraries or implementations (rust or otherwise). According to [Benchmarks](#benchmarks), our slower `Compat` mode is still faster than other implementations in rust.

//! - **`Efficient`** mode works on `&[u8]` and the generated diffs break compatibility with other implementation. Use the **`Efficient`** mode ONLY if you are using this [crate](https://crates.io/crates/diff-match-patch-rs) at the source of diff generation and the destination.

//!

//! ```toml

//! [dependencies]

//! ```

//!

//! ### `Effitient` mode

//! | Lang. | Library | Diff Avg. | Patch Avg. | Bencher | Mode | Correct |

//! |:-------:|:----------------------------------------------------------------------------------------:|:---------:|:----------:|:----------:|:-----------:|:-------:|

//! | `rust` | [diff_match_patch v0.1.1](https://crates.io/crates/diff_match_patch)[^2] | 68.108 ms | 10.596 ms | Criterion | - | ✅ |

//! | `rust` | [dmp v0.2.0](https://crates.io/crates/dmp) | 69.019 ms | 14.654 ms | Criterion | - | ✅ |

//! | `node` | [diff-match-patch](https://www.npmjs.com/package/diff-match-patch) | 246.90 ms | 1.07 ms | tinybench | - | ✅ |

//! | `python`| [diff-match-patch](https://pypi.org/project/diff-match-patch/) | 1.01 s | 0.25 ms | timeit | - | ✅ |

//!

//!

//!

//!

pub mod dmp;

use std::hash::Hash;

use percent_encoding::{percent_decode, AsciiSet, CONTROLS};

use crate::{

Ops,

};

new: &[Self],

x: usize,

y: usize,

) -> Result<Vec<Diff<Self>>, crate::errors::Error>;

fn from_char(c: char) -> Self;

new: &[u8],

x: usize,

y: usize,

) -> Result<Vec<Diff<u8>>, crate::errors::Error> {

let old_a = &old[..x];

let new_a = &new[..y];

new: &[char],

x: usize,

y: usize,

) -> Result<Vec<Diff<char>>, crate::errors::Error> {

let old_a = &old[..x];

let new_a = &new[..y];

new: &[usize],

x: usize,

y: usize,

) -> Result<Vec<Diff<usize>>, crate::errors::Error> {

let old_a = &old[..x];

let new_a = &new[..y];

use std::time::Instant;

use diff_match_patch_rs::dmp::Diff;

use diff_match_patch_rs::html::HtmlConfig;

let a = vec!["`Twas brillig, and the slithy toves\nDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\nAnd the mome raths outgrabe.\n"; 2048].join("");

let b = vec!["I am the very model of a modern major general,\nI\'ve information vegetable, animal, and mineral,\nI know the kings of England, and I quote the fights historical,\nFrom Marathon to Waterloo, in order categorical.\n"; 2048].join("");

dmp.diff_main::<Efficient>(&a, &b)?;

// Test that we took at least the timeout period (+ 5ms being generous).

// Test the linemode speedup.

// Must be long to pass the 100 char cutoff.

let a = vec!["`Twas brillig, and the slithy toves\nDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\nAnd the mome raths outgrabe.\n"; 2048].join("");

let b = vec!["I am the very model of a modern major general,\nI\'ve information vegetable, animal, and mineral,\nI know the kings of England, and I quote the fights historical,\nFrom Marathon to Waterloo, in order categorical.\n"; 2048].join("");

dmp.diff_main::<Efficient>(&a, &b)?;

// Test that we took at least the timeout period (+ 5ms being generous).

// Test the linemode speedup.

// Must be long to pass the 100 char cutoff.

dmp.patch_apply(&patches, "x")?

);

Ok(())

}