rootle 0.13.1

Modal TUI for browsing remote source-control systems from the terminal
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
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

//! Input for App.

use super::diagnostics;
use super::{Action, App, Component, KeyEvent, Mode, Outcome, keymap};

impl App {
    /// Shared interactive/headless boundary. Drivers own waiting and drawing,
    /// while input admission, worker lifetimes and diagnostics have one owner.
    pub fn handle_event(&mut self, event: crate::event::AppEvent) {
        use crate::event::AppEvent;
        use ratatui::crossterm::event::Event;
        match event {
            AppEvent::Terminal(Event::Key(key)) => self.handle_key(key),
            AppEvent::Terminal(Event::Resize(columns, rows)) => {
                rootle_trace::record_with(
                    rootle_trace::EventKind::Resize,
                    || serde_json::json!({"columns": columns, "rows": rows, "source": "input"}),
                );
            }
            AppEvent::Terminal(ignored) => {
                rootle_trace::record_with(rootle_trace::EventKind::Input, || match ignored {
                    Event::Paste(text) => serde_json::json!({
                        "kind": "paste", "handled": false, "bytes": text.len(),
                        "text": rootle_trace::capture_content().then_some(text.as_str()),
                    }),
                    Event::FocusGained => {
                        serde_json::json!({"kind": "focus_gained", "handled": false})
                    }
                    Event::FocusLost => {
                        serde_json::json!({"kind": "focus_lost", "handled": false})
                    }
                    Event::Mouse(_) => serde_json::json!({"kind": "mouse", "handled": false}),
                    Event::Key(_) | Event::Resize(..) => unreachable!(),
                });
            }
            worker => self.handle_app_event(worker),
        }
    }

    pub(super) fn effective_mode(&self) -> Mode {
        if self.consent.is_some() {
            return Mode::Browse;
        }
        if let Some(wizard) = &self.wizard {
            return wizard.effective_mode();
        }
        if let Some(settings) = &self.settings {
            return settings.effective_mode();
        }
        if let Some(help) = &self.help {
            return help.effective_mode();
        }
        if let Some(refs) = &self.refs_popup {
            return refs.effective_mode();
        }
        if self.command_line.is_some() {
            return Mode::Insert;
        }
        if self.mode == Mode::History && self.browser.history_filtering() {
            return Mode::Search;
        }
        if self.mode == Mode::Commit
            && self
                .browser
                .commit_ref()
                .is_some_and(|view| view.filtering())
        {
            return Mode::Search;
        }
        if self.mode == Mode::Commit
            && self
                .browser
                .commit_ref()
                .is_some_and(|view| view.searching())
        {
            return Mode::Find;
        }
        if let Some(view) = &self.search_view {
            // The leader layer can be raised over the view (␣ from the
            // results) — it owns the keys and the modeline while up.
            if self.mode == Mode::Leader {
                return Mode::Leader;
            }
            return view.effective_mode();
        }
        match &self.popup {
            Some(popup) => popup.effective_mode(),
            None => self.mode,
        }
    }
    pub fn handle_key(&mut self, key: KeyEvent) {
        rootle_trace::in_operation(rootle_trace::operation_id(), || {
            diagnostics::record_key(&key, self.effective_mode().chip());
            let action = self.dispatch(key);
            self.handle_action(action);
            diagnostics::record_state(self, "post_key");
        });
    }

    pub(super) fn dispatch(&mut self, key: KeyEvent) -> Action {
        // Overlays capture keys, topmost first — the consent popup is
        // the very top: a pending trust decision outranks everything.
        if let Some(consent) = &mut self.consent {
            return consent.handle_key(key);
        }
        if let Some(wizard) = &mut self.wizard {
            return wizard.handle_key(key);
        }
        if let Some(settings) = &mut self.settings {
            return settings.handle_key(key);
        }
        if let Some(help) = &mut self.help {
            return help.handle_key(key);
        }
        if let Some(refs) = &mut self.refs_popup {
            return refs.handle_key(key);
        }
        if let Some(command_line) = &mut self.command_line {
            return command_line.handle_key(key);
        }
        if let Some(view) = &mut self.search_view {
            // While the leader layer is up, it owns the keys — the
            // view regains them on the action that follows.
            if self.mode == Mode::Leader {
                return keymap::leader(key.code);
            }
            return view.handle_key(key);
        }
        if let Some(popup) = &mut self.popup {
            return popup.handle_key(key);
        }
        match self.mode {
            Mode::Browse => keymap::browsing(key.code),
            Mode::Visual => keymap::visual(key.code),
            Mode::Search => match self.browser.filter_input.handle_key(key) {
                Outcome::Changed => Action::Noop, // filter applied below
                Outcome::Submitted => Action::CommitFilter,
                Outcome::Cancelled => Action::ClearFilter,
                Outcome::Noop => Action::Noop,
            },
            Mode::Find => match self.browser.find_input.handle_key(key) {
                Outcome::Changed => Action::UpdateFind,
                Outcome::Submitted => Action::CommitFind,
                Outcome::Cancelled => Action::CancelFind,
                Outcome::Noop => Action::Noop,
            },
            Mode::Leader => keymap::leader(key.code),
            Mode::History => {
                // An active `/` session owns the keys until commit.
                if self.browser.history_filtering() {
                    Action::HistoryFilterKey(key)
                } else if self.browser.repository_history_active() {
                    keymap::repository_history(key.code)
                } else {
                    keymap::history(key.code)
                }
            }
            Mode::Preview => self.browser.preview_key(key),
            Mode::Commit => self
                .browser
                .commit()
                .map(|view| view.handle_key(key))
                .unwrap_or(Action::Noop),
            _ => Action::Noop,
        }
    }

    /// Dispatch: domain files own the arms (plans/0021 M1) —
    /// `try_*` returns the action back when it isn't theirs. The
    /// shared tail (filter re-apply, theme sync, blob drain, provider
    /// notices) applies to every routed action.
    pub fn handle_action(&mut self, action: Action) {
        diagnostics::record_action(&action);
        match &action {
            Action::RepoSelected { .. } | Action::OrgSelected(_) | Action::LoadRepoTree { .. } => {
                self.requests.search = crate::request::LoadState::default();
                self.requests.invalidate_browser();
            }
            Action::BlameToggle => self.requests.blame.invalidate(),
            Action::HistoryUp | Action::HistoryDown => self.requests.historical_blob.invalidate(),
            Action::ClosePopup => {
                self.requests.search = crate::request::LoadState::default();
                self.requests.references.invalidate();
            }
            _ => {}
        }
        let left = self
            .try_browse(action)
            .and_then(|a| self.try_search(a))
            .and_then(|a| self.try_lenses(a))
            .and_then(|a| self.try_lifecycle(a));
        debug_assert!(left.is_none(), "unrouted action: {left:?}");
        let _ = left;
        if !self.browser.history_is_open() {
            self.requests.historical_blob.invalidate();
        }
        // Incremental filter: re-apply on every SEARCH keystroke.
        if self.mode == Mode::Search {
            self.browser.apply_filter();
        }

        // Theme switches (settings live preview, then commit) restyle
        // the code the same frame the chrome recolors.
        self.sync_highlight_theme();

        // Any state change can leave a file under the cursor without its
        // blob (navigation, filter commit/clear, tree loads) — drain it
        // uniformly at the end of every route.
        self.maybe_load_blob();

        // Provider notices ride the status line once (plans/0008 §5).
        // 0022 M1: a restart-failure streak goes sticky; successes
        // stay transient.
        if let Some(note) = self.provider.take_notice() {
            if note.contains("keeps failing to restart") {
                self.degraded = Some(note.clone());
            }
            self.status = Some(note);
        }
        diagnostics::record_state(self, "post_action");
    }
}