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
111
112
113
114
115
116
117
118
119
120
121

use editor_core::{
    Command, CommandExecutor, CommandResult, CursorCommand, EditCommand, SearchOptions,
};

fn opts(case_sensitive: bool, whole_word: bool, regex: bool) -> SearchOptions {
    SearchOptions {
        case_sensitive,
        whole_word,
        regex,
    }
}

#[test]
fn test_find_next_and_prev_basic() {
    let mut executor = CommandExecutor::new("Hello hello HELLO", 80);

    // Find next (case-sensitive): should match the lowercase "hello".
    let result = executor
        .execute(Command::Cursor(CursorCommand::FindNext {
            query: "hello".to_string(),
            options: opts(true, false, false),
        }))
        .unwrap();
    let CommandResult::SearchMatch { start, end } = result else {
        panic!("expected CommandResult::SearchMatch");
    };
    assert_eq!((start, end), (6, 11));

    // Find prev from current selection start: should match the leading "Hello" with case-insensitive.
    let result = executor
        .execute(Command::Cursor(CursorCommand::FindPrev {
            query: "hello".to_string(),
            options: opts(false, false, false),
        }))
        .unwrap();
    let CommandResult::SearchMatch { start, end } = result else {
        panic!("expected CommandResult::SearchMatch");
    };
    assert_eq!((start, end), (0, 5));
}

#[test]
fn test_find_whole_word() {
    let mut executor = CommandExecutor::new("foobar foo barfoo foo", 80);

    let result = executor
        .execute(Command::Cursor(CursorCommand::FindNext {
            query: "foo".to_string(),
            options: opts(true, true, false),
        }))
        .unwrap();
    let CommandResult::SearchMatch { start, end } = result else {
        panic!("expected CommandResult::SearchMatch");
    };
    assert_eq!((start, end), (7, 10));

    let result = executor
        .execute(Command::Cursor(CursorCommand::FindNext {
            query: "foo".to_string(),
            options: opts(true, true, false),
        }))
        .unwrap();
    let CommandResult::SearchMatch { start, end } = result else {
        panic!("expected CommandResult::SearchMatch");
    };
    assert_eq!((start, end), (18, 21));
}

#[test]
fn test_replace_current_is_single_undo_step() {
    let mut executor = CommandExecutor::new("foo foo", 80);

    // Select the first "foo".
    executor
        .execute(Command::Cursor(CursorCommand::FindNext {
            query: "foo".to_string(),
            options: opts(true, true, false),
        }))
        .unwrap();

    assert_eq!(executor.undo_depth(), 0);

    executor
        .execute(Command::Edit(EditCommand::ReplaceCurrent {
            query: "foo".to_string(),
            replacement: "bar".to_string(),
            options: opts(true, true, false),
        }))
        .unwrap();

    assert_eq!(executor.editor().get_text(), "bar foo");
    assert_eq!(executor.undo_depth(), 1);

    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    assert_eq!(executor.editor().get_text(), "foo foo");

    executor.execute(Command::Edit(EditCommand::Redo)).unwrap();
    assert_eq!(executor.editor().get_text(), "bar foo");
}

#[test]
fn test_replace_all_is_single_undo_step_and_supports_regex_replacement() {
    let mut executor = CommandExecutor::new("foo1 foo2 foo3", 80);

    executor
        .execute(Command::Edit(EditCommand::ReplaceAll {
            query: "foo(\\d)".to_string(),
            replacement: "bar$1".to_string(),
            options: opts(true, false, true),
        }))
        .unwrap();

    assert_eq!(executor.editor().get_text(), "bar1 bar2 bar3");
    assert_eq!(executor.undo_depth(), 1);

    executor.execute(Command::Edit(EditCommand::Undo)).unwrap();
    assert_eq!(executor.editor().get_text(), "foo1 foo2 foo3");

    executor.execute(Command::Edit(EditCommand::Redo)).unwrap();
    assert_eq!(executor.editor().get_text(), "bar1 bar2 bar3");
}