sim-codec-doc 0.1.1

Markup document codec backends for SIM.
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::{Inline, MarkupBlock, MarkupDoc, MarkupEdit, Span, SpanState, apply_edit, invert_edit};

#[test]
fn invert_edit_is_involutive() {
    let edits = vec![
        MarkupEdit::SetTitle {
            old: Some("Old".to_owned()),
            new: Some("New".to_owned()),
        },
        MarkupEdit::InsertBlock {
            index: 1,
            block: paragraph("Inserted", None),
        },
        MarkupEdit::ReplaceBlock {
            index: 0,
            old: paragraph("Old", None),
            new: paragraph("New", None),
        },
        MarkupEdit::DeleteBlock {
            index: 0,
            old: paragraph("Old", None),
        },
        MarkupEdit::SetInlineText {
            block: 0,
            path: vec![1, 0],
            old: "old".to_owned(),
            new: "new".to_owned(),
        },
    ];

    for edit in edits {
        assert_eq!(invert_edit(&invert_edit(&edit)), edit);
    }
}

#[test]
fn apply_then_inverse_restores_document() {
    let original = MarkupDoc {
        title: Some("Guide".to_owned()),
        attrs: Default::default(),
        source: None,
        blocks: vec![paragraph("Alpha beta.", None)],
    };
    let edit = MarkupEdit::SetInlineText {
        block: 0,
        path: vec![0],
        old: "Alpha beta.".to_owned(),
        new: "Gamma.".to_owned(),
    };
    let mut edited = original.clone();

    apply_edit(&mut edited, &edit).unwrap();
    apply_edit(&mut edited, &invert_edit(&edit)).unwrap();

    assert_eq!(edited, original);
}

#[test]
fn dirty_spans_stay_local() {
    let mut doc = MarkupDoc {
        title: None,
        attrs: Default::default(),
        source: None,
        blocks: vec![
            paragraph(
                "Alpha",
                Some(Span {
                    start: 0,
                    end: 5,
                    state: SpanState::Preserved,
                }),
            ),
            paragraph(
                "Beta",
                Some(Span {
                    start: 7,
                    end: 11,
                    state: SpanState::Preserved,
                }),
            ),
        ],
    };
    let edit = MarkupEdit::SetInlineText {
        block: 0,
        path: vec![0],
        old: "Alpha".to_owned(),
        new: "Gamma".to_owned(),
    };

    apply_edit(&mut doc, &edit).unwrap();

    assert_eq!(block_span_state(&doc.blocks[0]), Some(&SpanState::Dirty));
    assert_eq!(
        block_span_state(&doc.blocks[1]),
        Some(&SpanState::Preserved)
    );
}

#[test]
fn edit_roundtrips_through_value_expr() {
    let edits = vec![
        MarkupEdit::SetTitle {
            old: None,
            new: Some("Guide".to_owned()),
        },
        MarkupEdit::InsertBlock {
            index: 0,
            block: paragraph("Inserted", None),
        },
        MarkupEdit::ReplaceBlock {
            index: 0,
            old: paragraph("Old", None),
            new: paragraph("New", None),
        },
        MarkupEdit::DeleteBlock {
            index: 0,
            old: paragraph("Old", None),
        },
        MarkupEdit::SetInlineText {
            block: 0,
            path: vec![0],
            old: "Old".to_owned(),
            new: "New".to_owned(),
        },
    ];

    for edit in edits {
        let decoded = MarkupEdit::from_expr(&edit.as_expr()).unwrap();
        assert_eq!(decoded, edit);
    }
}

fn paragraph(text: &str, span: Option<Span>) -> MarkupBlock {
    MarkupBlock::Paragraph {
        content: vec![Inline::Text(text.to_owned())],
        span,
    }
}

fn block_span_state(block: &MarkupBlock) -> Option<&SpanState> {
    match block {
        MarkupBlock::Paragraph {
            span: Some(span), ..
        } => Some(&span.state),
        _ => None,
    }
}