hjkl-vim 0.28.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

/// Operator identity carried by the reducer. Kept independent of
/// `hjkl-engine` so `hjkl-vim` has no upstream dependency.
///
/// The five operators that can be entered directly from Normal mode via bare
/// `d` / `y` / `c` / `>` / `<`, plus the four g-prefix case/reflow operators
/// (`gU` / `gu` / `g~` / `gq`) bridged through the reducer in chunk 2c-v.
/// Fold (`zf`) does not enter bare op-pending so it is omitted entirely.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OperatorKind {
    /// `d` — delete.
    Delete,
    /// `y` — yank.
    Yank,
    /// `c` — change (delete + enter Insert mode).
    Change,
    /// `>` — indent.
    Indent,
    /// `<` — outdent.
    Outdent,
    /// `gU` — uppercase.
    Uppercase,
    /// `gu` — lowercase.
    Lowercase,
    /// `g~` — toggle case.
    ToggleCase,
    /// `gq` — reflow / format text.
    Reflow,
    /// `=` — auto-indent (v1 dumb shiftwidth bracket counting).
    AutoIndent,
    /// `!` — filter through external shell command. After the motion fixes the
    /// range the grammar transitions to `PendingFilter` and waits for the
    /// app to supply a command string before emitting `EngineCmd::ApplyFilter`.
    Filter,
    /// `gc` — toggle line comments on the range. `gcc` = current line (doubled-
    /// char convention, like `dd`). `gc{motion}` = motion variant. All three
    /// visual modes resolve to a row range and call `toggle_comment_range`.
    Comment,
}

impl OperatorKind {
    /// The doubled-letter char for this operator.
    ///
    /// Used by the `AfterOp` reducer arm to detect the line-op doubled form:
    /// `dd`, `yy`, `cc`, `>>`, `<<`, `gUU`, `guu`, `g~~`, `gqq`, `gcc`.
    pub(crate) fn double_char(self) -> char {
        match self {
            OperatorKind::Delete => 'd',
            OperatorKind::Yank => 'y',
            OperatorKind::Change => 'c',
            OperatorKind::Indent => '>',
            OperatorKind::Outdent => '<',
            OperatorKind::Uppercase => 'U',
            OperatorKind::Lowercase => 'u',
            OperatorKind::ToggleCase => '~',
            OperatorKind::Reflow => 'q',
            OperatorKind::AutoIndent => '=',
            OperatorKind::Filter => '!',
            // `gcc` — doubled 'c' after `gc` enters the comment operator.
            OperatorKind::Comment => 'c',
        }
    }
}