Add terminal-aware rendering API (auto-disable ANSI when not writing to TTY)

[mike-5345]

Hello,

I am wondering if it is possible to add a way to render/write the table to a string the retains ANSI formatting and one that removes ANSI formatting.

Basically, I have some columns I want to colour differently based on the value, and some other ANSI styling - bold, italic etc. Maybe a display_term annotation? And a to_term_string on the Table?

Thanks for consideration!

[zhiburt]

Hi @mike-5345

If you could provide an example I would try to help better.
Please do.

But based on my understanding:

1. The simpliest solution to turn off all the ANSI is to use something like ansi_str::AnsiStr::ansi_strip.

use std::iter::FromIterator;

use ansi_str::AnsiStr;
use tabled::{settings::Color, Table};

fn main() {
    let mut table = Table::from_iter(['a'..='z']);
    table.with(Color::rgb_bg(100, 200, 40));

    let output = table.to_string();
    let output = output.ansi_strip();

    println!("{output}");
}

2. Or to remove colors based on how you set them.

About "auto-disable ANSI when not writing to TTY"

It is intentional that we don't have such function, at least if I picture your proposal correctly.
Because someone could want to rely on some particular lib to check for TTY, or a way to disable it being different.
There's many options here.

And it seems like oneliner right?
You could just do.

if your_lib::is_tty() == false {
    return table.to_string().ansi_strip();
} else {
    return table.to_string(); 
}

[zhiburt]

If your application performance concerned then you probably need to manually cleanup ANSI you configured using Table::with.

[mike-5345]

Thanks for the quick reply.

After looking at my requirements and your suggestion, I've decided to check TTY and then generate the tables to avoid the performance hit, only applying ANSI for terminal output. Creating a simple table for the log is pretty trivial, and I have to apply the styling for the terminal anyways so there is really no time lost.

Just as an aside if you are interested:
Currently, tabled provides an annotation display to supply your own function to display a field. Similarly, I think it would be helpful to also provide a style annotation that allows the user to supply a style function for a field so the style can be changed based on the value of the field. In this case, being able to generate the table string with and without ANSI would be important as the styling is baked into the table on creation. Below is an example of what it might look like (I'm not really sure what exactly the function should return).

pub enum MyEnum {
    Val1,
    Val2,
}

#[derive(Tabled)]
struct MyStruct {
    field1: String,
    field2: bool,

    // NEW PROPOSED ATTRIBUTE:
    // apply dynamic style to this column based on the cell's value
    #[tabled(style = "style_my_enum")]
    field3: MyEnum,
}

// return a style or nothing
fn style_my_enum(val: &MyEnum) -> Option<Settings> {
    match val {
        MyEnum::Val1 => Some(
            CellStyle::new()
                .fg(Color::Green)
                .bold(true)
        ),
        MyEnum::Val2 => Some(
            CellStyle::new()
                .fg(Color::Yellow)
                .bg(Color::DarkGrey)
        ),
    }
}

Either way, I appreciate your time, consideration, and help.

Mike

[zhiburt]

Interesting proposal, personally never was thinking about setting styles this way.

We could not do that with Tabled trait because it's solely responsible for data.
But we could do that with a different one which would be responsible for table.

Also could be doing this #158.
And choosing layout #472.
And this #65.
And many more :)

I was thinking about having ability to configure table in such way (there's an issue which I have not found).
But have not followed it...because I don't know why...just put it off a bit.
And as I said we certainly can't do it in 1 Tabled trait/derive.
So we need to came up with a beautiful solution :)

I will be thinking about it.

[zhiburt]

According to your example you could do something as following.

Create a enum to return from style_my_enum and implement CellOption for it.
Then use it.

*Enum is nessary because we can't Box<dyn CellOption> which is a pitty.........and very inconvenient.
*TODO

Yes .... lots of boilerplate.............

use tabled::{
    grid::{
        config::{ColoredConfig, Entity},
        records::vec_records::{Text, VecRecords},
    },
    settings::{CellOption, Color, Modify, Padding, Settings},
    Table, Tabled,
};

#[derive(Debug)]
pub enum MyEnum {
    Val1,
    Val2,
}

#[derive(Tabled)]
struct MyStruct {
    field1: String,
    field2: bool,
    #[tabled(display = "tabled::derive::display::debug")]
    field3: MyEnum,
}

impl MyStruct {
    fn new(field1: &str, field2: bool, field3: MyEnum) -> Self {
        Self {
            field1: field1.to_string(),
            field2,
            field3,
        }
    }
}

fn style_my_enum(val: &MyEnum) -> Option<MyEnumSettings> {
    match val {
        MyEnum::Val1 => Some(MyEnumSettings::Val1(
            Settings::empty().with(Color::BG_GREEN | Color::BOLD),
        )),
        MyEnum::Val2 => Some(MyEnumSettings::Val2(Settings::new(
            Color::BG_BRIGHT_CYAN | Color::FG_BRIGHT_RED,
            Padding::new(4, 4, 0, 0),
        ))),
    }
}

#[derive(Clone)]
enum MyEnumSettings {
    Val1(Settings<Settings, Color>),
    Val2(Settings<Color, Padding>),
}

impl CellOption<VecRecords<Text<String>>, ColoredConfig> for MyEnumSettings {
    fn change(
        self,
        records: &mut VecRecords<Text<String>>,
        cfg: &mut ColoredConfig,
        entity: Entity,
    ) {
        match self {
            MyEnumSettings::Val1(s) => s.change(records, cfg, entity),
            MyEnumSettings::Val2(s) => s.change(records, cfg, entity),
        }
    }
}

fn main() {
    let data = vec![
        MyStruct::new("Hello", false, MyEnum::Val1),
        MyStruct::new("Hello", false, MyEnum::Val2),
        MyStruct::new("World", true, MyEnum::Val1),
    ];

    let options = data
        .iter()
        .map(|v| &v.field3)
        .map(style_my_enum)
        .enumerate()
        .filter(|(_, style)| style.is_some())
        .map(|(row, style)| Modify::new((row + 1, 2)).with(style.unwrap()));

    let mut table = Table::new(&data);

    for opt in options {
        table.with(opt);
    }

    println!("{table}");
}