term-rustdoc 0.2.0

A TUI for Rust docs.
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

// fenced codeblock including the tags and snippet are special in rustdoc:
// * empty fence tag means Rust code
// * extra tags following `rust,` hint extra rendering
// * code snippet beginning with `# ` is hidden as default

use super::{convert_style, Block, Line, MetaTag, Word, SYNTHEME};
use ratatui::style::{Color, Style};
use syntect::{easy::HighlightLines, util::LinesWithEndings};

pub fn parse(fence: &mut str, code: &str) -> Block {
    fence.make_ascii_lowercase();
    match &*fence {
        "" | "rust" | "rs" => rust(code),
        _ => other(fence, code),
    }
}

fn word(text: &str, style: syntect::highlighting::Style) -> Word {
    Word {
        word: text.into(),
        style: convert_style(style),
        tag: MetaTag::CodeBlock("rust".into()),
        trailling_whitespace: false,
    }
}

/// If the lang is not in SyntaxSet, first fall back to Rust lang, then this one.
#[cold]
fn fallback(code: &str) -> Block {
    code.lines()
        .map(|line| Word {
            word: line.into(),
            style: Style {
                fg: Some(Color::LightRed),
                ..Default::default()
            },
            tag: MetaTag::CodeBlock("Unknown".into()),
            trailling_whitespace: false,
        })
        .collect()
}

pub fn rust(code: &str) -> Block {
    SYNTHEME.with(|(ps, ts)| {
        let Some(syntax) = ps.find_syntax_by_name("Rust") else {
            return fallback(code);
        };
        let mut h = HighlightLines::new(syntax, &ts.themes["base16-ocean.dark"]);
        let mut lines = Vec::with_capacity(8);
        // filter out the lines starting `# ` used for hidden lines
        for line in code.lines().filter(|l| !{
            // a line begins with optional whitespaces and `# `, or a line with mere `#`
            let line = l.trim();
            line.starts_with("# ") || line == "#"
        }) {
            let mut words = Vec::with_capacity(8);
            for (style, text) in h.highlight_line(line, ps).unwrap() {
                words.push(word(text, style));
            }
            lines.push(Line::from_iter(words));
        }
        let mut block = Block::from_iter(lines);
        block.shrink_to_fit();
        block
    })
}

macro_rules! gen_parse_code {
    ($( $fname:ident ),+) => { $(
        pub fn $fname(code: &str) -> Block {
            SYNTHEME.with(|(ps, ts)| {
                let Some(syntax) = ps.find_syntax_by_name(stringify!($fname)) else {
                    return rust(code);
                };
                gen_parse_code! { #inner code ps ts syntax }
            })
        }
        )+ };
    (#inner $code:ident $ps:ident $ts:ident $syntax:ident) => {
        let mut h = HighlightLines::new($syntax, &$ts.themes["base16-ocean.dark"]);
        let mut lines = Vec::with_capacity(8);
        for line in LinesWithEndings::from($code) {
            let mut words = Vec::with_capacity(8);
            for (style, text) in h.highlight_line(line, $ps).unwrap() {
                words.push(word(text, style));
            }
            lines.push(Line::from_iter(words));
        }
        let mut block = Block::from_iter(lines);
        block.shrink_to_fit();
        block
    };
}

/// If the lang is not found by file extention, use Rust as fallback.
pub fn other(lang: &str, code: &str) -> Block {
    SYNTHEME.with(|(ps, ts)| {
        let Some(syntax) = ps.find_syntax_by_extension(lang) else {
            return rust(code);
        };
        gen_parse_code! { #inner code ps ts syntax }
    })
}

gen_parse_code!(markdown);

pub fn md_table(table: &str) -> Block {
    markdown(table)
}