hjkl_vim/

pending.rs

/// Pending-state machine for second-key chords. The umbrella stores
/// `Option<PendingState>`; when `Some`, it routes keys through `step`
/// instead of the keymap trie.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PendingState {
    Replace {
        count: usize,
    },
    /// `f<x>` / `F<x>` / `t<x>` / `T<x>` — find single char on current line.
    /// `forward` = direction (true for f/t, false for F/T).
    /// `till` = stop one char before target (true for t/T, false for f/F).
    Find {
        count: usize,
        forward: bool,
        till: bool,
    },
    /// `g<x>` — bare g-prefix chord in Normal / Visual mode. The app sets this
    /// after intercepting `g`; `step` routes the next `Key::Char(ch)` to
    /// `EngineCmd::AfterGChord { ch, count }`. `Key::Esc` cancels; any
    /// non-char key also cancels (mirrors the `Find` arm).
    AfterG {
        count: usize,
    },
    /// `z<x>` — bare z-prefix chord in Normal / Visual mode. The app sets this
    /// after intercepting `z`; `step` routes the next `Key::Char(ch)` to
    /// `EngineCmd::AfterZChord { ch, count }`. `Key::Esc` cancels; any
    /// non-char key also cancels (mirrors the `AfterG` arm).
    AfterZ {
        count: usize,
    },
    /// `d<x>` / `y<x>` / `c<x>` / `><x>` / `<<x>` — bare op-pending entered
    /// from Normal mode after the operator key. `count1` is the count pressed
    /// before the operator; `inner_count` accumulates digits pressed after the
    /// operator (e.g. `d3w` → count1=1, inner_count=3, total=3). The reducer
    /// is authoritative for both counts; `total = count1.max(1) *
    /// inner_count.max(1)` is passed to the engine on completion.
    ///
    /// Vim quirk: a bare `0` when `inner_count == 0` is the line-start motion
    /// (`LineStart`), not a digit. Any other digit, or `0` when `inner_count >
    /// 0`, accumulates.
    AfterOp {
        op: crate::operator::OperatorKind,
        count1: usize,
        inner_count: usize,
    },
    // 2c–2e sub-state variants land later.
}

/// One step of the reducer.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Outcome {
    /// Need more keys — keep accumulating with new state.
    Wait(PendingState),
    /// Run this engine command, then clear pending.
    Commit(crate::cmd::EngineCmd),
    /// Cancel pending (Esc, invalid char, etc.). No engine call.
    Cancel,
    /// Pending state didn't consume this key — host should route it
    /// normally (e.g. modifier-only key). Pending state stays alive.
    Forward,
}

/// `Key` is intentionally minimal — hjkl-vim should not depend on
/// crossterm. Hosts translate their native keys into this shape.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Key {
    Char(char),
    Esc,
    Enter,
    Backspace,
    Tab,
    // Add more variants only as later chunks require them.
}

pub fn step(state: PendingState, key: Key) -> Outcome {
    match state {
        PendingState::Replace { count } => match key {
            Key::Esc => Outcome::Cancel,
            Key::Char(ch) => Outcome::Commit(crate::cmd::EngineCmd::ReplaceChar { ch, count }),
            Key::Enter => Outcome::Commit(crate::cmd::EngineCmd::ReplaceChar { ch: '\n', count }),
            _ => Outcome::Cancel,
        },
        PendingState::Find {
            count,
            forward,
            till,
        } => match key {
            Key::Esc => Outcome::Cancel,
            Key::Char(ch) => Outcome::Commit(crate::cmd::EngineCmd::FindChar {
                ch,
                forward,
                till,
                count,
            }),
            // Any non-char key cancels (vim cancels f<non-char>).
            _ => Outcome::Cancel,
        },
        PendingState::AfterG { count } => match key {
            Key::Esc => Outcome::Cancel,
            Key::Char(ch) => Outcome::Commit(crate::cmd::EngineCmd::AfterGChord { ch, count }),
            // Any non-char key cancels (mirrors Find arm).
            _ => Outcome::Cancel,
        },
        PendingState::AfterZ { count } => match key {
            Key::Esc => Outcome::Cancel,
            Key::Char(ch) => Outcome::Commit(crate::cmd::EngineCmd::AfterZChord { ch, count }),
            // Any non-char key cancels (mirrors AfterG arm).
            _ => Outcome::Cancel,
        },
        PendingState::AfterOp {
            op,
            count1,
            inner_count,
        } => match key {
            Key::Esc => Outcome::Cancel,
            Key::Char(d @ '0'..='9') => {
                // Vim quirk: bare `0` with inner_count==0 is LineStart motion.
                if d == '0' && inner_count == 0 {
                    // Treat as motion key — engine will parse '0' as LineStart.
                    let total = count1.max(1);
                    Outcome::Commit(crate::cmd::EngineCmd::ApplyOpMotion {
                        op,
                        motion_key: '0',
                        total_count: total,
                    })
                } else {
                    let new_inner = inner_count
                        .saturating_mul(10)
                        .saturating_add(d as usize - '0' as usize);
                    Outcome::Wait(PendingState::AfterOp {
                        op,
                        count1,
                        inner_count: new_inner,
                    })
                }
            }
            Key::Char(ch) => {
                let total = count1.max(1) * inner_count.max(1);
                // Doubled letter → line op (dd/yy/cc/>>/<<).
                if ch == op.double_char() {
                    Outcome::Commit(crate::cmd::EngineCmd::ApplyOpDouble {
                        op,
                        total_count: total,
                    })
                // Text object: `i` → inner, `a` → outer.
                } else if ch == 'i' {
                    Outcome::Commit(crate::cmd::EngineCmd::EnterOpTextObj {
                        op,
                        count1,
                        inner: true,
                    })
                } else if ch == 'a' {
                    Outcome::Commit(crate::cmd::EngineCmd::EnterOpTextObj {
                        op,
                        count1,
                        inner: false,
                    })
                // g-chord sub-pending (dgg, dgU, etc.).
                } else if ch == 'g' {
                    Outcome::Commit(crate::cmd::EngineCmd::EnterOpG { op, count1 })
                // Find sub-pending (df/dF/dt/dT).
                } else if ch == 'f' {
                    Outcome::Commit(crate::cmd::EngineCmd::EnterOpFind {
                        op,
                        count1,
                        forward: true,
                        till: false,
                    })
                } else if ch == 'F' {
                    Outcome::Commit(crate::cmd::EngineCmd::EnterOpFind {
                        op,
                        count1,
                        forward: false,
                        till: false,
                    })
                } else if ch == 't' {
                    Outcome::Commit(crate::cmd::EngineCmd::EnterOpFind {
                        op,
                        count1,
                        forward: true,
                        till: true,
                    })
                } else if ch == 'T' {
                    Outcome::Commit(crate::cmd::EngineCmd::EnterOpFind {
                        op,
                        count1,
                        forward: false,
                        till: true,
                    })
                } else {
                    // All other chars: treat as motion key and let the engine
                    // parse it via parse_motion. Unknown keys no-op in the engine.
                    Outcome::Commit(crate::cmd::EngineCmd::ApplyOpMotion {
                        op,
                        motion_key: ch,
                        total_count: total,
                    })
                }
            }
            // Non-char, non-Esc → cancel (mirrors Find/AfterG arms).
            _ => Outcome::Cancel,
        },
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cmd::EngineCmd;
    use crate::operator::OperatorKind;

    // ── AfterG reducer unit tests ────────────────────────────────────────────

    #[test]
    fn after_g_gg_commits() {
        let state = PendingState::AfterG { count: 1 };
        assert_eq!(
            step(state, Key::Char('g')),
            Outcome::Commit(EngineCmd::AfterGChord { ch: 'g', count: 1 })
        );
    }

    #[test]
    fn after_g_gv_commits() {
        let state = PendingState::AfterG { count: 1 };
        assert_eq!(
            step(state, Key::Char('v')),
            Outcome::Commit(EngineCmd::AfterGChord { ch: 'v', count: 1 })
        );
    }

    #[test]
    fn after_g_gu_operator_commits() {
        // gU still produces AfterGChord; the engine handles the Pending::Op transition.
        let state = PendingState::AfterG { count: 1 };
        assert_eq!(
            step(state, Key::Char('U')),
            Outcome::Commit(EngineCmd::AfterGChord { ch: 'U', count: 1 })
        );
    }

    #[test]
    fn after_g_gi_commits() {
        let state = PendingState::AfterG { count: 1 };
        assert_eq!(
            step(state, Key::Char('i')),
            Outcome::Commit(EngineCmd::AfterGChord { ch: 'i', count: 1 })
        );
    }

    #[test]
    fn after_g_esc_cancels() {
        let state = PendingState::AfterG { count: 1 };
        assert_eq!(step(state, Key::Esc), Outcome::Cancel);
    }

    #[test]
    fn after_g_count_carry_through() {
        // 5gg enters with count=5 — AfterGChord carries it through.
        let state = PendingState::AfterG { count: 5 };
        assert_eq!(
            step(state, Key::Char('g')),
            Outcome::Commit(EngineCmd::AfterGChord { ch: 'g', count: 5 })
        );
    }

    #[test]
    fn after_g_non_char_cancels() {
        // Non-char, non-Esc key (e.g. Enter) cancels.
        let state = PendingState::AfterG { count: 1 };
        assert_eq!(step(state, Key::Enter), Outcome::Cancel);
    }

    // ── AfterZ reducer unit tests ────────────────────────────────────────────

    #[test]
    fn after_z_zz_commits() {
        let state = PendingState::AfterZ { count: 1 };
        assert_eq!(
            step(state, Key::Char('z')),
            Outcome::Commit(EngineCmd::AfterZChord { ch: 'z', count: 1 })
        );
    }

    #[test]
    fn after_z_zf_commits() {
        let state = PendingState::AfterZ { count: 1 };
        assert_eq!(
            step(state, Key::Char('f')),
            Outcome::Commit(EngineCmd::AfterZChord { ch: 'f', count: 1 })
        );
    }

    #[test]
    fn after_z_esc_cancels() {
        let state = PendingState::AfterZ { count: 1 };
        assert_eq!(step(state, Key::Esc), Outcome::Cancel);
    }

    #[test]
    fn after_z_count_carry_through() {
        // 3zz enters with count=3 — AfterZChord carries it through.
        let state = PendingState::AfterZ { count: 3 };
        assert_eq!(
            step(state, Key::Char('z')),
            Outcome::Commit(EngineCmd::AfterZChord { ch: 'z', count: 3 })
        );
    }

    #[test]
    fn after_z_non_char_cancels() {
        // Non-char, non-Esc key (e.g. Enter) cancels.
        let state = PendingState::AfterZ { count: 1 };
        assert_eq!(step(state, Key::Enter), Outcome::Cancel);
    }

    // ── AfterOp reducer unit tests ───────────────────────────────────────────

    fn after_op(op: OperatorKind, count1: usize) -> PendingState {
        PendingState::AfterOp {
            op,
            count1,
            inner_count: 0,
        }
    }

    #[test]
    fn op_d_then_w_commits_motion() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('w')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Delete,
                motion_key: 'w',
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_d_then_d_commits_double() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('d')),
            Outcome::Commit(EngineCmd::ApplyOpDouble {
                op: OperatorKind::Delete,
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_d_inner_count_d3w_commits_motion_with_count_3() {
        // d3w: count1=1, inner_count accumulates to 3, total=3.
        let state = after_op(OperatorKind::Delete, 1);
        // Type '3'.
        let Outcome::Wait(state2) = step(state, Key::Char('3')) else {
            panic!("expected Wait");
        };
        assert_eq!(
            state2,
            PendingState::AfterOp {
                op: OperatorKind::Delete,
                count1: 1,
                inner_count: 3
            }
        );
        // Type 'w'.
        assert_eq!(
            step(state2, Key::Char('w')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Delete,
                motion_key: 'w',
                total_count: 3,
            })
        );
    }

    #[test]
    fn op_2d_d_commits_double_with_count_2() {
        // 2dd: count1=2, inner_count=0, doubled → total=2.
        let state = after_op(OperatorKind::Delete, 2);
        assert_eq!(
            step(state, Key::Char('d')),
            Outcome::Commit(EngineCmd::ApplyOpDouble {
                op: OperatorKind::Delete,
                total_count: 2,
            })
        );
    }

    #[test]
    fn op_2d_3w_commits_motion_with_total_6() {
        // 2d3w: count1=2, inner=3, total=6.
        let state = after_op(OperatorKind::Delete, 2);
        let Outcome::Wait(state2) = step(state, Key::Char('3')) else {
            panic!("expected Wait");
        };
        assert_eq!(
            step(state2, Key::Char('w')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Delete,
                motion_key: 'w',
                total_count: 6,
            })
        );
    }

    #[test]
    fn op_d_then_i_emits_enter_op_text_obj_inner_true() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('i')),
            Outcome::Commit(EngineCmd::EnterOpTextObj {
                op: OperatorKind::Delete,
                count1: 1,
                inner: true,
            })
        );
    }

    #[test]
    fn op_d_then_a_emits_enter_op_text_obj_inner_false() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('a')),
            Outcome::Commit(EngineCmd::EnterOpTextObj {
                op: OperatorKind::Delete,
                count1: 1,
                inner: false,
            })
        );
    }

    #[test]
    fn op_d_then_g_emits_enter_op_g() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('g')),
            Outcome::Commit(EngineCmd::EnterOpG {
                op: OperatorKind::Delete,
                count1: 1,
            })
        );
    }

    #[test]
    fn op_d_then_f_emits_enter_op_find_forward_not_till() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('f')),
            Outcome::Commit(EngineCmd::EnterOpFind {
                op: OperatorKind::Delete,
                count1: 1,
                forward: true,
                till: false,
            })
        );
    }

    #[test]
    fn op_d_then_cap_f_emits_enter_op_find_backward_not_till() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('F')),
            Outcome::Commit(EngineCmd::EnterOpFind {
                op: OperatorKind::Delete,
                count1: 1,
                forward: false,
                till: false,
            })
        );
    }

    #[test]
    fn op_d_then_t_emits_enter_op_find_forward_till() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('t')),
            Outcome::Commit(EngineCmd::EnterOpFind {
                op: OperatorKind::Delete,
                count1: 1,
                forward: true,
                till: true,
            })
        );
    }

    #[test]
    fn op_d_then_cap_t_emits_enter_op_find_backward_till() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('T')),
            Outcome::Commit(EngineCmd::EnterOpFind {
                op: OperatorKind::Delete,
                count1: 1,
                forward: false,
                till: true,
            })
        );
    }

    #[test]
    fn op_d_then_esc_cancels() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(step(state, Key::Esc), Outcome::Cancel);
    }

    #[test]
    fn op_d_non_char_cancels() {
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(step(state, Key::Enter), Outcome::Cancel);
    }

    #[test]
    fn op_d_bare_zero_is_line_start_motion() {
        // Bare '0' with inner_count=0 → LineStart motion (total=1).
        let state = after_op(OperatorKind::Delete, 1);
        assert_eq!(
            step(state, Key::Char('0')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Delete,
                motion_key: '0',
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_d_zero_accumulates_when_inner_count_nonzero() {
        // d10w: '1' accumulates to inner=1, then '0' accumulates (inner>0) to inner=10.
        let state = after_op(OperatorKind::Delete, 1);
        let Outcome::Wait(s2) = step(state, Key::Char('1')) else {
            panic!("expected Wait");
        };
        let Outcome::Wait(s3) = step(s2, Key::Char('0')) else {
            panic!("expected Wait");
        };
        assert_eq!(
            s3,
            PendingState::AfterOp {
                op: OperatorKind::Delete,
                count1: 1,
                inner_count: 10,
            }
        );
        assert_eq!(
            step(s3, Key::Char('w')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Delete,
                motion_key: 'w',
                total_count: 10,
            })
        );
    }

    // Per-operator round-trip tests.

    #[test]
    fn op_yank_doubled() {
        let state = after_op(OperatorKind::Yank, 1);
        assert_eq!(
            step(state, Key::Char('y')),
            Outcome::Commit(EngineCmd::ApplyOpDouble {
                op: OperatorKind::Yank,
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_change_doubled() {
        let state = after_op(OperatorKind::Change, 1);
        assert_eq!(
            step(state, Key::Char('c')),
            Outcome::Commit(EngineCmd::ApplyOpDouble {
                op: OperatorKind::Change,
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_indent_doubled() {
        let state = after_op(OperatorKind::Indent, 1);
        assert_eq!(
            step(state, Key::Char('>')),
            Outcome::Commit(EngineCmd::ApplyOpDouble {
                op: OperatorKind::Indent,
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_outdent_doubled() {
        let state = after_op(OperatorKind::Outdent, 1);
        assert_eq!(
            step(state, Key::Char('<')),
            Outcome::Commit(EngineCmd::ApplyOpDouble {
                op: OperatorKind::Outdent,
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_yank_motion() {
        let state = after_op(OperatorKind::Yank, 1);
        assert_eq!(
            step(state, Key::Char('$')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Yank,
                motion_key: '$',
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_change_motion() {
        let state = after_op(OperatorKind::Change, 1);
        assert_eq!(
            step(state, Key::Char('w')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Change,
                motion_key: 'w',
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_indent_motion() {
        let state = after_op(OperatorKind::Indent, 1);
        assert_eq!(
            step(state, Key::Char('j')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Indent,
                motion_key: 'j',
                total_count: 1,
            })
        );
    }

    #[test]
    fn op_outdent_motion() {
        let state = after_op(OperatorKind::Outdent, 1);
        assert_eq!(
            step(state, Key::Char('k')),
            Outcome::Commit(EngineCmd::ApplyOpMotion {
                op: OperatorKind::Outdent,
                motion_key: 'k',
                total_count: 1,
            })
        );
    }
}