marustdown 0.1.2

A fast, configurable terminal markdown viewer with syntax highlighting, task toggling and keyboard link following
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

mod cli;
mod config;
mod doc;
mod highlight;
mod keys;
mod layout;
mod links;
mod pager;
mod render;
mod search;
mod source;
mod table;
mod theme;
mod wrap;

use std::io::{self, IsTerminal};
use std::process::ExitCode;

use clap::error::ErrorKind;
use clap::{CommandFactory, Parser};

use cli::{Args, ColorMode};
use doc::Document;
use keys::Keymap;
use source::Source;
use theme::Theme;

fn main() -> ExitCode {
    match run(Args::parse()) {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            eprintln!("mar: {e}");
            ExitCode::FAILURE
        }
    }
}

fn run(args: Args) -> Result<(), String> {
    let color = if args.no_color {
        ColorMode::Never
    } else {
        args.color
    };
    let overrides = config::Overrides {
        theme: args.theme.as_deref(),
        no_icons: args.no_icons,
        no_color: color == ColorMode::Never
            || std::env::var_os("NO_COLOR").is_some_and(|v| !v.is_empty()),
    };
    let mut cfg = config::load(args.config.as_deref(), &overrides)?;
    if let Some(width) = args.width {
        cfg.layout.width = width;
    }
    let terminal = io::stdout().is_terminal();
    let paged = !args.cat && terminal;
    let plain = match color {
        ColorMode::Auto => !terminal,
        ColorMode::Always => false,
        ColorMode::Never => true,
    };
    if !paged {
        cfg.glyphs.code_copy.clear();
    }
    let theme = Theme::new(cfg)?;
    let keys = Keymap::new(&theme.keys)?;

    let path = args.file.filter(|p| p.as_os_str() != "-");
    let source = match &path {
        Some(p) => Source::open(p).map_err(|e| format!("{}: {e}", p.display()))?,
        None if io::stdin().is_terminal() => Args::command()
            .error(
                ErrorKind::MissingRequiredArgument,
                "no input: pass a file or pipe markdown to stdin",
            )
            .exit(),
        None => Source::stdin().map_err(|e| format!("stdin: {e}"))?,
    };

    let result = if paged {
        pager::run(source, path, &theme, keys)
    } else {
        cat(&source, &theme, plain)
    };
    match result {
        Err(e) if e.kind() == io::ErrorKind::BrokenPipe => Ok(()),
        r => r.map_err(|e| e.to_string()),
    }
}

fn cat(source: &Source, theme: &Theme, plain: bool) -> io::Result<()> {
    let (width, margin) = match crossterm::terminal::size() {
        Ok((cols, _)) if io::stdout().is_terminal() => theme.layout.fit(cols as usize),
        _ => (theme.layout.width, 0),
    };
    let mut doc = Document::new();
    doc.layout(source.text(), width, theme);
    render::cat(&doc, theme, margin, plain, &mut io::stdout().lock())
}