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

//! Worker spawners + result styling for `App`: every provider call
//! runs on a dedicated thread and reports back over the event channel
//! (PLAN.md §6). Same `impl App` as `mod.rs` — a file split, not a
//! design split.

use super::App;
use crate::components::global_search::SearchKind;
use rootle_provider::{ErrorKind, ProviderError, ProviderResult};

pub(super) mod lenses;
pub(super) mod lifecycle;
pub(super) mod search;
pub(super) mod tracker;

pub(crate) use tracker::Outstanding;

/// Blobs over 1 MiB never enter the app, whatever the provider: the
/// preview pane rejects them anyway, and no backend (in-tree or stdio)
/// should be able to push a giant payload through the pipe. The
/// uniform guarantee lives here, at the boundary, not in each provider
/// (plans/0009 R1).
const BLOB_CAP: usize = 1024 * 1024;

/// fetch_blob with the uniform cap; every blob path in the app goes
/// through this.
fn fetch_blob_capped(
    provider: &dyn rootle_provider::Provider,
    repo: &rootle_provider::RepoId,
    sha: &rootle_provider::Sha,
) -> ProviderResult<Vec<u8>> {
    let bytes = provider.fetch_blob(repo, sha)?;
    if bytes.len() > BLOB_CAP {
        return Err(ProviderError::new(
            ErrorKind::Provider,
            format!(
                "blob {sha} is {} KiB — over the 1 MiB preview cap",
                bytes.len() / 1024
            ),
        ));
    }
    Ok(bytes)
}

impl App {
    /// Style raw hits at the UI boundary: Tree-sitter highlight + grep
    /// match chips (plans/0002 §5). Runs on mock and real hits alike.
    pub(super) fn finish_hits(
        &self,
        hits: Vec<crate::components::global_search::SearchHit>,
        kind: SearchKind,
        query: &str,
    ) -> Vec<crate::components::global_search::SearchHit> {
        let mut hits: Vec<_> = hits
            .into_iter()
            .map(|hit| {
                let lines = self.highlighter.highlight(&hit.path, &hit.preview_text());
                hit.with_highlighted(lines)
            })
            .collect();
        if kind == SearchKind::Grep {
            crate::components::global_search::highlight_matches(
                &mut hits,
                query,
                self.theme.semantic.search_match,
                self.theme.semantic.crust,
            );
        }
        hits
    }
}