Documents: Org, AsciiDoc and man pages¶

cargo run -p rs-rich-ext --example guide_documents

fn show_org(console: &Console) {
    console.print(&DocumentView::org(ORG));
}

fn show_asciidoc(console: &Console) {
    // Without hyperlinks a link's target is written out, as `rich` does
    // unless `-y` asks for terminal hyperlinks.
    console.print(&DocumentView::asciidoc(ASCIIDOC).hyperlinks(false));
}

fn show_man(console: &Console) {
    console.print(&DocumentView::man(MAN));
}

fn show_detect(console: &Console) {
    let registry = DocumentRegistry::with_builtins();
    let mut table = Table::new();
    for header in ["Path", "Content", "Format", "Confidence", "By"] {
        table.add_column(header);
    }
    for (path, content) in [
        (Some("notes.org"), ""),
        (Some("ls.1"), MAN),
        (Some("syslog.1"), "Jan 1 boot ok\n"),
        (Some("gen.c"), MAN),
        (Some("GREET"), MAN),
        (None, ORG),
    ] {
        let detected = registry.detect(path, content, CERTAIN);
        let (format, confidence, by) = match &detected {
            Some(found) => (
                found.format.clone(),
                format!("{:.2}", found.confidence),
                format!("{:?}", found.by),
            ),
            None => ("—".into(), "".into(), "".into()),
        };
        let shown = content.lines().next().unwrap_or("");
        table.add_row_text(vec![
            Text::new(path.unwrap_or("<stdin>")),
            Text::new(shown.chars().take(18).collect::<String>()),
            Text::new(format),
            Text::new(confidence),
            Text::new(by),
        ]);
    }
    console.print(&table);
}

fn show_registry(console: &Console) {
    let registry = DocumentRegistry::with_builtins();
    // Options apply to every format: links, code theme, the language of
    // unlabelled code, and fence renderers (Mermaid, DOT) for code blocks.
    let options = RenderOptions::new()
        .hyperlinks(false)
        .default_language("bash");
    let source = ".TH DEMO 1\n.SH EXAMPLE\n.EX\nrich ls.1 | less -R\n.EE\n.so other.1\n";
    let rendered = registry
        .render(source, "man", &options)
        .expect("a built-in");
    console.print(rendered.renderable.as_ref());
    for diagnostic in &rendered.diagnostics {
        if diagnostic.severity == Severity::Warning {
            console.print(&Text::styled(format!("warning: {diagnostic}"), "yellow"));
        }
    }
}

fn show_model(console: &Console) {
    // Any producer can build the shared model and draw it the same way.
    let document = Document {
        blocks: vec![
            Block::Paragraph(vec![
                Inline::text("Built by hand: "),
                Inline::Strong(vec![Inline::text("strong")]),
                Inline::text(", "),
                Inline::Code("code".into()),
                Inline::text(" and "),
                Inline::Link {
                    target: "https://example.com".into(),
                    content: vec![Inline::text("a link")],
                },
                Inline::text("."),
            ]),
            Block::Rule,
        ],
    };
    console.print(&DocumentView::new(document).hyperlinks(false));
}

/// A format of your own: `.todo` files, one task per line.
struct TodoFormat;

impl DocumentFormat for TodoFormat {
    fn id(&self) -> &str {
        "todo"
    }

    fn name(&self) -> &str {
        "Task list"
    }

    fn extensions(&self) -> Vec<String> {
        vec!["todo".into()]
    }

    fn parse(&self, source: &str) -> Option<rich_ext::document::Parsed> {
        use rich_ext::document::model::{Checkbox, List, ListItem, ListKind};
        let items = source
            .lines()
            .filter(|line| !line.trim().is_empty())
            .map(|line| {
                let (done, text) = match line.strip_prefix("x ") {
                    Some(text) => (true, text),
                    None => (false, line),
                };
                ListItem {
                    checkbox: Some(if done {
                        Checkbox::Checked
                    } else {
                        Checkbox::Unchecked
                    }),
                    number: None,
                    blocks: vec![Block::Paragraph(vec![Inline::text(text)])],
                }
            })
            .collect();
        let list = Block::List(List {
            kind: ListKind::Bullet,
            items,
        });
        Some(rich_ext::document::Parsed {
            document: Document { blocks: vec![list] },
            diagnostics: Vec::new(),
        })
    }
}

fn show_custom(console: &Console) {
    let mut registry = DocumentRegistry::with_builtins();
    registry.register(Arc::new(TodoFormat)).expect("a new name");
    let found = registry
        .detect(Some("week.todo"), "", CERTAIN)
        .expect("by extension");
    let rendered = registry
        .render(
            "x Ship 0.0.19\nWrite the release notes\n",
            &found.format,
            &RenderOptions::new(),
        )
        .expect("registered");
    console.print(rendered.renderable.as_ref());
}