We've tried updating comfytable in polars from 0.5.1 to 0.6.1 and only had to adapt a few method names, so that was great.

However the table formatting changed. This made all our doctests fail. Given that it is a huge undertaking to update all of them, I wonder if we can get the old formatting behavior.

An example of what we had:

    shape: (3, 3)
    ┌─────┬─────┬───────────┐
    │ a   ┆ b   ┆ b_squared │
    │ --- ┆ --- ┆ ---       │
    │ i64 ┆ i64 ┆ f64       │
    ╞═════╪═════╪═══════════╡
    │ 1   ┆ 2   ┆ 4.0       │
    ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┤
    │ 3   ┆ 4   ┆ 16.0      │
    ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┤
    │ 5   ┆ 6   ┆ 36.0      │
    └─────┴─────┴───────────┘

-----------------------------

And what we got after updating:

    shape: (3, 3)
    ┌─────┬─────┬─────────┐
    │ a   ┆ b   ┆ b_squar │
    │ --- ┆ --- ┆ ed      │
    │ i64 ┆ i64 ┆ ---     │
    │     ┆     ┆ f64     │
    ╞═════╪═════╪═════════╡
    │ 1   ┆ 2   ┆ 4.0     │
    ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
    │ 3   ┆ 4   ┆ 16.0    │
    ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
    │ 5   ┆ 6   ┆ 36.0    │
    └─────┴─────┴─────────┘

Any ideas?

I wanted to use comfy-table with cells that contain ANSI escape characters, generated with the colored crate. However, when calculating the width of a cell, the ANSI escape characters were counted as well, resulting in funny looking tables.

By using textwrap's function to calculate the display width of a String, the tables have the correct cells and display correctly.

Hi, I'm experimenting with this library and I have a question. I have a vector containing custom structs, where each struct field should be a table column. I'm trying to figure out how to produce this table efficiently. Right now I'm basically doing this:

    let mut table = Table::new();
    table.load_preset(UTF8_FULL)
        .set_content_arrangement(ContentArrangement::Dynamic)
        .set_header(vec![
            Cell::new("a"),
            Cell::new("b"),
            Cell::new("c"),
            Cell::new("d"),
            Cell::new("e"),
            Cell::new("f"),
            Cell::new("g"),
        ]);

    // let things: Vec<Thing> = get_things(...);
    for d in things.iter() {
        table.add_row(vec![
            Cell::new(&d.a),
            Cell::new(&d.b),
            Cell::new(&d.c),
            Cell::new(&d.d),
            Cell::new(&d.e),
            Cell::new(&d.f),
            Cell::new(&d.g),
        ]);
    }

This works, and produces the correct output, but it seems a little slow with ~670 structs in the vector. It gets a bit faster if I turn off dynamic layout, but without that feature the table is sized incorrectly so I think I need it to be enabled.

1. Is there a more efficient way to load a vector of structs instead of iter + add_row? For example, I think the tabled crate can accept that data structure directly (maybe it's doing iter + add_row internally though I don't know)
2. Is there a way to size the table to the terminal width without dynamic content arrangement (if that's actually the right choice regardless?)
3. Do you have any other recommendations for this situation?

https://github.com/datafuselabs/datafuse/pull/1323

preset: table.load_preset("||--+-++| ++++++");

Cell::new(format!("{}", "✅ ".blue())); // error, missing spaces for padding. `.blue()` comes from `colored`

Cell::new(format!("{}", "✅ "));  // error, it looks like there is an extra blank character 

Cell::new(format!("{}", "☑")); or Cell::new("☑").fg(Color::Green); // ok, `CellAlignment::Center`, but i want ✅

There are now a few libraries for pretty-printing tables to the console. It would be really helpful to have a bit of a comparison to allow users (including myself!) to determine which one to go for.

• tabled
• prettytable-rs (possibly unmaintained)
• cli-table
• term-table-rs
• comfy-table
• etc...

I am wondering if it is possible to get the width of a column? I have a table like this:

table
    .load_preset(UTF8_FULL)
    .apply_modifier(UTF8_ROUND_CORNERS)
    .set_content_arrangement(ContentArrangement::Dynamic);
table.add_row(vec![Cell::new("Hello"), Cell::new("How do you do")]);

And i would like to get the width of the second column of this table.

I dont know if my particular usecase is weird or not:

• A shell function wraps the invocation of a rust program, like so

  foo() {
        eval "$(bar "$@")"
  }
  

• but the rust program bar, outputs tables produced by this library to stderr. So I'd like to be able to still make use of the auto-detection of the terminal width / table width.

Looking at the implementation, you pivot is_tty purely based off the stdout's tty. But I can, in fact use crossterm::terminal::size() directly, and send the width of that into table.set_table_width, and all appears to work just fine from there, because the output is all going to stderr.

(Although i'm not a unix expert, but I almost think stderr would be a better default anyways to output these kinds of tables that are intended for human consumption)

It's not obvious to me what the least disruptive way to enable this would be, but it'd be handy if either the default behavior could

• only take heed of the not_tty's value before calling size() and don't bother checking is_tty (assuming size() returns Err when it couldn't i.e. neither were tty)
• either fall back to stderr tty when stdout is false
• allow me to call a method to set when tty ought to be true (the current api only lets one force disable it, not force enable it).

Obviously, feel free to correct me if any of this is blatantly wrong!

Using presets::ASCII_BORDERS_ONLY, whose sample table is:

+---------------+
| Hello   there |
+===============+
| a       b     |
| c       d     |
+---------------+

I'm instead getting an empty middle row between each actual row:

+-------------------------------+
| timestamp   one   two   three |
+===============================+
| 2001000     12    15    19    |
|                               |
| 2001001     22    25    29    |
|                               |
| 2001002     32    35    39    |
+-------------------------------+

This is with v4.0.1. Is this a bug? Or some row padding section I'm not seeing?

Thanks!

I think I must be missing something, but I can't figure out how to prevent the contents of cells from wrapping.

Here's my code:

    let mut table = comfy_table::Table::new();
    table.set_table_width(100);

    table.set_header(&["", "redb", "lmdb", "sled"]);

    for (benchmark, _duration) in &redb_results {
        table.add_row(&[benchmark]);
    }

    for results in [redb_results, lmdb_results, sled_results] {
        for (i, (_benchmark, duration)) in results.iter().enumerate() {
            table
                .get_row_mut(i)
                .unwrap()
                .add_cell(comfy_table::Cell::new(format!(
                    "{}ms",
                    duration.as_millis()
                )));
        }
    }

    println!("{table}");

And here's the table it prints:

+--------------------+------+------+------+
|                    | redb | lmdb | sled |
+=========================================+
| bulk load          | 4136 | 1235 | 1428 |
|                    | ms   | ms   | 2ms  |
|--------------------+------+------+------|
| individual writes  | 50ms | 10ms | 3547 |
|                    |      |      | ms   |
|--------------------+------+------+------|
| batch writes       | 5495 | 3010 | 1126 |
|                    | ms   | ms   | 8ms  |
|--------------------+------+------+------|
| random reads       | 1106 | 1108 | 1703 |
|                    | ms   | ms   | ms   |
|--------------------+------+------+------|
| random reads       | 926m | 1104 | 1518 |
|                    | s    | ms   | ms   |
|--------------------+------+------+------|
| random reads       | 993m | 1219 | 1495 |
|                    | s    | ms   | ms   |
|--------------------+------+------+------|
| random range reads | 1137 | 1481 | 2264 |
|                    | ms   | ms   | ms   |
|--------------------+------+------+------|
| random range reads | 1144 | 1461 | 2317 |
|                    | ms   | ms   | ms   |
|--------------------+------+------+------|
| random range reads | 1154 | 1422 | 2169 |
|                    | ms   | ms   | ms   |
|--------------------+------+------+------|
| removals           | 2677 | 1004 | 2824 |
|                    | ms   | ms   | ms   |
+--------------------+------+------+------+

I'd like the table to be wider to avoid wrapping the content of any of the cells. Is there a way to do this?

The following code:

let mut table = Table::new();
table.load_preset(comfy_table::presets::NOTHING);
table.set_header(vec![
    "A heading".bold(),
    "Column 1".bold(),
    "A slightly longer heading".bold(),
]);
for i in 0..5 {
    let row: Vec<_> = (0..3).map(|j| format!("Row {} col {}", i, j)).collect();
    table.add_row(row);
}

produces a table with misaligned headings.

If I coerce each row into a Vec<StyledContent<String>> by calling .reset() on the Strings:

let mut table = Table::new();
table.load_preset(comfy_table::presets::NOTHING);
table.set_header(vec![
    "A heading".bold(),
    "Column 1".bold(),
    "A slightly longer heading".bold(),
]);
for i in 0..5 {
    let row: Vec<_> = (0..3)
        .map(|j| format!("Row {} col {}", i, j).reset()) // Change.
        .collect();
    table.add_row(row);
}

the problem goes away.

Is there any easy way that I can use bat (library) to render output of the table? This would greatly improve the aesthetic of the output and may even make the library way more ergonomic.

Describe the bug

Column alignment breaks if printed text has formatting control codes.

Expected behavior

Text in a column contains parts formated with color/style using console crate. Alignment of later columns should be correct.

Code

use comfy_table::{Table, Row, Cell};
use console::Style;

fn main() {
    let mut table = Table::new();
    table.load_preset(comfy_table::presets::NOTHING);
    
    let mut row = Row::new();
    row.add_cell(Cell::new(
        "cell1"
    ));
    row.add_cell(Cell::new(
        "cell2"
    ));

    table.add_row(row);

    let mut row = Row::new();
    row.add_cell(Cell::new(
        format!("cell{}", console::style("3").bold().red())
    ));
    row.add_cell(Cell::new(
        "cell4"
    ));
    table.add_row(row);

    println!("{}", table);   
}

Additional context

• Operating System: nixos linux
• comfy-table version: 6.1.0

I'm honestly impressed by comfy-table, and it handled a multiline string like a champ. What I would like to ask is for the ability to set vertical alignment (perhaps through a new enum and method, perhaps through adding new values to CellAlignment).

For example, in the table from this screenshot below, I would like the single line text in the header to be in the lower line, so that unit, status and state transition are all in the same line.

This is a follow-up issue to #44.

By default, if there's not enough space and dynamic mode is active, comfy-table falls back to a column with minimum-width of 1. However, if there are multi-column characters in the text, the format will break as the character doesn't fit into the line.

Example:

╭───╮
│   │
├╌╌╌┤
│ ⺀ │
╰───╯

This is a super rare edge-case and this will need quite a bit of special logic to be properly handled. This includes iterating through all characters of a column.

I'm not sure if it's worth doing it. However, it's probably better to do so, even if it's just for the sake of consistency and correctness.

This behavior will also show up if the user enforces a width of 1 for a column, but this is something we won't handle!