difference-rs 3.2.0

A Rust text diffing and assertion library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use std::char::REPLACEMENT_CHARACTER;

use crate::{Changeset, ChangesetMulti, Difference};

impl From<(Changeset, Vec<(usize, String)>, Vec<(usize, String)>)> for ChangesetMulti {
    fn from(
        (changeset, orig_splits, edit_splits): (
            Changeset,
            Vec<(usize, String)>,
            Vec<(usize, String)>,
        ),
    ) -> Self {
        let distance = changeset.distance;
        let mut orig_counter = 0;
        let mut edit_counter = 0;
        let diffs = changeset
            .diffs
            .into_iter()
            .map(|d| match d {
                Difference::Same(ref x) => {
                    let orig = x.as_str().split(REPLACEMENT_CHARACTER).collect::<Vec<_>>();
                    let mut s = String::new();
                    for word in orig {
                        orig_counter += word.len();
                        edit_counter += word.len();
                        s.push_str(word);
                        if let Some(split) = orig_splits
                            .iter()
                            .find(|(idx, _split)| idx == &orig_counter)
                        {
                            orig_counter += split.1.len();
                            edit_counter += split.1.len();

                            s.push_str(&split.1);
                        }
                    }
                    Difference::Same(s)
                }
                Difference::Add(ref x) => {
                    let edit = x.as_str().split(REPLACEMENT_CHARACTER).collect::<Vec<_>>();
                    let mut s = String::new();
                    for word in edit {
                        edit_counter += word.len();
                        s.push_str(word);
                        if let Some(split) = edit_splits
                            .iter()
                            .find(|(idx, _split)| idx == &edit_counter)
                        {
                            edit_counter += split.1.len();
                            s.push_str(&split.1);
                        }
                    }
                    Difference::Add(s)
                }
                Difference::Rem(ref x) => {
                    let orig = x.as_str().split(REPLACEMENT_CHARACTER).collect::<Vec<_>>();
                    let mut s = String::new();
                    for word in orig {
                        orig_counter += word.len();
                        s.push_str(word);
                        if let Some(split) = orig_splits
                            .iter()
                            .find(|(idx, _split)| idx == &orig_counter)
                        {
                            orig_counter += split.1.len();
                            s.push_str(&split.1);
                        }
                    }
                    Difference::Rem(s)
                }
            })
            .collect();
        ChangesetMulti {
            splits: orig_splits,
            edit_splits,
            distance,
            diffs,
        }
    }
}