Struct RatatuiTextGenerator 

pub struct RatatuiTextGenerator<P = NoopCustomTagParser<Style>> { /* private fields */ }

Available on crate feature ratatui only.

Generator for ratatui crate’s Text type.

See docs/ratatui-tags.ebnf for supported tags.

Example

use tui_markup::{compile, generator::RatatuiTextGenerator};

assert_eq!(
    compile::<RatatuiTextGenerator>("I have a <green green text>"),
    Ok(Text::from(vec![Line::from(vec![
        Span::raw("I have a "),
        Span::styled("green text", Style::default().fg(Color::Green)),
    ])])),
);

assert_eq!(
    compile::<RatatuiTextGenerator>("I can set <bg:blue background>"),
    Ok(Text::from(vec![Line::from(vec![
        Span::raw("I can set "),
        Span::styled("background", Style::default().bg(Color::Blue)),
    ])])),
);

assert_eq!(
    compile::<RatatuiTextGenerator>("I can add <b bold>, <d dim>, <i italic> modifiers"),
    Ok(Text::from(vec![Line::from(vec![
        Span::raw("I can add "),
        Span::styled("bold", Style::default().add_modifier(Modifier::BOLD)),
        Span::raw(", "),
        Span::styled("dim", Style::default().add_modifier(Modifier::DIM)),
        Span::raw(", "),
        Span::styled("italic", Style::default().add_modifier(Modifier::ITALIC)),
        Span::raw(" modifiers"),
    ])])),
);

assert_eq!(
    compile::<RatatuiTextGenerator>("I can <bg:blue combine <green them <b <i all>>>>"),
    Ok(Text::from(vec![Line::from(vec![
        Span::raw("I can "),
        Span::styled("combine ", Style::default().bg(Color::Blue)),
        Span::styled("them ", Style::default().bg(Color::Blue).fg(Color::Green)),
        Span::styled(
            "all",
            Style::default()
                .bg(Color::Blue)
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD | Modifier::ITALIC)
        ),
    ])])),
);

assert_eq!(
    compile::<RatatuiTextGenerator>("I can use <bg:66ccff custom color>"),
    Ok(Text::from(vec![Line::from(vec![
        Span::raw("I can use "),
        Span::styled(
            "custom color",
            Style::default().bg(Color::Rgb(0x66, 0xcc, 0xff))
        ),
    ])])),
);

assert_eq!(
    compile::<RatatuiTextGenerator>("I can set <bg:blue,green,b,i many style> in one tag"),
    Ok(Text::from(vec![Line::from(vec![
        Span::raw("I can set "),
        Span::styled(
            "many style",
            Style::default()
                .bg(Color::Blue)
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD | Modifier::ITALIC)
        ),
        Span::raw(" in one tag"),
    ])])),
);

With custom tags

use tui_markup::{compile_with, generator::RatatuiTextGenerator};

let g = RatatuiTextGenerator::new(|tag: &str| match tag {
    "keyboard" => Some(
        Style::default()
            .bg(Color::White)
            .fg(Color::Green)
            .add_modifier(Modifier::BOLD),
    ),
    _ => None,
});

assert_eq!(
    compile_with("Press <keyboard W> to move up", g),
    Ok(Text::from(vec![Line::from(vec![
        Span::raw("Press "),
        Span::styled(
            "W",
            Style::default()
                .bg(Color::White)
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD)
        ),
        Span::raw(" to move up"),
    ])])),
);

Show output

Use any widget of the ratatui crate that supports it’s Text type, for example: ratatui::widgets::Paragraph.

Note that the Paragraph widget includes a ratatui::widgets::Paragraph::wrap option that defaults to trimming leading whitespace. You need to turn this option off if you require full control over the output.

Implementations

impl<P> RatatuiTextGenerator<P>

pub fn new(p: P) -> Self

Create a new generator, with a custom tag parser.

Trait Implementations

impl<P: Debug> Debug for RatatuiTextGenerator<P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P> Default for RatatuiTextGenerator<P>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, P> Generator<'a> for RatatuiTextGenerator<P>

where P: CustomTagParser<Output = Style>,

type Convertor = RatatuiTagConvertor<P>

Tag convertor type.

type Err = GeneratorInfallible

Error type.

type Output = Text<'a>

Output type.

fn convertor(&mut self) -> &mut Self::Convertor

Get the tag convertor.

fn generate( &mut self, markup: Vec<Vec<ItemG<'a, Self>>>, ) -> Result<Self::Output, Self::Err>

Generates final output from IR, which is output result of the Convertor.