rootle 0.4.0

Modal TUI for browsing remote source-control systems (GitHub in-tree, any forge via stdio providers) 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

//! Repo tree queries: a fetched recursive tree reduced to the
//! miller-column questions the browser asks — "what are this path's
//! direct children?" and "where is this path's node?".

use crate::components::pane::{Entry, EntryKind};
use crate::provider::TreeNode;

/// A repo's full recursive tree, paths relative to the repo root.
pub struct RepoTree {
    pub owner: String,
    pub name: String,
    pub truncated: bool,
    /// Default branch (yank URLs, blob links).
    pub branch: String,
    entries: Vec<TreeNode>,
}

impl RepoTree {
    pub fn new(
        owner: String,
        name: String,
        truncated: bool,
        branch: String,
        entries: Vec<TreeNode>,
    ) -> Self {
        RepoTree {
            owner,
            name,
            truncated,
            branch,
            entries,
        }
    }

    /// Direct children of `path` ("" = root), dirs first, then files,
    /// alphabetical within each group.
    pub fn children(&self, path: &str) -> Vec<Entry> {
        let prefix = if path.is_empty() {
            String::new()
        } else {
            format!("{path}/")
        };
        let mut dirs = Vec::new();
        let mut files = Vec::new();
        for node in &self.entries {
            let Some(rest) = node.path.strip_prefix(&prefix) else {
                continue;
            };
            if rest.is_empty() || rest.contains('/') {
                continue;
            }
            let entry = Entry::new(
                rest,
                if node.is_dir {
                    EntryKind::Dir
                } else {
                    EntryKind::File
                },
            );
            if node.is_dir {
                dirs.push(entry);
            } else {
                files.push(entry);
            }
        }
        let by_name = |a: &Entry, b: &Entry| a.name.cmp(&b.name);
        dirs.sort_by(by_name);
        files.sort_by(by_name);
        dirs.extend(files);
        dirs
    }

    pub fn find(&self, path: &str) -> Option<&TreeNode> {
        self.entries.iter().find(|e| e.path == path)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn node(path: &str, is_dir: bool) -> TreeNode {
        TreeNode {
            path: path.into(),
            is_dir,
            sha: "sha".into(),
            size: Some(1),
        }
    }

    #[test]
    fn children_lists_direct_only_dirs_first() {
        let tree = RepoTree::new(
            "o".into(),
            "r".into(),
            false,
            "main".into(),
            vec![
                node("src", true),
                node("src/zeta.rs", false),
                node("src/alpha.rs", false),
                node("src/nested/deep.rs", false), // not a direct child
                node("src/widgets", true),
                node("zdocs.md", false),
                node("lib.rs", false),
            ],
        );
        let root: Vec<String> = tree.children("").iter().map(|e| e.name.clone()).collect();
        assert_eq!(root, vec!["src", "lib.rs", "zdocs.md"]);
        let src: Vec<String> = tree
            .children("src")
            .iter()
            .map(|e| e.name.clone())
            .collect();
        assert_eq!(src, vec!["widgets", "alpha.rs", "zeta.rs"]);
        assert!(tree.find("src/widgets").is_some());
    }
}