hjkl-vim 0.10.0

Vim modal state types and grammar primitives for the hjkl editor stack. Pre-1.0 churn.
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

/// Controller commands the host engine implements. hjkl-vim never mutates
/// the editor directly — it emits a command and the host (apps/hjkl) calls
/// the corresponding `Editor` method.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EngineCmd {
    ReplaceChar {
        ch: char,
        count: usize,
    },
    /// Emitted by `PendingState::Find` when the user completes `f<x>` / `F<x>`
    /// / `t<x>` / `T<x>`. The host calls `Editor::find_char`.
    FindChar {
        ch: char,
        forward: bool,
        till: bool,
        count: usize,
    },
    /// Emitted by `PendingState::AfterG` when the user completes `g<x>`. The
    /// host calls `Editor::after_g(ch, count)`.
    AfterGChord {
        ch: char,
        count: usize,
    },
    /// Emitted by `PendingState::AfterZ` when the user completes `z<x>`. The
    /// host calls `Editor::after_z(ch, count)`.
    AfterZChord {
        ch: char,
        count: usize,
    },
    /// `d<motion>` / `y<motion>` / `c<motion>` / `><motion>` / `<<motion>` —
    /// apply operator over a single-key motion. `motion_key` is the raw key
    /// char (e.g. `'w'`, `'$'`, `'G'`). Engine parses via `parse_motion` and
    /// applies. `total_count = count1 * inner_count`.
    ApplyOpMotion {
        op: crate::operator::OperatorKind,
        motion_key: char,
        total_count: usize,
    },
    /// `dd` / `yy` / `cc` / `>>` / `<<` — doubled-letter line op.
    ApplyOpDouble {
        op: crate::operator::OperatorKind,
        total_count: usize,
    },
    /// `diw` etc. — apply operator over text-object range. The reducer owns the
    /// `i`/`a` key via `PendingState::OpTextObj`; on the next char it emits this
    /// command. Host calls `Editor::apply_op_text_obj`.
    ApplyOpTextObj {
        op: crate::operator::OperatorKind,
        ch: char,
        inner: bool,
        total_count: usize,
    },
    /// `dgg` etc. — apply operator over g-chord motion or case-op linewise form.
    /// The reducer owns the `g` key via `PendingState::OpG`; on the next char it
    /// emits this command. Host calls `Editor::apply_op_g`.
    ApplyOpG {
        op: crate::operator::OperatorKind,
        ch: char,
        total_count: usize,
    },
    /// `df<x>` / `dF<x>` / `dt<x>` / `dT<x>` — apply operator over find
    /// motion. Engine builds `Motion::Find { ch, forward, till }` and applies
    /// it. `total_count` is `count1 * inner_count` folded at transition time.
    ///
    /// Replaces `EnterOpFind` (removed in 0.7.0). The reducer no longer sets
    /// engine `Pending::OpFind`; instead it transitions to
    /// `PendingState::OpFind` and emits this command on the next char.
    ApplyOpFind {
        op: crate::operator::OperatorKind,
        ch: char,
        forward: bool,
        till: bool,
        total_count: usize,
    },
    // Future variants land in chunks 2c–2e: GotoMark, etc.
}