tealdeer 1.9.0

Fetch and show tldr help pages for many CLI commands. Full featured offline client with caching support.
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

//! Functions for printing pages to the terminal

use std::io::{self, BufRead, BufReader, Read, Write};

use anyhow::{Context, Result};
use yansi::Paint;

use crate::{
    config::{Config, PlaceholderFormat, StyleConfig},
    formatter::{PageSnippet, highlight_lines},
    line_iterator::LineIterator,
};

/// Set up display pager
///
/// SAFETY: this function may be called multiple times
#[cfg(not(target_os = "windows"))]
fn configure_pager(_: bool) {
    use std::sync::Once;
    static INIT: Once = Once::new();
    INIT.call_once(|| pager::Pager::with_default_pager("less -R").setup());
}

#[cfg(target_os = "windows")]
fn configure_pager(enable_styles: bool) {
    use crate::utils::print_warning;
    print_warning(enable_styles, "--pager flag not available on Windows!");
}

/// Print page by path
pub fn print_page(
    reader: impl Read,
    enable_markdown: bool,
    enable_styles: bool,
    use_pager: bool,
    config: &Config,
) -> Result<()> {
    let reader = BufReader::new(reader);

    // Configure pager if applicable
    if use_pager || config.display.use_pager {
        configure_pager(enable_styles);
    }

    // Lock stdout only once, this improves performance considerably
    let stdout = io::stdout();
    let mut handle = stdout.lock();

    if enable_markdown {
        // Print the raw markdown of the file.
        for line in reader.lines() {
            let line = line.context("Error while reading from a page")?;
            writeln!(handle, "{line}").context("Could not write to stdout")?;
        }
    } else {
        // Closure that processes a page snippet and writes it to stdout
        let mut process_snippet = |snip: PageSnippet<&str>| {
            if snip.is_empty() {
                Ok(())
            } else {
                print_snippet(
                    &mut handle,
                    snip,
                    &config.style,
                    config.display.placeholder_format,
                )
                .context("Failed to print snippet")
            }
        };

        // Print highlighted lines
        highlight_lines(
            LineIterator::new(reader),
            &mut process_snippet,
            !config.display.compact,
            config.display.show_title,
            config.display.indent,
        )
        .context("Could not write to stdout")?;
    }

    // We're done outputting data, flush stdout now!
    handle.flush().context("Could not flush stdout")?;

    Ok(())
}

fn print_snippet(
    writer: &mut impl Write,
    snip: PageSnippet<&str>,
    style: &StyleConfig,
    placeholder_format: PlaceholderFormat,
) -> io::Result<()> {
    use PageSnippet::*;

    match snip {
        CommandName(s) | Title(s) => write!(writer, "{}", s.paint(style.command_name)),
        Placeholder(s) => write!(writer, "{}", s.paint(style.example_variable)),
        PlaceholderVariants { short, long } => match placeholder_format {
            PlaceholderFormat::Short => write!(writer, "{}", short.paint(style.example_code)),
            PlaceholderFormat::Long => write!(writer, "{}", long.paint(style.example_code)),
            PlaceholderFormat::Both => {
                write!(
                    writer,
                    "{}",
                    format!("[{short}|{long}]").paint(style.example_code)
                )
            }
        },
        NormalCode(s) => write!(writer, "{}", s.paint(style.example_code)),
        Description(s) => write!(writer, "{}", s.paint(style.description)),
        Text(s) => write!(writer, "{}", s.paint(style.example_text)),
        Indent(n) => write!(writer, "{:n$}", ' '),
        Linebreak => writeln!(writer),
    }
}