vorto 0.9.7

A terminal text editor with tree-sitter syntax highlighting and LSP support
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

//! `Expr::Motion` evaluation — pure cursor moves driven by `MotionKind`.
//! Inclusive-vs-exclusive distinctions matter for operators, not for
//! standalone motions; the inclusivity bit only surfaces in
//! [`super::operator::handle_op`].

use super::{push_word_search, resolve_motion_pure};
use crate::action::{MotionExpr, MotionKind};
use crate::app::App;
use crate::effect::Cmd;
use crate::mode::Mode;

pub(super) fn handle_motion(app: &mut App, m: MotionExpr) -> Vec<Cmd> {
    use MotionKind as M;
    let mut cmds = Vec::new();
    let allow_after = matches!(app.mode, Mode::Insert);
    let n = m.count;

    let (resolved, last_find_update) = resolve_motion_pure(m.motion, app.last_find);
    if let Some(lf) = last_find_update {
        cmds.push(Cmd::SetLastFind(lf));
    }
    let Some(resolved) = resolved else {
        cmds.push(Cmd::ToastError("no previous find".into()));
        return cmds;
    };

    match resolved {
        M::Left => {
            for _ in 0..n {
                app.buffer.move_left();
            }
        }
        M::Right => {
            for _ in 0..n {
                app.buffer.move_right(allow_after);
            }
        }
        M::Up => {
            for _ in 0..n {
                app.buffer.move_up();
            }
        }
        M::Down => {
            for _ in 0..n {
                app.buffer.move_down();
            }
        }
        M::LineStart => app.buffer.move_line_start(),
        M::LineEnd => app.buffer.move_line_end(),
        // `*` / `#` extract the word under the cursor (buffer
        // read), then ask the runtime to seed the search state
        // and jump. The buffer mutation for the cursor jump
        // happens during `JumpSearch` because it depends on the
        // updated search pattern.
        M::SearchWordForward => push_word_search(app, &mut cmds, true, true),
        M::SearchWordBack => push_word_search(app, &mut cmds, false, true),
        M::WordForward => {
            for _ in 0..n {
                app.buffer.move_word_forward();
            }
        }
        M::WordBack => {
            for _ in 0..n {
                app.buffer.move_word_backward();
            }
        }
        // Pure motions: ask the buffer for the target and assign.
        M::WordEnd
        | M::BigWordForward
        | M::BigWordBack
        | M::BigWordEnd
        | M::WordEndBack
        | M::BigWordEndBack
        | M::LineFirstNonBlank
        | M::LineLastNonBlank
        | M::BracketMatch
        | M::FindChar { .. }
        | M::ViewportTop
        | M::ViewportMiddle
        | M::ViewportBottom
        | M::HalfPageDown
        | M::HalfPageUp
        | M::PageDown
        | M::PageUp => {
            let target = app.buffer.motion_target(app.buffer.cursor, resolved, n);
            app.buffer.cursor = target;
        }
        // Resolved away by `resolve_motion_pure` — should never
        // reach the match arm.
        M::RepeatFind { .. } => {}
        // `gg` with no count goes to line 1; `5gg` to line 5.
        M::FileStart => {
            if n > 1 {
                app.goto_line_n_pure(n as usize);
            } else {
                app.buffer.move_file_start();
            }
        }
        // `G` with no count goes to file end; `20G` to line 20.
        M::FileEnd => {
            if n > 1 {
                app.goto_line_n_pure(n as usize);
            } else {
                app.buffer.move_file_end();
            }
        }
        M::SearchNext => {
            for _ in 0..n {
                cmds.push(Cmd::JumpSearch { reverse: false });
            }
        }
        M::SearchPrev => {
            for _ in 0..n {
                cmds.push(Cmd::JumpSearch { reverse: true });
            }
        }
        M::ParagraphForward => {
            for _ in 0..n {
                app.buffer.move_paragraph_forward();
            }
        }
        M::ParagraphBack => {
            for _ in 0..n {
                app.buffer.move_paragraph_backward();
            }
        }
    }
    cmds
}