Comfy Table

https://docs.rs/comfy-table/latest/
Admin
Comfy Table is a Rust library for building beautiful, customizable terminal tables with dynamic...
Tokens:32,808
Snippets:339
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Run example via Cargo

Source: https://docs.rs/comfy-table/latest/comfy_table/index.html

Command to execute a specific example provided in the library's example folder.

```bash
cargo run --example readme_table
```

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

### Visualize ASCII_MARKDOWN style

Source: https://docs.rs/comfy-table/latest/comfy_table/presets/constant.ASCII_MARKDOWN.html

Example output showing the Markdown-like table structure.

```text
| Hello | there |
|-------|-------|
| a     | b     |
| c     | d     |
```

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

### UTF8_FULL Table Visualization

Source: https://docs.rs/comfy-table/latest/comfy_table/presets/constant.UTF8_FULL.html

An example of how a table appears when using the UTF8_FULL preset.

```text
┌───────┬───────┐
│ Hello ┆ there │
╞═══════╪═══════╡
│ a     ┆ b     │
├╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ c     ┆ d     │
└───────┴───────┘
```

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

### Example output of NOTHING preset

Source: https://docs.rs/comfy-table/latest/comfy_table/presets/constant.NOTHING.html

Visual representation of how data appears when the NOTHING preset is applied.

```text
 Hello  there
 a      b
 c      d
```

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

### Simulate post-split column width

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/arrangement/dynamic.rs.html

Example of how splitting content at delimiters can reduce the required column width.

```text
sometest
sometest
```

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

### Set Content Arrangement

Source: https://docs.rs/comfy-table/latest/comfy_table/enum.ContentArrangement.html

Example of applying a content arrangement strategy to a table instance.

```rust
use comfy_table::{ContentArrangement, Table};

let mut table = Table::new();
table.set_content_arrangement(ContentArrangement::Dynamic);
```

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

### width

Source: https://docs.rs/comfy-table/latest/src/comfy_table/table.rs.html

Gets the expected width of the table.

```APIDOC
## pub fn width(&self) -> Option<u16>

### Description
Returns the current width of the table if set or detected from the terminal.
```

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

### ASCII_BORDERS_ONLY_CONDENSED Visual Representation

Source: https://docs.rs/comfy-table/latest/comfy_table/presets/constant.ASCII_BORDERS_ONLY_CONDENSED.html

An example of how a table appears when using the condensed ASCII border preset.

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

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

### UTF8_NO_BORDERS Visual Representation

Source: https://docs.rs/comfy-table/latest/comfy_table/presets/constant.UTF8_NO_BORDERS.html

An example of how a table rendered with the UTF8_NO_BORDERS preset appears.

```text
 Hello ┆ there
═══════╪═══════
 a     ┆ b
╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌
 c     ┆ d
```

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

### style

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Get the character currently used for drawing a component.

```APIDOC
## pub fn style(&mut self, component: TableComponent) -> Option<char>

### Description
Get a copy of the character that is currently used for drawing this component.
```

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

### Modify Column Properties

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Column.html

Example showing how to retrieve a mutable reference to a column and apply constraints, padding, and alignment.

```rust
use comfy_table::{CellAlignment, ColumnConstraint::*, Table, Width::*};

let mut table = Table::new();
table.set_header(&vec!["one", "two"]);

let mut column = table.column_mut(1).expect("This should be column two");

// Set the max width for all cells of this column to 20 characters.
column.set_constraint(UpperBoundary(Fixed(20)));

// Set the left padding to 5 spaces and the right padding to 1 space
column.set_padding((5, 1));

// Align content in all cells of this column to the center of the cell.
column.set_cell_alignment(CellAlignment::Center);
```

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

### TableComponent Visual Representation

Source: https://docs.rs/comfy-table/latest/comfy_table/enum.TableComponent.html

A visual guide illustrating the difference between BorderIntersections and MiddleIntersections.

```text
       ---------
       v       |
+---+---+---+  |
| a | b | c |  |
+===+===+===+<-|
|   |   |   |  |
+---+---+---+<-- These "+" chars are Borderintersections.
|   |   |   |    The inner "+" chars are MiddleIntersections
+---+---+---+
```

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

### column

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Get a reference to a specific column.

```APIDOC
## pub fn column(&self, index: usize) -> Option<&Column>

### Description
Get a reference to a specific column by its index.
```

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

### Manage table presets

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Demonstrates loading a preset and verifying the current style configuration.

```rust
use comfy_table::{Table, presets::UTF8_FULL};

let mut table = Table::new();
table.load_preset(UTF8_FULL);

assert_eq!(UTF8_FULL, table.current_style_as_preset())
```

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

### column_mut

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Get a mutable reference to a specific column.

```APIDOC
## pub fn column_mut(&mut self, index: usize) -> Option<&mut Column>

### Description
Get a mutable reference to a specific column by its index.
```

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

### Create a basic table

Source: https://docs.rs/comfy-table/latest/comfy_table/index.html

Generates a simple table that expands to fit its content width.

```rust
use comfy_table::Table;

fn main() {
    let mut table = Table::new();
    table
        .set_header(vec!["Header1", "Header2", "Header3"])
        .add_row(vec![
            "This is a text",
            "This is another text",
            "This is the third text",
        ])
        .add_row(vec![
            "This is another text",
            "Now\nadd some\nmulti line stuff",
            "This is awesome",
        ]);

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

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

### Apply UTF8 styling and dynamic arrangement

Source: https://docs.rs/comfy-table/latest/comfy_table/index.html

Demonstrates using presets, modifiers, and dynamic width arrangement to format a table with specific cell alignments.

```rust
use comfy_table::modifiers::UTF8_ROUND_CORNERS;
use comfy_table::presets::UTF8_FULL;
use comfy_table::*;

fn main() {
    let mut table = Table::new();
    table
        .load_preset(UTF8_FULL)
        .apply_modifier(UTF8_ROUND_CORNERS)
        .set_content_arrangement(ContentArrangement::Dynamic)
        .set_width(40)
        .set_header(vec!["Header1", "Header2", "Header3"])
        .add_row(vec![
            Cell::new("Center aligned").set_alignment(CellAlignment::Center),
            Cell::new("This is another text"),
            Cell::new("This is the third text"),
        ])
        .add_row(vec![
            "This is another text",
            "Now\nadd some\nmulti line stuff",
            "This is awesome",
        ]);

    // Set the default alignment for the third column to right
    let column = table.column_mut(2).expect("Our table has three columns");
    column.set_cell_alignment(CellAlignment::Right);

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

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

### Get Row Count

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Retrieve the number of data rows currently in the table.

```rust
use comfy_table::Table;

let mut table = Table::new();
table.add_row(vec!["One", "Two"]);

assert_eq!(table.row_count(), 1);
```

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

### load_preset

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Loads a table style preset.

```APIDOC
## pub fn load_preset(&mut self, preset: &str) -> &mut Self

### Description
Creates a TableStyle from a given preset string found in `styling::presets::*`.
```

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

### Get Column Count

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Retrieve the number of columns currently present in the table.

```rust
use comfy_table::Table;

let mut table = Table::new();
table.set_header(vec!["Col 1", "Col 2", "Col 3"]);

assert_eq!(table.column_count(), 3);
```

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

### Library entry point and module exports

Source: https://docs.rs/comfy-table/latest/src/comfy_table/lib.rs.html

Defines the crate structure, enforces safety, and publicly exports core table components.

```rust
1#![forbid(unsafe_code)]
2#![doc = include_str!("../README.md")]
3// The README code examples should be valid mini scripts to make them properly testable.
4#![allow(clippy::needless_doctest_main)]
5// Had a few false-positives on v1.81. Check lateron if they're still there.
6#![allow(clippy::manual_unwrap_or)]
7
8mod cell;
9mod column;
10mod row;
11mod style;
12mod table;
13#[cfg(feature = "_integration_test")]
14/// We publicly expose the internal [utils] module for our integration tests.
15/// There's some logic we need from inside here.
16/// The API inside of this isn't considered stable and shouldnt' be used.
17pub mod utils;
18#[cfg(not(feature = "_integration_test"))]
19mod utils;
20
21pub use style::*;
22
23pub use crate::{
24    cell::{Cell, Cells},
25    column::Column,
26    row::Row,
27    table::{ColumnCellIter, Table},
28};
```

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

### Row::new

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Row.html

Creates a new, empty Row instance.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new empty row that can be populated with cells and added to a table.
```

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

### Apply advanced cell styling

Source: https://docs.rs/comfy-table/latest/comfy_table/index.html

Shows how to apply colors, background colors, and text attributes like bold or blink to individual cells.

```rust
use comfy_table::presets::UTF8_FULL;
use comfy_table::*;

fn main() {
    let mut table = Table::new();
    table.load_preset(UTF8_FULL)
        .set_content_arrangement(ContentArrangement::Dynamic)
        .set_width(80)
        .set_header(vec![
            Cell::new("Header1").add_attribute(Attribute::Bold),
            Cell::new("Header2").fg(Color::Green),
            Cell::new("Header3"),
        ])
        .add_row(vec![
             Cell::new("This is a bold text").add_attribute(Attribute::Bold),
             Cell::new("This is a green text").fg(Color::Green),
             Cell::new("This one has black background").bg(Color::Black),
        ])
        .add_row(vec![
            Cell::new("Blinky boi").add_attribute(Attribute::SlowBlink),
            Cell::new("This table's content is dynamically arranged. The table is exactly 80 characters wide.\nHere comes a reallylongwordthatshoulddynamicallywrap"),
            Cell::new("COMBINE ALL THE THINGS")
                .fg(Color::Green)
                .bg(Color::Black)
                .add_attributes(vec![
                    Attribute::Bold,
                    Attribute::SlowBlink,
                ])
        ]);

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

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

### Dynamic Table Arrangement Logic

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/arrangement/dynamic.rs.html

The 'arrange' function calculates column widths by iteratively applying constraints, handling lower boundaries, and distributing remaining space.

```rust
pub fn arrange(
    table: &Table,
    infos: &mut DisplayInfos,
    table_width: usize,
    max_content_widths: &[u16],
) {
    let visible_columns = count_visible_columns(&table.columns);

    // Step 1
    // Find out how much space there is left.
    let mut remaining_width: usize =
        available_content_width(table, infos, visible_columns, table_width);
    let mut remaining_columns = count_remaining_columns(visible_columns, infos);

    #[cfg(feature = "_debug")]
    println!(
        "dynamic::arrange: Table width: {table_width}, Start remaining width {remaining_width}"
    );
    #[cfg(feature = "_debug")]
    println!("dynamic::arrange: Max content widths: {max_content_widths:#?}");

    // Step 2.
    //
    // Iterate through all undecided columns and enforce LowerBoundary constraints, if they're
    // bigger than the current average space.
    if remaining_columns > 0 {
        (remaining_width, remaining_columns) = enforce_lower_boundary_constraints(
            table,
            infos,
            remaining_width,
            remaining_columns,
            visible_columns,
        );
    }

    // Step 3-5.
    // Find all columns that require less space than the average.
    // Returns the remaining available width and the amount of remaining columns that need handling
    let (mut remaining_width, mut remaining_columns) = find_columns_that_fit_into_average(
        table,
        infos,
        remaining_width,
        remaining_columns,
        visible_columns,
        max_content_widths,
    );

    #[cfg(feature = "_debug")]
    {
        println!("After less than average: {infos:#?}");
        println!("Remaining width {remaining_width}, column {remaining_columns}");
    }

    // Step 6
    // All remaining columns should get an equal amount of remaining space.
    // However, we check if we can save some space after the content has been split.
    //
    // We only do this if there are remaining columns.
    if remaining_columns > 0 {
        // This is where Step 5 happens.
        (remaining_width, remaining_columns) =
            optimize_space_after_split(table, infos, remaining_width, remaining_columns);
    }

    #[cfg(feature = "_debug")]
    {
        println!("dynamic::arrange: After optimize: {infos:#?}",);
        println!("dynamic::arrange: Remaining width {remaining_width}, column {remaining_columns}",);
    }

    // Early exit and one branch of Part 7.
    //
    // All columns have been successfully assigned a width.
    // However, in case the user specified that the full terminal width should always be fully
    // utilized, we have to equally distribute the remaining space across all columns.
    if remaining_columns == 0 {
        if remaining_width > 0 && matches!(table.arrangement, ContentArrangement::DynamicFullWidth)
        {
            use_full_width(infos, remaining_width);
            #[cfg(feature = "_debug")]
            println!("dynamic::arrange: After full width: {infos:#?}");
        }
        return;
    }

    // Step 7. Equally distribute the remaining_width to all remaining columns
```

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

### Draw table borders and rows

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/formatting/borders.rs.html

Main entry point for generating the string representation of table borders and content rows.

```rust
1use crate::{style::TableComponent, table::Table, utils::ColumnDisplayInfo};

pub(crate) fn draw_borders(
    table: &Table,
    rows: &[Vec<Vec<String>>],
    display_info: &[ColumnDisplayInfo],
) -> Vec<String> {
    // We know how many lines there should be. Initialize the vector with the rough correct amount.
    // We might over allocate a bit, but that's better than under allocating.
    let mut lines = if let Some(capacity) = rows.first().map(|lines| lines.len()) {
        // Lines * 2 -> Lines + delimiters
        // + 5 -> header delimiters + header + bottom/top borders
        Vec::with_capacity(capacity * 2 + 5)
    } else {
        Vec::new()
    };

    if should_draw_top_border(table) {
        lines.push(draw_top_border(table, display_info));
    }

    draw_rows(&mut lines, rows, table, display_info);

    if should_draw_bottom_border(table) {
        lines.push(draw_bottom_border(table, display_info));
    }

    lines
}
```

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

### Get Table Component Style

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Retrieve the character currently assigned to a specific table component.

```rust
use comfy_table::{Table, TableComponent::*};

let mut table = Table::new();
assert_eq!(table.style(TopLeftCorner), Some('+'));
```

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

### Cell API

Source: https://docs.rs/comfy-table/latest/src/comfy_table/cell.rs.html

Methods for creating and configuring a Cell instance.

```APIDOC
## Cell::new<T: ToString>(content: T) -> Self

### Description
Creates a new Cell from any type that implements the ToString trait. The content is automatically split by newlines.

## Cell::new_owned(content: String) -> Self

### Description
Creates a new Cell from an owned String, splitting the content by newlines.

## Cell::content(&self) -> String

### Description
Returns the full content of the cell as a single String, joining split lines with newlines.

## Cell::set_delimiter(mut self, delimiter: char) -> Self

### Description
Sets the delimiter used to split text for this cell, which helps the table understand word boundaries.

## Cell::set_alignment(mut self, alignment: CellAlignment) -> Self

### Description
Sets the alignment of the content for this specific cell, overriding any column-level alignment settings.

## Cell::fg(mut self, color: Color) -> Self

### Description
Sets the foreground text color for this cell (requires 'tty' feature).

## Cell::bg(mut self, color: Color) -> Self

### Description
Sets the background color for this cell (requires 'tty' feature).

## Cell::add_attribute(mut self, attribute: Attribute) -> Self

### Description
Adds a single styling attribute (e.g., Bold, Italic) to the cell content (requires 'tty' feature).

## Cell::add_attributes(mut self, mut attribute: Vec<Attribute>) -> Self

### Description
Adds a vector of styling attributes to the cell content (requires 'tty' feature).
```

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

### Arrange table content

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/arrangement/mod.rs.html

Calculates column display information based on table constraints and arrangement settings.

```rust
pub fn arrange_content(table: &Table) -> Vec<ColumnDisplayInfo> {
    let table_width = table.width().map(usize::from);
    let mut infos = BTreeMap::new();

    let max_content_widths = table.column_max_content_widths();

    // Check if we can already resolve some constraints.
    // This step also populates the ColumnDisplayInfo structs.
    let visible_columns = helper::count_visible_columns(&table.columns);
    for column in table.columns.iter() {
        if column.constraint.is_some() {
            constraint::evaluate(
                table,
                visible_columns,
                &mut infos,
                column,
                max_content_widths[column.index],
            );
        }
    }
    #[cfg(feature = "_debug")]
    println!("After initial constraints: {infos:#?}");

    // Fallback to `ContentArrangement::Disabled`, if we don't have any information
    // on how wide the table should be.
    let table_width = if let Some(table_width) = table_width {
        table_width
    } else {
        disabled::arrange(table, &mut infos, visible_columns, &max_content_widths);
        return infos.into_values().collect();
    };

    match &table.arrangement {
        ContentArrangement::Disabled => {
            disabled::arrange(table, &mut infos, visible_columns, &max_content_widths)
        }
        ContentArrangement::Dynamic | ContentArrangement::DynamicFullWidth => {
            dynamic::arrange(table, &mut infos, table_width, &max_content_widths);
        }
    }

    infos.into_values().collect()
}
```

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

### Iterate Over Column Cells Including Header

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Access cells within a specific column, starting with the header cell.

```rust
use comfy_table::Table;
let mut table = Table::new();
table.set_header(&vec!["A", "B"]);
table.add_row(&vec!["First", "Second"]);
table.add_row(&vec!["Third"]);
table.add_row(&vec!["Fourth", "Fifth"]);

// Create an iterator over the second column
let mut cell_iter = table.column_cells_with_header_iter(1);
assert_eq!(cell_iter.next().unwrap().unwrap().content(), "B");
assert_eq!(cell_iter.next().unwrap().unwrap().content(), "Second");
assert!(cell_iter.next().unwrap().is_none());
assert_eq!(cell_iter.next().unwrap().unwrap().content(), "Fifth");
assert!(cell_iter.next().is_none());
```

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

### Convert types to Cell

Source: https://docs.rs/comfy-table/latest/src/comfy_table/cell.rs.html

Demonstrates creating a Cell from various types using the From trait.

```rust
use comfy_table::Cell;
let cell: Cell = "content".into();
let cell: Cell = 5u32.into();
```

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

### Measure text width and split strings

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/formatting/content_split/normal.rs.html

Utilities for calculating the display width of strings and splitting them by delimiters or character width limits.

```rust
use unicode_segmentation::UnicodeSegmentation;
use unicode_width::UnicodeWidthStr;

/// returns printed length of string
/// if ansi feature enabled, takes into account escape codes
#[inline(always)]
pub fn measure_text_width(s: &str) -> usize {
    s.width()
}

/// Split a line into its individual parts along the given delimiter.
pub fn split_line_by_delimiter(line: &str, delimiter: char) -> Vec<String> {
    line.split(delimiter)
        .map(ToString::to_string)
        .collect::<Vec<String>>()
}

/// Splits a long word at a given character width.
/// This needs some special logic, as we have to take multi-character UTF-8 symbols into account.
/// When simply splitting at a certain char position, we might end up with a string that's has a
/// wider display width than allowed.
pub fn split_long_word(allowed_width: usize, word: &str) -> (String, String) {
    let mut current_width = 0;
    let mut parts = String::new();

    let mut graphmes = word.graphemes(true).peekable();

    // Check if the string might be too long, one Unicode grapheme at a time.
    // Peek into the next grapheme and check the exit condition.
    //
    // This code uses graphemes to handle both zero-width joiner[0] UTF-8 chars, which
    // combine multiple UTF-8 chars into a single grapheme, and variant selectors [1],
    // which pick a certain variant of the preceding char.
    //
    // [0]: https://en.wikipedia.org/wiki/Zero-width_joiner
    // [1]: https://en.wikipedia.org/wiki/Variation_Selectors_(Unicode_block)
    while let Some(c) = graphmes.peek() {
        if (current_width + c.width()) > allowed_width {
            break;
        }

        // We can unwrap, as we just checked that a suitable grapheme is next in line.
        let c = graphmes.next().unwrap();

        let character_width = c.width();
        current_width += character_width;
        parts.push_str(c);
    }

    // Collect the remaining characters.
    let remaining = graphmes.collect();
    (parts, remaining)
}
```

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

### Evaluate Column Constraints

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/arrangement/constraint.rs.html

Evaluates column constraints to determine display information, such as fixed widths or hidden status, at the start of table arrangement.

```rust
pub fn evaluate(
    table: &Table,
    visible_columns: usize,
    infos: &mut DisplayInfos,
    column: &Column,
    max_content_width: u16,
) {
    match &column.constraint {
        Some(ContentWidth) => {
            let info = ColumnDisplayInfo::new(column, max_content_width);
            infos.insert(column.index, info);
        }
        Some(Absolute(width)) => {
            if let Some(width) = absolute_value_from_width(table, width, visible_columns) {
                // The column should get always get a fixed width.
                let width = absolute_width_with_padding(column, width);
                let info = ColumnDisplayInfo::new(column, width);
                infos.insert(column.index, info);
            }
        }
        Some(Hidden) => {
            let mut info = ColumnDisplayInfo::new(column, max_content_width);
            info.is_hidden = true;
            infos.insert(column.index, info);
        }
        _ => {}
    }

    if let Some(min_width) = min(table, &column.constraint, visible_columns) {
        // In case a min_width is specified, we may already fix the size of the column.
        // We do this, if we know that the content is smaller than the min size.
        let max_width = max_content_width + column.padding_width();
        if max_width <= min_width {
            let width = absolute_width_with_padding(column, min_width);
            let info = ColumnDisplayInfo::new(column, width);
            infos.insert(column.index, info);
        }
    }
}
```

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

### Enforce MaxWidth constraints for column sizing

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/arrangement/dynamic.rs.html

Logic for fixing column widths based on MaxWidth constraints when columns exceed or fall below the average available space.

```rust
if usize::from(max_width) <= average_space_with_padding
                    && width_with_padding >= max_width
                {
                    // Save the calculated info, this column has been handled.
                    let width = absolute_width_with_padding(column, max_width);
                    let info = ColumnDisplayInfo::new(column, width);
                    infos.insert(column.index, info);

                    #[cfg(feature = "_debug")]
                    println!(
                        "dynamic::find_columns_that_fit_into_average: Fixed column {} via MaxWidth constraint with size {}, as it's bigger than average {}",
                        column.index, width, average_space
                    );

                    // Continue with new recalculated width
                    remaining_width = remaining_width.saturating_sub(width.into());
                    remaining_columns -= 1;

                    if remaining_columns == 0 {
                        break;
                    }

                    average_space = remaining_width / remaining_columns;
                    found_smaller = true;
                    continue;
                }
            }

            // The column has a smaller or equal max_content_width than the average space.
            // Fix the width to max_content_width and mark it as checked
            if usize::from(max_column_width) <= average_space {
                let info = ColumnDisplayInfo::new(column, max_column_width);
                infos.insert(column.index, info);

                #[cfg(feature = "_debug")]
                println!(
                    "dynamic::find_columns_that_fit_into_average: Fixed column {} with size {}, as it's smaller than average {}",
                    column.index, max_column_width, average_space
                );

                // Continue with new recalculated width
                remaining_width = remaining_width.saturating_sub(max_column_width.into());
                remaining_columns -= 1;
                if remaining_columns == 0 {
                    break;
                }

                average_space = remaining_width / remaining_columns;
                found_smaller = true;
            }
        }
    }

    (remaining_width, remaining_columns)
}
```

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

### current_style_as_preset

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Exports the current style as a preset string.

```APIDOC
## pub fn current_style_as_preset(&mut self) -> String

### Description
Returns the current table style as a preset string.
```

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

### Style Terminal Line

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/formatting/content_format.rs.html

Applies foreground color, background color, and text attributes to a line if the TTY feature is enabled.

```rust
#[cfg(feature = "tty")]
fn style_line(line: String, cell: &Cell) -> String {
    // Just return the line, if there's no need to style.
    if cell.fg.is_none() && cell.bg.is_none() && cell.attributes.is_empty() {
        return line;
    }

    let mut content = style(line);

    // Apply text color
    if let Some(color) = cell.fg {
        content = content.with(map_color(color));
    }

    // Apply background color
    if let Some(color) = cell.bg {
        content = content.on(map_color(color));
    }

    for attribute in cell.attributes.iter() {
        content = content.attribute(map_attribute(*attribute));
    }

    content.to_string()
}
```

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

### Test column generation and width calculation

Source: https://docs.rs/comfy-table/latest/src/comfy_table/table.rs.html

Unit test verifying that adding rows automatically generates columns and updates maximum content widths.

```rust
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_column_generation() {
        let mut table = Table::new();
        table.set_header(vec!["thr", "four", "fivef"]);

        // When adding a new row, columns are automatically generated
        assert_eq!(table.columns.len(), 3);
        // The max content width is also correctly set for each column
        assert_eq!(table.column_max_content_widths(), vec![3, 4, 5]);

        // When adding a new row, the max content width is updated accordingly
        table.add_row(vec!["four", "fivef", "very long text with 23"]);
        assert_eq!(table.column_max_content_widths(), vec![4, 5, 22]);

        // Now add a row that has column lines. The max content width shouldn't change
        table.add_row(vec!["", "", "shorter"]);
        assert_eq!(table.column_max_content_widths(), vec![4, 5, 22]);

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

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

### Column Configuration Methods

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Column.html

Methods available on the Column struct to modify column behavior and appearance.

```APIDOC
## pub fn set_padding(&mut self, padding: (u16, u16)) -> &mut Self

### Description
Sets the padding for all cells of this column. Padding is provided as a tuple of (left, right). The default is (1, 1).

## pub fn set_delimiter(&mut self, delimiter: char) -> &mut Self

### Description
Sets the delimiter used to split text for this column's cells. This helps the library identify words for wrapping.

## pub fn set_constraint(&mut self, constraint: ColumnConstraint) -> &mut Self

### Description
Sets a constraint to influence the auto-adjustment behavior of the column.

## pub fn set_cell_alignment(&mut self, alignment: CellAlignment)

### Description
Sets the default alignment for content inside all cells of this column. Note that individual cell alignment settings will override this column-level setting.
```

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

### current_style_as_preset

Source: https://docs.rs/comfy-table/latest/src/comfy_table/table.rs.html

Retrieves the current table style configuration as a preset string.

```APIDOC
## fn current_style_as_preset(&mut self) -> String

### Description
Returns a string representation of the current table style, allowing for easy export or reuse of the current configuration.
```

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

### content_arrangement

Source: https://docs.rs/comfy-table/latest/src/comfy_table/table.rs.html

Retrieves the current content arrangement.

```APIDOC
## pub fn content_arrangement(&self) -> ContentArrangement

### Description
Returns the current ContentArrangement setting of the table.
```

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

### Test Column Functionality

Source: https://docs.rs/comfy-table/latest/src/comfy_table/column.rs.html

Unit test verifying the creation of a column and the management of its constraints.

```rust
#[test]
fn test_column() {
    let mut column = Column::new(0);
    column.set_padding((0, 0));

    column.set_constraint(ColumnConstraint::ContentWidth);
    assert_eq!(column.constraint(), Some(&ColumnConstraint::ContentWidth));

    column.remove_constraint();
    assert_eq!(column.constraint(), None);
}
```

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

### Find Columns Fitting Average Width

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/arrangement/dynamic.rs.html

Iteratively identifies columns that fit within the average remaining space and fixes their widths accordingly.

```rust
fn find_columns_that_fit_into_average(
    table: &Table,
    infos: &mut DisplayInfos,
    mut remaining_width: usize,
    mut remaining_columns: usize,
    visible_columns: usize,
    max_content_widths: &[u16],
) -> (usize, usize) {
    let mut found_smaller = true;
    while found_smaller {
        found_smaller = false;

        // There are no columns left to check. Proceed to the next step
        if remaining_columns == 0 {
            break;
        }

        let mut average_space = remaining_width / remaining_columns;
        // We have no space left, the terminal is either tiny or the other columns are huge.
        if average_space == 0 {
            break;
        }

        for column in table.columns.iter() {
            // Ignore hidden columns
            // We already checked this column, skip it
            if infos.contains_key(&column.index) {
                continue;
            }

            let max_column_width = max_content_widths[column.index];

            // The column has a MaxWidth Constraint.
            // we can fix the column to this max_width and mark it as checked if these
            // two conditions are met:
            // - The average remaining space is bigger then the MaxWidth constraint.
            // - The actual max content of the column is bigger than the MaxWidth constraint.
            if let Some(max_width) = constraint::max(table, &column.constraint, visible_columns) {
                // Max/Min constraints always include padding!
                let average_space_with_padding =
                    average_space + usize::from(column.padding_width());

                let width_with_padding = max_column_width + column.padding_width();
```

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

### Iterate and Configure Columns

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Use a mutable iterator to apply column constraints to all columns in the table.

```rust
use comfy_table::{ColumnConstraint::*, Table, Width::*};

let mut table = Table::new();
table.add_row(&vec!["First", "Second", "Third"]);

// Add a ColumnConstraint to each column (left->right)
// first -> min width of 10
// second -> max width of 8
// third -> fixed width of 10
let constraints = vec![
    LowerBoundary(Fixed(10)),
    UpperBoundary(Fixed(8)),
    Absolute(Fixed(10)),
];

// Add the constraints to their respective column
for (column_index, column) in table.column_iter_mut().enumerate() {
    let constraint = constraints.get(column_index).unwrap();
    column.set_constraint(*constraint);
}
```

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

### Cell::new

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Cell.html

Creates a new Cell instance from any type that implements ToString.

```APIDOC
## pub fn new<T: ToString>(content: T) -> Self

### Description
Create a new Cell from the provided content.

### Parameters
- **content** (T: ToString) - Required - The content to be placed in the cell.
```

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

### Define UTF-8 Table Styles

Source: https://docs.rs/comfy-table/latest/src/comfy_table/style/presets.rs.html

Constants representing various UTF-8 box-drawing table border configurations.

```rust
pub const UTF8_FULL: &str = "││──╞═╪╡┆╌┼├┤┬┴┌┐└┘";
```

```rust
pub const UTF8_FULL_CONDENSED: &str = "││──╞═╪╡┆    ┬┴┌┐└┘";
```

```rust
pub const UTF8_NO_BORDERS: &str = "     ═╪ ┆╌┼        ";
```

```rust
pub const UTF8_BORDERS_ONLY: &str = "││──╞══╡     ──┌┐└┘";
```

```rust
pub const UTF8_HORIZONTAL_ONLY: &str = "  ── ══  ──  ──    ";
```

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

### Define Column Constraints and Widths

Source: https://docs.rs/comfy-table/latest/src/comfy_table/style/column.rs.html

Enums for specifying column visibility, content-based width, and absolute or boundary-based constraints.

```rust
/// A Constraint can be added to a [columns](crate::Column).
///
/// They allow some control over Column widths as well as the dynamic arrangement process.
///
/// All percental boundaries will be ignored, if:
/// - you aren't using one of ContentArrangement::{Dynamic, DynamicFullWidth}
/// - the width of the table/terminal cannot be determined.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ColumnConstraint {
    /// This will completely hide a column.
    Hidden,
    /// Force the column to be as long as it's content.
    /// Use with caution! This can easily mess up your table formatting,
    /// if a column's content is overly long.
    ContentWidth,
    /// Enforce a absolute width for a column.
    Absolute(Width),
    /// Specify a lower boundary, either fixed or as percentage of the total width.
    /// A column with this constraint will be at least as wide as specified.
    /// If the content isn't as long as that boundary, it will be padded.
    /// If the column has longer content and is allowed to grow, the column may take more space.
    LowerBoundary(Width),
    /// Specify a upper boundary, either fixed or as percentage of the total width.
    /// A column with this constraint will be at most as wide as specified.
    /// The column may be smaller than that width.
    UpperBoundary(Width),
    /// Specify both, an upper and a lower boundary.
    Boundaries { lower: Width, upper: Width },
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Width {
    /// A fixed amount of characters.
    Fixed(u16),
    /// A width equivalent to a certain percentage of the available width.
    /// Values above 100 will be automatically reduced to 100.
    ///
    /// **Warning:** This option will be ignored if:
    /// - you aren't using one of ContentArrangement::{Dynamic, DynamicFullWidth}
    /// - the width of the table/terminal cannot be determined.
    Percentage(u16),
}
```

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

### Style Module Configuration

Source: https://docs.rs/comfy-table/latest/src/comfy_table/style/mod.rs.html

The module structure for comfy_table styling, including conditional compilation for TTY features and re-exports.

```rust
1#[cfg(all(feature = "tty", not(feature = "reexport_crossterm")))]
2mod attribute;
3mod cell;
4#[cfg(all(feature = "tty", not(feature = "reexport_crossterm")))]
5mod color;
6mod column;
7/// Contains modifiers, that can be used to alter certain parts of a preset.\
8/// For instance, the [UTF8_ROUND_CORNERS](modifiers::UTF8_ROUND_CORNERS) replaces all corners with
9/// round UTF8 box corners.
10pub mod modifiers;
11/// This module provides styling presets for tables.\
12/// Every preset has an example preview.
13pub mod presets;
14mod table;
15
16pub use cell::CellAlignment;
17pub use column::{ColumnConstraint, Width};
18#[cfg(feature = "tty")]
19pub use styling_enums::{Attribute, Color};
20#[cfg(feature = "tty")]
21pub(crate) use styling_enums::{map_attribute, map_color};
22pub use table::{ContentArrangement, TableComponent};
23
24/// Convenience module to have cleaner and "identical" conditional re-exports for style enums.
25#[cfg(all(feature = "tty", not(feature = "reexport_crossterm")))]
26mod styling_enums {
27    pub use super::{attribute::*, color::*};
28}
29
30/// Re-export the crossterm type directly instead of using the internal mirrored types.
31/// This result in possible ABI incompatibilities when using comfy_table and crossterm in the same
32/// project with different versions, but may also be very convenient for developers.
33#[cfg(all(feature = "tty", feature = "reexport_crossterm"))]
34mod styling_enums {
35    /// Attributes used for styling cell content. Reexport of crossterm's
36    /// [Attributes](crossterm::style::Attribute) enum.
37    pub use crossterm::style::Attribute;
38    /// Colors used for styling cell content. Reexport of crossterm's
39    /// [Color](crossterm::style::Color) enum.
40    pub use crossterm::style::Color;
41
42    /// Convenience function to have the same mapping code for reexported types.
43    #[inline]
44    pub(crate) fn map_attribute(attribute: Attribute) -> Attribute {
45        attribute
46    }
47
48    /// Convenience function to have the same mapping code for reexported types.
49    #[inline]
50    pub(crate) fn map_color(color: Color) -> Color {
51        color
52    }
53}
```

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

### Define ASCII Table Styles

Source: https://docs.rs/comfy-table/latest/src/comfy_table/style/presets.rs.html

Constants representing various ASCII-based table border configurations.

```rust
pub const ASCII_FULL: &str = "||--+==+|-+||++++++";
```

```rust
pub const ASCII_FULL_CONDENSED: &str = "||--+==+|    ++++++";
```

```rust
pub const ASCII_NO_BORDERS: &str = "     == |-+        ";
```

```rust
pub const ASCII_BORDERS_ONLY: &str = "||--+==+   ||--++++";
```

```rust
pub const ASCII_BORDERS_ONLY_CONDENSED: &str = "||--+==+     --++++";
```

```rust
pub const ASCII_HORIZONTAL_ONLY: &str = "  -- ==  --  --    ";
```

```rust
pub const ASCII_MARKDOWN: &str = "||  |-|||           ";
```

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

### enforce_styling

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Enforces terminal styling even if TTY is disabled.

```APIDOC
## pub fn enforce_styling(&mut self) -> &mut Self

### Description
Enforces terminal styling. This is useful if TTY was forcefully disabled but terminal styles are still desired.
```

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

### Define NOTHING constant

Source: https://docs.rs/comfy-table/latest/comfy_table/presets/constant.NOTHING.html

The constant is defined as a string of spaces to ensure no borders are rendered.

```rust
pub const NOTHING: &str = "                   ";
```

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

### should_style

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Checks if the table content should be styled.

```APIDOC
## pub fn should_style(&self) -> bool

### Description
Returns whether the content of this table should be styled based on current settings and environment.
```

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

### Handle terminal size via ioctl

Source: https://docs.rs/comfy-table/latest/comfy_table/index.html

This snippet demonstrates the internal usage of ioctl for terminal size detection when the tty feature is enabled.

```rust
...
if wrap_with_result(unsafe { ioctl(fd, TIOCGWINSZ.into(), &mut size) }).is_ok() {
    Ok((size.ws_col, size.ws_row))
} else {
    tput_size().ok_or_else(|| std::io::Error::last_os_error().into())
}
...
```

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

### Split line utility implementation

Source: https://docs.rs/comfy-table/latest/src/comfy_table/utils/formatting/content_split/mod.rs.html

The split_line function processes a string into a vector of lines based on column display information and a delimiter.

```rust
use crate::utils::ColumnDisplayInfo;

#[cfg(feature = "custom_styling")]
mod custom_styling;
#[cfg(not(feature = "custom_styling"))]
mod normal;

#[cfg(feature = "custom_styling")]
pub use custom_styling::*;
#[cfg(not(feature = "custom_styling"))]
pub use normal::*;

/// Split a line if it's longer than the allowed columns (width - padding).
///
/// This function tries to do this in a smart way, by splitting the content
/// with a given delimiter at the very beginning.
/// These "elements" then get added one-by-one to the lines, until a line is full.
/// As soon as the line is full, we add it to the result set and start a new line.
///
/// This is repeated until there are no more "elements".
///
/// Mid-element splits only occurs if an element doesn't fit in a single line by itself.
pub fn split_line(line: &str, info: &ColumnDisplayInfo, delimiter: char) -> Vec<String> {
    let mut lines = Vec::new();
    let content_width = usize::from(info.content_width);

    // Split the line by the given deliminator and turn the content into a stack.
    // Also clone it and convert it into a Vec<String>. Otherwise, we get some burrowing problems
    // due to early drops of borrowed values that need to be inserted into `Vec<&str>`
    let mut elements = split_line_by_delimiter(line, delimiter);

    // Reverse it, since we want to push/pop without reversing the text.
    elements.reverse();

    let mut current_line = String::new();
    while let Some(next) = elements.pop() {
        let current_length = measure_text_width(&current_line);
        let next_length = measure_text_width(&next);

        // Some helper variables
        // The length of the current line when combining it with the next element
        // Add 1 for the delimiter if we are on a non-empty line.
        let mut added_length = next_length + current_length;
        if !current_line.is_empty() {
            added_length += 1;
        }
        // The remaining width for this column. If we are on a non-empty line, subtract 1 for the
        // delimiter.
        let mut remaining_width = content_width - current_length;
        if !current_line.is_empty() {
            remaining_width = remaining_width.saturating_sub(1);
        }

        // The next element fits into the current line
        if added_length <= content_width {
            // Only add delimiter, if we're not on a fresh line
            if !current_line.is_empty() {
                current_line.push(delimiter);
            }
            current_line += &next;

            // Already complete the current line, if there isn't space for more than two chars
            current_line = check_if_full(&mut lines, content_width, current_line);
            continue;
        }

        // The next element doesn't fit in the current line

        // Check, if there's enough space in the current line in case we decide to split the
        // element and only append a part of it to the current line.
        // If there isn't enough space, we simply push the current line, put the element back
        // on stack and start with a fresh line.
        if !current_line.is_empty() && remaining_width <= MIN_FREE_CHARS {
            elements.push(next);
            lines.push(current_line);
            current_line = String::new();

            continue;
        }

        // Ok. There's still enough space to fit something in (more than MIN_FREE_CHARS characters)
        // There are two scenarios:
        //
        // 1. The word is too long for a single line. In this case, we have to split the element
        //    anyway. Let's fill the remaining space on the current line with, start a new line and
        //    push the remaining part on the stack.
        // 2. The word is short enough to fit as a whole into a line In that case we simply push the
        //    current line and start a new one with the current element

        // Case 1
        // The element is longer than the specified content_width
        // Split the word, push the remaining string back on the stack
        if next_length > content_width {
            let new_line = current_line.is_empty();

            // Only add delimiter, if we're not on a fresh line
            if !new_line {
                current_line.push(delimiter);
            }

            let (mut next, mut remaining) = split_long_word(remaining_width, &next);

            // This is an ugly hack, but it's needed for now.
            //
            // Scenario: The current column has to have a width of 1, and we work with a new line.
```

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

### Converting Iterables to Cells

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Cells.html

Demonstrates how to convert vectors of strings or integers into a Cells object using the From trait.

```rust
use comfy_table::{Cells, Row};

let cells_string: Cells = vec!["One", "Two", "Three"].into();
let cells_integer: Cells = vec![1, 2, 3, 4].into();
```

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

### Create a row from various types

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Row.html

Use the From trait to initialize a Row from vectors of strings, cells, or other compatible types.

```rust
use comfy_table::{Cell, Row};

let row = Row::from(vec!["One", "Two", "Three"]);
let row = Row::from(vec![Cell::new("One"), Cell::new("Two"), Cell::new("Three")]);
let row = Row::from(vec![1, 2, 3, 4]);
```

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

### Set Background Color

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Cell.html

Applies a background color to the cell.

```rust
use comfy_table::{Cell, Color};

let mut cell = Cell::new("Some content").bg(Color::Red);
```

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

### Define ASCII_MARKDOWN constant

Source: https://docs.rs/comfy-table/latest/comfy_table/presets/constant.ASCII_MARKDOWN.html

The constant definition for the Markdown-style table preset.

```rust
pub const ASCII_MARKDOWN: &str = "||  |-|||           ";
```

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

### Set column constraints

Source: https://docs.rs/comfy-table/latest/comfy_table/struct.Table.html

Applies constraints to columns. Must be called after adding at least one row or header to ensure columns are initialized.

```rust
 use comfy_table::{CellAlignment, ColumnConstraint::_, ContentArrangement, Table, Width::_};
let mut table = Table::new(); table .add_row(&vec![“one”, “two”, “three”]) .set_content_arrangement(ContentArrangement::Dynamic) .set_constraints(vec![UpperBoundary(Fixed(15)), LowerBoundary(Fixed(20))]);
```
Tokens:
Raw