editor-core 0.4.1

A headless editor engine focused on state management, Unicode-aware text measurement, and coordinate conversion.
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

use editor_core::{Command, CommandExecutor, EditCommand};

#[test]
fn undo_tree_preserves_alternate_branches_and_allows_branch_selection() {
    let mut executor = CommandExecutor::empty(80);

    // Build a simple linear history: a -> ab
    executor
        .execute(Command::Edit(EditCommand::InsertText { text: "a".into() }))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::EndUndoGroup))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::InsertText { text: "b".into() }))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::EndUndoGroup))
        .unwrap();
    assert_eq!(executor.editor().get_text(), "ab");

    // Undo back to the branch point: "a"
    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    assert_eq!(executor.editor().get_text(), "a");
    assert_eq!(executor.redo_branch_count(), 1);

    // Create a new branch from "a": "ac"
    executor
        .execute(Command::Edit(EditCommand::InsertText { text: "c".into() }))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::EndUndoGroup))
        .unwrap();
    assert_eq!(executor.editor().get_text(), "ac");
    assert!(!executor.can_redo());

    // Undo to the branch point again: now there are *two* redo branches ("b" and "c").
    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    assert_eq!(executor.editor().get_text(), "a");
    assert_eq!(executor.redo_branch_count(), 2);
    assert!(executor.can_redo());

    // By default, redo follows the branch we just came from ("c").
    executor.execute(Command::Edit(EditCommand::Redo)).unwrap();
    assert_eq!(executor.editor().get_text(), "ac");

    // Undo again, then select the *other* branch ("b") and redo.
    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    assert_eq!(executor.editor().get_text(), "a");
    assert_eq!(executor.redo_branch_count(), 2);

    executor.select_redo_branch(0).unwrap();
    executor.execute(Command::Edit(EditCommand::Redo)).unwrap();
    assert_eq!(executor.editor().get_text(), "ab");
}

#[test]
fn redo_depth_follows_selected_branch_in_undo_tree() {
    let mut executor = CommandExecutor::empty(80);

    // a -> ab -> abd
    executor
        .execute(Command::Edit(EditCommand::InsertText { text: "a".into() }))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::EndUndoGroup))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::InsertText { text: "b".into() }))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::EndUndoGroup))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::InsertText { text: "d".into() }))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::EndUndoGroup))
        .unwrap();
    assert_eq!(executor.editor().get_text(), "abd");

    // Undo back to "a" (two steps).
    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    assert_eq!(executor.editor().get_text(), "a");

    // New branch from "a": "ac"
    executor
        .execute(Command::Edit(EditCommand::InsertText { text: "c".into() }))
        .unwrap();
    executor
        .execute(Command::Edit(EditCommand::EndUndoGroup))
        .unwrap();
    assert_eq!(executor.editor().get_text(), "ac");

    // Undo to branch point again.
    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    assert_eq!(executor.editor().get_text(), "a");

    // There are 2 redo branches:
    // - branch 0: "b" then "d" (redo_depth == 2)
    // - branch 1: "c" (redo_depth == 1)
    assert_eq!(executor.redo_branch_count(), 2);

    executor.select_redo_branch(0).unwrap();
    assert_eq!(executor.redo_depth(), 2);

    executor.select_redo_branch(1).unwrap();
    assert_eq!(executor.redo_depth(), 1);
}