reconcile-text 0.12.1

Intelligent 3-way text merging with automated conflict resolution
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

mod example_document;

use std::{fs, path::Path};

use example_document::ExampleDocument;
use reconcile_text::{BuiltinTokenizer, reconcile};
use serde::Deserialize;

#[test]
fn test_document_one_way_without_cursors() {
    for doc in &get_all_documents() {
        doc.assert_eq_without_cursors(
            &reconcile(
                &doc.parent(),
                &doc.left().text().into(),
                &doc.right().text().into(),
                &*BuiltinTokenizer::Word,
            )
            .apply()
            .text(),
        );
    }
}

#[test]
fn test_document_one_way_with_cursors() {
    for doc in &get_all_documents() {
        doc.assert_eq(&reconcile(
            &doc.parent(),
            &doc.left(),
            &doc.right(),
            &*BuiltinTokenizer::Word,
        ));
    }
}

#[cfg(feature = "serde")]
#[test]
fn test_document_one_way_with_serialisation() {
    use reconcile_text::EditedText;

    for doc in &get_all_documents() {
        let parent = doc.parent();
        let left_operations =
            EditedText::from_strings_with_tokenizer(&parent, &doc.left(), &*BuiltinTokenizer::Word);
        let right_operations = EditedText::from_strings_with_tokenizer(
            &parent,
            &doc.right(),
            &*BuiltinTokenizer::Word,
        );

        let serialised_left = serde_yaml::from_str(
            &serde_yaml::to_string(&left_operations.to_diff().unwrap()).unwrap(),
        )
        .unwrap();
        let serialised_right = serde_yaml::from_str(
            &serde_yaml::to_string(&right_operations.to_diff().unwrap()).unwrap(),
        )
        .unwrap();

        let restored_left_operations =
            EditedText::from_diff(&parent, serialised_left, &*BuiltinTokenizer::Word).unwrap();
        let restored_right_operations =
            EditedText::from_diff(&parent, serialised_right, &*BuiltinTokenizer::Word).unwrap();

        doc.assert_eq_without_cursors(
            &restored_left_operations
                .merge(restored_right_operations)
                .apply()
                .text(),
        );
    }
}

#[test]
fn test_document_inverse_way_without_cursors() {
    for doc in &get_all_documents() {
        doc.assert_eq_without_cursors(
            &reconcile(
                &doc.parent(),
                &doc.right().text().into(),
                &doc.left().text().into(),
                &*BuiltinTokenizer::Word,
            )
            .apply()
            .text(),
        );
    }
}

#[test]
fn test_document_inverse_way_with_cursors() {
    for doc in &get_all_documents() {
        doc.assert_eq(&reconcile(
            &doc.parent(),
            &doc.right(),
            &doc.left(),
            &*BuiltinTokenizer::Word,
        ));
    }
}

fn get_all_documents() -> Vec<ExampleDocument> {
    let examples_dir = Path::new("tests/examples");
    let entries = fs::read_dir(examples_dir)
        .expect("Failed to read examples directory")
        .collect::<Vec<_>>();

    let mut documents = Vec::new();

    for entry in entries {
        let entry = entry.expect("Failed to read directory entry");
        let path = entry.path();

        if path.is_file() && path.extension().and_then(|ext| ext.to_str()) == Some("yml") {
            let file = fs::File::open(&path).expect("Failed to open example file");
            for document in serde_yaml::Deserializer::from_reader(file) {
                let doc =
                    ExampleDocument::deserialize(document).expect("Failed to deserialize document");
                documents.push(doc);
            }
        }
    }

    documents
}