rizzler 0.1.0

the rizz editor
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

use crate::action::Action;
use crate::keymap::{KeyCode, KeyEvent};
use std::collections::HashMap;
use std::rc::Rc;

#[derive(Debug, Clone)]
pub enum Trie {
    Node {
        children: HashMap<KeyEvent, Rc<Trie>>,
        /// Catches any `KeyCode::Char(_)` not bound in `children`, producing
        /// an action from the captured char. Terminal — does not descend.
        on_char: Option<fn(char) -> Action>,
    },
    Leaf(Rc<Action>),
}
impl Trie {
    pub fn empty() -> Trie {
        Trie::Node {
            children: HashMap::new(),
            on_char: None,
        }
    }

    /// Bind `keys` to `action` under this node, creating intermediate nodes
    /// as needed. A conflicting binding on the same path is overwritten
    /// (last write wins).
    pub fn insert_path(node: &mut Rc<Trie>, keys: &[KeyEvent], action: Rc<Action>) {
        match keys {
            [] => {
                // End of the path: this slot becomes the action.
                *node = Rc::new(Trie::Leaf(action));
            }
            [first, rest @ ..] => {
                let km = Rc::make_mut(node);
                // A path can only continue through a node; promote a leaf.
                if !matches!(km, Trie::Node { .. }) {
                    *km = Trie::empty();
                }
                if let Trie::Node { children, .. } = km {
                    let child = children
                        .entry(*first)
                        .or_insert_with(|| Rc::new(Trie::empty()));
                    Trie::insert_path(child, rest, action);
                }
            }
        }
    }

    /// Remove the binding at `keys`. Returns the action if the path pointed at
    /// a leaf (if it pointed at an intermediate node, the whole subtree is
    /// removed and `None` is returned). Empty intermediate nodes are pruned.
    pub fn remove_path(node: &mut Rc<Trie>, keys: &[KeyEvent]) -> Option<Rc<Action>> {
        match keys {
            [] => None, // can't remove the root through this API
            [last] => {
                let Trie::Node { children, .. } = Rc::make_mut(node) else {
                    return None;
                };
                match children.remove(last)?.as_ref() {
                    Trie::Leaf(action) => Some(action.clone()),
                    Trie::Node { .. } => None,
                }
            }
            [first, rest @ ..] => {
                let Trie::Node { children, .. } = Rc::make_mut(node) else {
                    return None;
                };
                let child = children.get_mut(first)?;
                let removed = Trie::remove_path(child, rest);
                // Prune the child if removing left it as an empty node.
                let prune = matches!(
                    child.as_ref(),
                    Trie::Node { children, on_char: None } if children.is_empty()
                );
                if prune {
                    children.remove(first);
                }
                removed
            }
        }
    }
}

pub enum WalkOutcome {
    Action(Rc<Action>),
    Descend(Rc<Trie>),
    Miss,
}

/// Resolve one key against `trie`. Returns either the matched action, the
/// next subtree to wait on, or a miss. A `Trie::Leaf` root maps every key to
/// the same action; otherwise we look up `key` directly, then fall back to
/// the node's `on_char` wildcard if `key` is a printable char.
pub fn walk(trie: &Trie, key: KeyEvent) -> WalkOutcome {
    match trie {
        Trie::Leaf(a) => WalkOutcome::Action(a.clone()),
        Trie::Node { children, on_char } => {
            if let Some(next) = children.get(&key) {
                match next.as_ref() {
                    Trie::Leaf(a) => WalkOutcome::Action(a.clone()),
                    Trie::Node { .. } => WalkOutcome::Descend(next.clone()),
                }
            } else if let (Some(f), KeyCode::Char(c)) = (on_char, key.code) {
                WalkOutcome::Action(f(c).into())
            } else {
                WalkOutcome::Miss
            }
        }
    }
}