Struct Markdown 

pub struct Markdown { /* private fields */ }

A rendered Markdown document. Mirrors rich.markdown.Markdown.

Implementations

impl Markdown

pub fn markup(&self) -> &str

The Markdown source this was parsed from (upstream Markdown.markup). Not upstream as a method; it changes nothing.

use rich::markdown::Markdown;

assert_eq!(Markdown::new("# Title\n").markup(), "# Title\n");

pub fn new(source: &str) -> Self

Parse CommonMark source into renderable blocks.

Hyperlinks are on, matching rich.markdown.Markdown(hyperlinks=True). The CLI wants them off — see hyperlinks.

pub fn hyperlinks(self, hyperlinks: bool) -> Self

Choose how a [text](url) is rendered. Port of rich.markdown.Markdown(hyperlinks=…), default true.

• true — the text becomes an OSC 8 hyperlink pointing at the URL.
• false — the URL is written out after the text, as text (https://example.com).

The distinction is not cosmetic. An OSC 8 escape is only emitted when the console has a colour system, so with hyperlinks on a piped or NO_COLOR render drops every destination with nothing left to recover it from. That is why upstream’s rich-cli passes hyperlinks=False by default and puts the OSC 8 form behind its opt-in -y/--hyperlinks flag; a CLI built on this crate should do the same:

let opt_in = false; // set by `-y/--hyperlinks`
let md = Markdown::new("A [link](https://example.com).").hyperlinks(opt_in);

pub fn justify(self, justify: Justify) -> Self

Justify every paragraph. Port of Markdown(justify=…); by default paragraphs are left-justified. Headings keep their own alignment.

pub fn style(self, style: Style) -> Self

The root style every run of text is drawn in. Port of Markdown(style=…), default "none".

pub fn code_theme(self, theme: impl Into<String>) -> Self

The theme for code blocks. Port of Markdown(code_theme=…). Names are the highlighter’s own: with the default, syntect theme names plus upstream’s ansi_dark and ansi_light (see DIVERGENCES #18).

pub fn inline_code_lexer(self, lexer: impl Into<String>) -> Self

Highlight inline code as lexer. Port of Markdown(inline_code_lexer=…); by default inline code is not highlighted.

pub fn inline_code_theme(self, theme: impl Into<String>) -> Self

The theme for highlighted inline code. Port of Markdown(inline_code_theme=…), defaulting to the code theme.

pub fn highlighter(self, highlighter: Arc<dyn CodeHighlighter>) -> Self

Highlight code blocks, and inline code when an inline_code_lexer is set, with highlighter instead of the console’s default or the built-in engine (syntect with the syntax feature; without it, code blocks are plain unless a highlighter is given here or on the console, see Syntax). Theme names are then the highlighter’s own.

pub fn fence_renderer(self, renderer: Arc<dyn FenceRenderer>) -> Self

Let renderer draw fenced code blocks instead of highlighting them, for the languages it accepts (see FenceRenderer). Renderers are asked in the order they were added. Not in upstream, which always highlights; with none added, output is unchanged.

Trait Implementations

impl Renderable for Markdown

fn rich_render( &self, console: &Console, options: &ConsoleOptions, ) -> Vec<Segment>

fn measure(&self, _console: &Console, options: &ConsoleOptions) -> Measurement

The (minimum, maximum) cell width this renderable wants. Port of __rich_measure__. The default is what upstream’s Measurement.get returns for a renderable without one: anything from nothing to the whole width, (0, max_width).

fn fit_to_measurement(&self) -> bool

Whether a top-level Console::print shrinks this renderable to its measured width. Upstream renders every top-level renderable at the full console width, so the default is false; an extension may opt in.

fn vertical(&self) -> Option<VerticalAlign>

The vertical alignment a Table cell holding this renderable uses in place of its column’s. Upstream reads getattr(renderable, "vertical", None); Align sets it.

fn print_end_line(&self, _options: &ConsoleOptions) -> bool

Whether a top-level print ends this renderable’s last line. This port’s renderables separate lines, where upstream’s end each line with "\n", so a print adds the final line break. A renderable whose upstream output stops without one (Screen, LiveRender, a Rule whose end has no newline) returns false, and the next output continues its last line. options are the print’s options.