Tabled

https://github.com/zhiburt/tabled
Admin
Tabled is an easy-to-use Rust library for pretty printing tables from structs and enums with...
Tokens:37,821
Snippets:316
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Tabled Formatting Settings Examples

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Demonstrates different formatting settings for tables, including alignment and indentation of content within borders.

```text
╭───────────────────╮
│       &str        │
├───────────────────┤
│                   │
│ [                 │
│     "foo",        │
│     {             │
│         "bar": 1, │
│         "baz": [  │
│             2,    │
│             3     │
│         ]         │
│     }             │
│ ]                 │
╰───────────────────╯
```

```text
╭───────────────────╮
│       &str        │
├───────────────────┤
│                   │
│         [         │
│        "foo",     │
│           {       │
│         "bar": 1, │
│         "baz": [  │
│              2,   │
│               3   │
│             ]     │
│           }       │
│         ]         │
╰───────────────────╯
```

```text
╭───────────────────╮
│       &str        │
├───────────────────┤
│     [             │
│     "foo",        │
│     {             │
│     "bar": 1,     │
│     "baz": [      │
│     2,            │
│     3             │
│     ]             │
│     }             │
│     ]             │
│                   │
╰───────────────────╯
```

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

### Table Width Adjustment Example 2

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Another example demonstrating table width adjustments, showing how content wraps or truncates within defined column boundaries.

```text
.----------------------------------------.
| usize | &str                           |
| 0     | # Changelog                    |
| 1     | All notable changes to this    |
|       | projectwill be documented in   |
|       | thisfile.                      |
| 2     | The format is based on [Keep a |
|       | Changelog](https://keepachange |
|       | log.com/en/1.0.0/),            |
| 3     | and this project adheres to    |
|       | [SemanticVersioning](https://s |
|       | emver.org/spec/v2.0.0.html).   |
| 4     | ## Unreleased                  |
'-------+--------------------------------'
```

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

### Display Tabular Data

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

This example shows how to display data in a formatted table. It's useful for presenting structured information clearly.

```text
+----------------------+-----------------+
|        name          | first_release   |
+----------------------+-----------------+
| Sublime Text 3       | 2008            |
+----------------------+-----------------+
| Visual Studio Code   | 2015            |
+----------------------+-----------------+
| Notepad++            | 2003            |
+----------------------+-----------------+
| GNU Emacs            | 1984            |
+----------------------+-----------------+
| Neovim               | 2015            |
+----------------------+-----------------+

```

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

### Split String into Table

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

This example demonstrates splitting a string into a table format. It's useful for visualizing string data in a structured way.

```text
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐                       
│ a │ b │ c │ d │ e │ f │ g │ h │ i │ j │ k │ l │ m │ n │ o │ p │ q │ r │ s │ t │ u │ v │ w │ x │ y │ z │                       
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘                       
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ ┌───┬───┐ ┌───┬───┐ ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ 
│ a │ b │ c │ d │ e │ f │ g │ h │ i │ j │ k │ l │ │ a │ b │ │ a │ b │ │ a │ y │ b │ z │ c │ d │ e │ f │ g │ h │ i │ j │ k │ l │ 
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤ ├───┼───┤ ├───┼───┤ ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤ 
│ m │ n │ o │ p │ q │ r │ s │ t │ u │ v │ w │ x │ │ c │ d │ │ m │ n │ │ m │   │ n │   │ o │ p │ q │ r │ s │ t │ u │ v │ w │ x │ 
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤ ├───┼───┤ ├───┼───┤ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ 
│ y │ z │   │   │   │   │   │   │   │   │   │   │ │ e │ f │ │ y │ z │ ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ 
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ ├───┼───┤ ├───┼───┤ │ a │ b │ c │ d │ e │ f │ g │ h │ i │ j │ k │ l │ y │ z │ 
                                                  ├───┼───┤ ├───┼───┤ ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤ 
                                                  │ i │ j │ │ o │ p │ │ m │ n │ o │ p │ q │ r │ s │ t │ u │ v │ w │ x │   │   │ 
                                                  ├───┼───┤ ├───┼───┤ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ 
                                                  │ k │ l │ │ e │ f │                                                           
                                                  ├───┼───┤ ├───┼───┤                                                           
                                                  │ m │ n │ │ q │ r │                                                           
                                                  ├───┼───┤ ├───┼───┤                                                           
                                                  │ o │ p │ │ g │ h │                                                           
                                                  ├───┼───┤ ├───┼───┤                                                           
                                                  │ q │ r │ │ s │ t │                                                           
                                                  ├───┼───┤ ├───┼───┤                                                           
                                                  │ s │ t │ │ i │ j │                                                           
                                                  ├───┼───┤ ├───┼───┤                                                           
                                                  │ u │ v │ │ u │ v │                                                           
                                                  ├───┼───┤ ├───┼───┤                                                           
                                                  │ w │ x │ │ k │ l │                                                           
                                                  ├───┼───┤ ├───┼───┤                                                           
                                                  │ y │ z │ │ w │ x │                                                           
                                                  └───┴───┘ └───┴───┘                     

```

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

### Example Table Output

Source: https://github.com/zhiburt/tabled/blob/master/json_to_table/README.md

Demonstrates the visual output of a formatted table. This shows how data is rendered with headers and rows, including nested elements.

```text
+----------------------------------------------------+
| +------+---------------+-------------+-----------+ |
| | age  | name          | referred-by | role      | |
| +------+---------------+-------------+-----------+ |
| |  23  |  Aleix Melon  |  E0012      | +-------+ | |
| |      |               |             | |  Dev  | | |
| |      |               |             | +-------+ | |
| |      |               |             | |  DBA  | | |
| |      |               |             | +-------+ | |
| +------+---------------+-------------+-----------+ |
+----------------------------------------------------+
| +------+---------------+-------------+-----------+ |
| | age  | name          | referred-by | role      | |
| +------+---------------+-------------+-----------+ |
| |  24  |  Aleix Melon  |  E0012      | +-------+ | |
| |      |               |             | |  DBA  | | |
| |      |               |             | +-------+ | |
| +------+---------------+-------------+-----------+ |
+----------------------------------------------------+
```

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

### Example of static_table usage

Source: https://github.com/zhiburt/tabled/blob/master/static_table/README.md

Demonstrates how to use the static_table! macro to create a standard adjusted table at compile time. The resulting table is stored as a string.

```rust
use static_table::static_table;

static LANG_LIST: &str = static_table!([
    ["name", "designed by", "first release"],
    ["C", "Dennis Ritchie", "1972"],
    ["Go", "Rob Pike", "2009"],
    ["Rust", "Graydon Hoare", "2010"],
    ["Hare", "Drew DeVault", "2022"],
]);

fn main() {
    println!("{LANG_LIST}")
}
```

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

### Compact Table Layout 2

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Another example of a compact table, demonstrating how data is presented with minimal spacing between columns.

```text
 Debian  | 1.1.1.1   | true 
---------+-----------+------
 Arch    | 127.1.1.1 | true 
 Manjaro | Arch      | true 
```

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

### Builder Table Output

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Shows a table constructed with the builder, presenting information about the ocean. This example highlights the flexibility in content and structure.

```text
| https://en.wikipedia.org/wiki/Ocean |
|---------------+---------------------|
| The terms "the ocean" or "the sea"  |
| used without specification refer to |
|  the interconnected body of salt wa |
| covering the majority of the Ea |
| rth's surface                       |
| =================================== |
| #             | Ocean               |
| 0             | Atlantic            |
| 1             | Pacific             |
| 2             | Indian              |
| 3             | Southern            |
| 4             | Arctic              |
```

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

### PoolTable Example in Rust

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Illustrates the usage of PoolTable for creating tables with diverse and non-aligned column layouts. This is useful when standard table structures are not suitable.

```rust
use tabled::{
    settings::{Alignment, Style},
    tables::PoolTable,
};

let characters = [
    "Naruto Uzumaki",
    "Kakashi Hatake",
    "Minato Namikaze",
    "Jiraiya",
    "Orochimaru",
    "Itachi Uchiha",
];

let data = characters.chunks(2);

let table = PoolTable::new(data)
    .with(Style::dots())
    .with(Alignment::center())
    .to_string();

println!("{table}");

```

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

### Example of pool_table usage

Source: https://github.com/zhiburt/tabled/blob/master/static_table/README.md

Demonstrates how to use the pool_table! macro to create a non-adjusted, floating table at compile time. The resulting table is stored as a string.

```rust
use static_table::pool_table;

static LANG_LIST: &str = pool_table!([
    ["name", "designed by", "first release"],
    ["C", "Dennis Ritchie", "1972"],
    ["Go", "Rob Pike", "2009"],
    ["Rust", "Graydon Hoare", "2010"],
    ["Hare", "Drew DeVault", "2022"],
]);

fn main() {
    println!("{LANG_LIST}")
}
```

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

### Merge Duplicates Table Example

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Demonstrates how the tabled crate can merge duplicate rows, consolidating information for a cleaner presentation. Uses default styling.

```text
┌────────────┬─────────┬────────┐
│ db         │ table   │ total  │
├────────────┼─────────┼────────┤
│ database_1 │ table_1 │ 10712  │
│            ├─────────┼────────┤
│            │ table_2 │ 57     │
│            ├─────────┤        │
│            │ table_3 │        │
├────────────┼─────────┼────────┤
│ database_2 │ table_1 │ 72     │
│            ├─────────┼────────┤
│            │ table_2 │ 75     │
├────────────┼─────────┼────────┤
│ database_3 │ table_1 │ 20     │
│            ├─────────┼────────┤
│            │ table_2 │ 21339  │
│            ├─────────┼────────┤
│            │ table_3 │ 141723 │
└────────────┴─────────┴────────┘
```

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

### IterTable Example in Rust

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Demonstrates how to use IterTable for memory-efficient table generation when data doesn't fit in memory. It buffers only one row at a time and uses a limited number of passes for layout estimation.

```rust
use std::borrow::Cow;
use tabled::{settings::Style, tables::IterTable};
    
struct Language<'a> {
    name: &'a str,
    designed_by: &'a str,
    year: usize,
}
    
let languages = vec![
    Language { name: "C", designed_by: "Dennis Ritchie", year: 1972 },
    Language { name: "Go", designed_by: "Rob Pike", year: 2009 },
    Language { name: "Rust", designed_by: "Graydon Hoare", year: 2010 },
];

let iter = languages.iter().rev().map(|l| {
    [
        Cow::Borrowed(l.name),
        Cow::Borrowed(l.designed_by),
        Cow::Owned(l.year.to_string()),
    ]
});

let head = [
    Cow::Borrowed("lang"),
    Cow::Borrowed("inventor"),
    Cow::Borrowed("published year"),
];
let iter = std::iter::once(head).chain(iter);

let table = IterTable::new(iter)
    .sniff(2)
    .with(Style::modern().remove_horizontal());
    
let output = table.to_string();
    
println!("{output}");

```

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

### CompactTable Example in Rust

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Shows how to use CompactTable for environments with strict memory constraints, as it avoids buffering and requires manual width estimation. This table type supports `no-std`.

```rust
use std::borrow::Cow;
use tabled::settings::Style;
use tabled::tables::CompactTable;
    
struct Language<'a> {
    name: &'a str,
    designed_by: &'a str,
    year: usize,
}
    
let languages = vec![
    Language { name: "C", designed_by: "Dennis Ritchie", year: 1972 },
    Language { name: "Go", designed_by: "Rob Pike", year: 2009 },
    Language { name: "Rust", designed_by: "Graydon Hoare", year: 2010 },
];

let iter = languages.iter().rev().map(|l| {
    [
        Cow::Borrowed(l.name),
        Cow::Borrowed(l.designed_by),
        Cow::Owned(l.year.to_string()),
    ]
});

let head = [
    Cow::Borrowed("lang"),
    Cow::Borrowed("inventor"),
    Cow::Borrowed("published year"),
];
let iter = std::iter::once(head).chain(iter);

let table = CompactTable::new(iter)
    .rows(languages.len())
    .columns(3)
    .width([10, 20, 20])
    .with(Style::modern().remove_horizontal());

let output = table.to_string();
    
println!("{output}");

```

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

### Runtime-Configurable Table Styling with Theme

Source: https://context7.com/zhiburt/tabled/llms.txt

Use `Theme` to dynamically modify table styles at runtime. Start from an existing preset using `Theme::from_style` and then customize borders.

```rust
use tabled::{Table, settings::{Style, themes::Theme}};
use tabled::grid::config::{Border, HorizontalLine};

let data = [["C", "Dennis Ritchie", "1972"], ["Rust", "Graydon Hoare", "2010"]];

let mut theme = Theme::from_style(Style::ascii_rounded());
theme.remove_borders_horizontal();
theme.remove_borders_vertical();

let table = Table::new(data).with(theme).to_string();

println!("{table}");
// .-------------------------------
// | C    Dennis Ritchie   1972    |
// | Rust Graydon Hoare    2010    |
// '-------------------------------'
```

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

### Format Table with std::fmt options

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Apply standard Rust formatting options to a table for custom output. This example uses center alignment within a specified width.

```rust
use tabled::Table;

let numbers = [(1, 2, 3), (1, 2, 3)];
let table = Table::new(numbers);

println!("{{:.^30}}", table);
```

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

### Using static_table macro in documentation

Source: https://github.com/zhiburt/tabled/blob/master/static_table/README.md

Illustrates how to embed a table generated by the static_table! macro directly within Rust documentation comments. This is useful for generating example outputs.

```rust
/// Add joins 2 integers together to get a sum.
/// 
/// ```
#[doc = static_table::static_table!([
    ["a", "b", "result"],
    ["1", '2', '3'],
    ["2", '2', '4']
])]
/// ```
pub fn add(left: usize, right: usize) -> usize {
    left + right
}
```

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

### Construct a table at compile time

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Use the `static_table!` macro to define a table structure and content that is generated during compilation. This example demonstrates basic data and theme application.

```rust
const TABLE: &str = static_table::static_table!(
    [
        ["x", "y", "op", "result"],
        ["1", '2', '*', '2'],
        ["2", '2', '*', '4']
    ],
    THEME = "ROUNDED",
);

assert_eq!(
    TABLE,
    "╭───┬───┬────┬────────╮\n\     │ x │ y │ op │ result │\n\     ├───┼───┼────┼────────┤\n\     │ 1 │ 2 │ *  │ 2      │\n\     │ 2 │ 2 │ *  │ 4      │\n\     ╰───┴───┴────┴────────╯",
);
```

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

### Table Height Adjustments

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Demonstrates controlling table height by adding or removing rows, including examples for increasing, decreasing, and setting height to zero.

```text
Table

| &str        | i32 |
|-------------|-----|
| Multi       | 123 |
| line        |     |
| string      |     |
| Single line | 234 |

Table increase height to 10

| &str        | i32 |
|             |     |
|             |     |
|-------------|-----|
| Multi       | 123 |
| line        |     |
| string      |     |
|             |     |
| Single line | 234 |
|             |     |

Table decrease height to 4

| &str        | i32 |
|-------------|-----|
| Multi       | 123 |
| Single line | 234 |
Table decrease height to 0

|--|--|
```

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

### Table Width Adjustments

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Illustrates how table content is adjusted to fit different width constraints. The examples show progressive narrowing of the table display.

```text
| 0                | 1         |
|------------------|-----------|
| Hello World!!!   | 3.3.22.2  |
| Guten Morgen     | 1.1.1.1   |
| Добры вечар      | 127.0.0.1 |
| Bonjour le monde |           |
| Ciao mondo       |           |

| 0          | 1   |
|------------|-----|
| Hello W... | ... |
| Guten M... | ... |
| Добры в... | ... |
| Bonjour... |     |
| Ciao mondo |     |

| 0     | 1   |
|-------|-----|
| Hello | ... |
|  W... |     |
| Guten | ... |
|  M... |     |
| Добры | ... |
|  в... |     |
| Bonjo |     |
| ur... |     |
| Ciao  |     |
| mondo |     |

| 0             | 1          |
|---------------|------------|
| Hello         | ...        |
|  W...         |            |
| Guten         | ...        |
|  M...         |            |
| Добры         | ...        |
|  в...         |            |
| Bonjo         |            |
| ur...         |            |
| Ciao          |            |
| mondo         |            |
```

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

### Apply Colors to Table Columns

Source: https://github.com/zhiburt/tabled/blob/master/README.md

After enabling the `ansi` feature, you can use color libraries to style table columns. This example applies different foreground colors to specific columns.

```rust
use tabled::{format::Format, object::Columns, Style, Table};

let mut table = Table::new(&data);
table
    .with(Style::psql())
    .modify(Columns::one(0), Color::FG_RED)
    .modify(Columns::one(1), Color::FG_BLUE)
    .modify(Columns::new(2..), Color::FG_GREEN);
```

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

### JSON to Table with Custom Orientation

Source: https://github.com/zhiburt/tabled/blob/master/json_to_table/README.md

Demonstrates how to control the table's orientation for arrays and objects using the `Orientation` enum. This example processes an array of objects with varying fields.

```rust
use json_to_table::{json_to_table, Orientation};
use serde_json::json;

fn main() {
    let value = json!(
        [
            {
                "name": "Aleix Melon",
                "role": ["Dev", "DBA"],
                "age": 23,
                "referred-by": "E0012"
            },
            {
                "name": "Aleix Melon",
                "role": ["DBA"],
                "age": 24,
                "referred-by": "E0012"
            },
        ]
    );

    let table = json_to_table(&value)

```

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

### Dynamic Table Theme with Customizations in Rust

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Modify table themes dynamically using `Theme`. This example demonstrates creating a theme from `Style::ascii_rounded` and then removing horizontal and vertical borders.

```rust
use tabled::settings::{Style, Theme};

let mut theme = Theme::from_style(Style::ascii_rounded());
theme.remove_borders_horizontal();
theme.remove_borders_vertical();

table.with(theme);

```

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

### Basic Table Creation with Papergrid

Source: https://github.com/zhiburt/tabled/blob/master/papergrid/README.md

Demonstrates how to configure and render a simple table using Papergrid. Includes setting borders, spans, alignments, and padding.

```rust
use papergrid::
    colors::NoColors,
    config::
        spanned::SpannedConfig,
    AlignmentHorizontal,
    AlignmentVertical,
    Borders,
    Entity,
    Indent,
    Sides,
 in papergrid::dimension::spanned::SpannedGridDimension;
use papergrid::grid::peekable::PeekableGrid;
use papergrid::records::vec_records::{CellInfo, VecRecords};

fn main() {
    let mut cfg = SpannedConfig::default();
    cfg.set_borders(Borders {
        top: Some('-'),
        top_left: Some('+'),
        top_right: Some('+'),
        top_intersection: Some('+'),
        bottom: Some('-'),
        bottom_left: Some('+'),
        bottom_right: Some('+'),
        bottom_intersection: Some('+'),
        horizontal: Some('-'),
        left_intersection: Some('+'),
        right_intersection: Some('+'),
        vertical: Some('|'),
        left: Some('|'),
        right: Some('|'),
        intersection: Some('+'),
    });
    cfg.set_column_span((1, 1), 3);
    cfg.set_row_span((0, 0), 2);
    cfg.set_alignment_horizontal((1, 0).into(), AlignmentHorizontal::Center);
    cfg.set_alignment_vertical(Entity::Global, AlignmentVertical::Center);
    cfg.set_padding(
        (0, 0).into(),
        Sides::new(
            Indent::spaced(4),
            Indent::spaced(4),
            Indent::spaced(1),
            Indent::spaced(1),
        ),
    );

    let data = [
        ["Papergrid", "is a library", "for print tables", "!"],
        ["", "Just like this", "", ""],
    ];

    let data = data
        .iter()
        .map(|row| row.iter().map(CellInfo::new).collect())
        .collect();

    let records = VecRecords::new(data);

    let mut dims = SpannedGridDimension::default();
    dims.estimate(&records, &cfg);

    let grid = PeekableGrid::new(&records, &cfg, &dims, NoColors).to_string();

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

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

### Build Table Step-by-Step with Style

Source: https://github.com/zhiburt/tabled/blob/master/tabled/README.md

Illustrates building a table incrementally using `Builder` and applying a specific style (`ascii_rounded`). Includes an assertion to verify the table's output.

```rust
use tabled::{builder::Builder, settings::Style};
use tabled::assert::assert_table;

let mut builder = Builder::new();
builder.push_record(["C", "Dennis Ritchie", "1972"]);
builder.push_record(["Go", "Rob Pike", "2009"]);
builder.push_record(["Rust", "Graydon Hoare", "2010"]);

let mut table = builder.build();
table.with(Style::ascii_rounded());

assert_table!(
    table,
    ".------------------------------."
    "| C    | Dennis Ritchie | 1972 |"
    "| Go   | Rob Pike       | 2009 |"
    "| Rust | Graydon Hoare  | 2010 |"
    "'------------------------------'"
);
```

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

### Display Table in PSQL Format

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Shows how to render a table in a format compatible with PostgreSQL's text output.

```text
 name | designed_by    | invented_year 
------+----------------+---------------
 C    | Dennis Ritchie | 1972          
 Rust | Graydon Hoare  | 2010          
 Go   | Rob Pike       | 2009          

```

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

### Use Testing Table Macros

Source: https://github.com/zhiburt/tabled/blob/master/testing_table/README.md

Demonstrates the usage of test_table!, assert_table!, and static_table! macros with a sample table. Ensure the 'testing_table' crate is included in your project.

```rust
use testing_table::{test_table, assert_table, static_table};

test_table!(
    test_tabled,
    tabled::Table::new([[1, 2, 3]]),
    "+---+---+---+"
    "| 0 | 1 | 2 |"
    "+---+---+---+"
    "| 1 | 2 | 3 |"
    "+---+---+---+"
);

assert_table!(
    tabled::Table::new([[1, 2, 3]]),
    "+---+---+---+"
    "| 0 | 1 | 2 |"
    "+---+---+---+"
    "| 1 | 2 | 3 |"
    "+---+---+---+"
);

static_table!(
    "+---+---+---+"
    "| 0 | 1 | 2 |"
    "+---+---+---+"
    "| 1 | 2 | 3 |"
    "+---+---+---+"
);
```

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

### Create and Customize HTML Table in Rust

Source: https://github.com/zhiburt/tabled/blob/master/table_to_html/README.md

Demonstrates how to create an HTML table from a 2D vector of strings, set a border, and print the resulting HTML. Ensure data is in the correct format before passing it to HtmlTable::new.

```rust
use table_to_html::HtmlTable;

fn main() {
    #[rustfmt::skip]
    let data = vec![
        ["0",  "INDIR", "",       "int sys_syscall(int number, ...)"],
        ["1",  "STD",   "",       "void sys_exit(int rval)"],
        ["2",  "STD",   "",       "int sys_fork(void)"],
        ["3",  "STD",   "NOLOCK", "ssize_t sys_read(int fd, void *buf, size_t nbyte)"],
        ["4",  "STD",   "NOLOCK", "ssize_t sys_write(int fd, const void *buf, size_t nbyte)"],
    ];

    let mut table = HtmlTable::new(data);
    table.set_border(3);

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

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

### Runtime Table Style Customization with Theme (Rust)

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Illustrates how to change table styles at runtime using the `Theme` object, including inserting horizontal lines and setting a custom frame.

```rust
use tabled::grid::config::{Border, HorizontalLine};
use tabled::settings::Theme;

let mut style = Theme::default();
style.insert_horizontal_line(1, HorizontalLine::full('-', '-', '+', '+'));
style.set_frame(Border::filled('+'));

```

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

### Basic JSON to Table Conversion

Source: https://github.com/zhiburt/tabled/blob/master/json_to_table/README.md

Use the `json_to_table` function to convert a JSON value into a formatted string table. This example shows a nested JSON structure.

```rust
use json_to_table::json_to_table;
use serde_json::json;

fn main() {
    let value = json!(
        [
            {
                "name": "Aleix Melon",
                "id": "E00245",
                "role": ["Dev", "DBA"],
                "age": 23,
                "doj": "11-12-2019",
                "married": false,
                "address": {
                    "street": "32, Laham St.",
                    "city": "Innsbruck",
                    "country": "Austria"
                    },
                "referred-by": "E0012"
            },
        ]
    );

    let table = json_to_table(&value).to_string();

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

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

### Apply PSQL Style to a Table

Source: https://github.com/zhiburt/tabled/blob/master/README.md

This snippet demonstrates how to apply a specific table style, 'psql', using the `with` method. This is useful for customizing the visual appearance of your tables at runtime.

```rust
use tabled::{Table, Style};

let mut table = Table::new(&data);
table.with(Style::psql());
```

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

### Format Table Cells

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Modifies cell content using a closure that takes row and column position. This example formats cells based on their row and column index.

```rust
use tabled::{
    settings::{format::Format, object::Rows},
    assert::assert_table,
    Table,
};

let mut table = Table::new([[0; 4]; 3]);
table.modify(
    Rows::new(..),
    Format::positioned(|_, p| ((p.row) * (p.col)).to_string()),
);

assert_table!(
    table,
    "+---+---+---+---+----+----+----+----+----+----+"
    "| 0 | 0 | 0 | 0 | 0  | 0  | 0  | 0  | 0  | 0  |"
    "+---+---+---+---+----+----+----+----+----+----+"
    "| 0 | 1 | 2 | 3 | 4  | 5  | 6  | 7  | 8  | 9  |"
    "+---+---+---+---+----+----+----+----+----+----+"
    "| 0 | 2 | 4 | 6 | 8  | 10 | 12 | 14 | 16 | 18 |"
    "+---+---+---+---+----+----+----+----+----+----+"
    "| 0 | 3 | 6 | 9 | 12 | 15 | 18 | 21 | 24 | 27 |"
    "+---+---+---+---+----+----+----+----+----+----+"
);
```

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

### Build Tables with Builder and Index Column

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Construct tables programmatically using `Builder`. The `index().column(1).name(None)` chain configures the first column as an index with no header. Ensure `Builder` and `Style` are imported.

```rust
use tabled::{builder::Builder, settings::Style};
use tabled::assert::assert_table;

let mut builder = Builder::default();
builder.push_record(["Index", "Language", "Status"]);
builder.push_record(["1", "English", "In progress"]);
builder.push_record(["2", "Deutsch", "Not ready"]);

let builder = builder.index().column(1).name(None);

let mut table = builder.build();
table.with(Style::rounded());

assert_table!(
 table,
 "╭─────────┬───────┬─────────────╮"
 "│         │ Index │ Status      │"
 "├─────────┼───────┼─────────────┤"
 "│ English │ 1     │ In progress │"
 "│ Deutsch │ 2     │ Not ready   │"
 "╰─────────┴───────┴─────────────╯"
);
```

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

### Advanced Merge Duplicates Table

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Shows an advanced example of merging duplicate rows with a different table style, potentially for wider displays or specific formatting needs.

```text
╭───────────┬───────────────────────────────────────────────────────────────────────────╮
│           │ 0        1        2        3        4        5           6        7       │
├───────────┼───────────────────────────────────────────────────────────────────────────┤
│ db        │ database_1                 database_2        database_3                   │
│ origin_db │ database_1                                   database_3                   │
│ table     │ table_1  table_2  table_3  table_1  table_2  table_1     table_2  table_3 │
│ total     │ 10712    57                72       75       20          21339    141723  │
╰───────────┴───────────────────────────────────────────────────────────────────────────╯
```

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

### Transpose Table Layout with Builder

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Modify the table layout by transposing rows and columns using the `transpose()` method on the builder. This example builds upon the previous builder configuration.

```rust
// ...
// Use previous example

let builder = builder.index()
 .column(1)
 .name(None)
 .transpose();
```

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

### Combine Tabled Objects using Tuples

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Combine different types that implement `Tabled` by using tuples to create combined columns. This example demonstrates combining a struct and an enum.

```rust
use tabled({
    settings::{Alignment, Style},
    assert::assert_table,
    Table,
    Tabled,
});

#[derive(Tabled)]
struct Developer(#[tabled(rename = "name")] &'static str);

#[derive(Tabled)]
enum Domain {
    Security,
    Embedded,
    Frontend,
    Unknown,
}

let data = vec![
    (Developer("Terri Kshlerin"), Domain::Embedded),
    (Developer("Catalina Dicki"), Domain::Security),
    (Developer("Jennie Schmeler"), Domain::Frontend),
    (Developer("Maxim Zhiburt"), Domain::Unknown),
];

let table = Table::new(data)
    .with(Style::psql())
    .with(Alignment::center())
    .to_string();

assert_table!(
    table,
    "      name       | Security | Embedded | Frontend | Unknown "
    "-----------------+----------+----------+----------+---------"
    " Terri Kshlerin  |          |    +     |          |         "
    " Catalina Dicki  |    +     |          |          |         "
    " Jennie Schmeler |          |          |    +     |         "
    "  Maxim Zhiburt  |          |          |          |    +    "
);
```

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

### Run Cargo Benchmarks

Source: https://github.com/zhiburt/tabled/blob/master/tabled/benches/lib_comp/README.md

Execute the benchmarks for the 'tabled' crate and its competitors. This command initiates the performance profiling of table construction.

```bash
cargo bench
```

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

### Custom Table Styling with Tabled

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Illustrates custom styling for a table, presenting software names, release years, and developers in a formatted grid.

```text
┌────────────────────┬─────────────────────────────────┐
│ name               │ first_release  developer        │
├────────────────────┼─────────────────────────────────┤
│ Sublime Text 3     │ 2008           Sublime HQ       │
│ Visual Studio Code │ 2015           Microsoft        │
│ Notepad++          │ 2003           Don Ho           │
│ GNU Emacs          │ 1984           Richard Stallman │
│ Neovim             │ 2015           Vim community    │
└────────────────────┴─────────────────────────────────┘
```

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

### Basic Table Output

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Displays a simple table with columns for name, based_on, is_active, and is_cool. This is a standard output format.

```text
| name    | based_on | is_active | is_cool |
|---------|----------|-----------|---------|
| Manjaro | Arch     | true      | true    |
| Arch    |          | true      | true    |
| Debian  |          | true      | true    |
```

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

### Derive Tabled Macro for Custom Types (Compile Fail Example)

Source: https://github.com/zhiburt/tabled/blob/master/README.md

Illustrates a scenario where the `Tabled` derive macro will fail to compile because a field type does not implement `std::fmt::Display`.

```rust
use tabled::Tabled;
#[derive(Tabled)]
struct SomeType {
    field1: SomeOtherType,
}

struct SomeOtherType;
```

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

### Iterate and Display Table Data

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Demonstrates how to read lines from a file and display them in a table with ASCII rounded borders. Requires `std::io::BufRead` and `tabled` crate.

```rust
.----------------------------------------------------------------------------------------.
| 0  | ok | //! The example can be run by this command                                   |
| 1  | ok | //! `cargo run --example iter_table`                                         |
| 2  | ok |                                                                              |
| 3  | ok | use std::io::BufRead;                                                        |
| 4  | ok |                                                                              |
| 5  | ok | use tabled::{settings::Style, tables::IterTable};               |
| 6  | ok |                                                                              |
| 7  | ok | fn main() {                                                                  |
| 8  | ok |     let path = file!();                                                      |
| 9  | ok |     let file = std::fs::File::open(path).unwrap();                           |
| 10 | ok |     let reader = std::io::BufReader::new(file);                              |
| 11 | ok |     let iterator = reader.lines().enumerate().map(|(i, line)| match line {   |
| 12 | ok |         Ok(line) => [i.to_string(), String::from("ok"), line],               |
| 13 | ok |         Err(err) => [i.to_string(), String::from("error"), err.to_string()], |
| 14 | ok |     });                                                                      |
| 15 | ok |                                                                              |
| 16 | ok |     let table = IterTable::new(iterator).with(Style::ascii_rounded());       |
| 17 | ok |                                                                              |
| 18 | ok |     table.build(std::io::stdout()).unwrap();                                 |
| 19 | ok |     println!()                                                               |
| 20 | ok | }                                                                            |
'----------------------------------------------------------------------------------------'

```

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

### Generate a static string table

Source: https://context7.com/zhiburt/tabled/llms.txt

Use the `static_table!` macro to create a `&'static str` table at compile time. Ensure the `static_table` crate is added to your `Cargo.toml`. The macro takes a 2D array of strings representing the table data and an optional `THEME` argument.

```rust
// In Cargo.toml: static_table = "*"
use static_table::static_table;

const TABLE: &str = static_table!(
    [
        ["x", "y", "op", "result"],
        ["1", "2", "*",  "2"],
        ["2", "2", "*",  "4"],
    ],
    THEME = "ROUNDED",
);

// Use in doc comments:
/// Multiplication table:
///
#[doc = static_table!([["x", "y", "result"], ["1", "2", "2"], ["2", "2", "4"]])]
pub fn mul(left: usize, right: usize) -> usize {
    left * right
}

assert_eq!(
    TABLE,
    "╭───┬───┬────┬────────╮\n\    │ x │ y │ op │ result │\n    ├───┼───┼────┼────────┤\n    │ 1 │ 2 │ *  │ 2      │\n    │ 2 │ 2 │ *  │ 4      │\n    ╰───┴───┴────┴────────╯"
);
```

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

### Adjust Table to Terminal Size

Source: https://github.com/zhiburt/tabled/blob/master/README.md

This snippet demonstrates how to dynamically adjust a table's width and height to fit the terminal. It uses the 'terminal_size' crate to get the current terminal dimensions and applies them as settings to the table.

```rust
use tabled::{
    builder::Builder,
    settings::{peaker::Priority, Height, Settings, Width},
    Table,
};
use terminal_size::{terminal_size, Height as TerminalHeight, Width as TerminalWidth};

fn get_terminal_size() -> (usize, usize) {
    let (TerminalWidth(width), TerminalHeight(height)) = 
        terminal_size().expect("failed to obtain a terminal size");

    (width as usize, height as usize)
}

let (width, height) = get_terminal_size();

let data = [
    ["0.2.1", "2021-06-23", "true", "#[header(inline)] attribute"],
    ["0.2.0", "2021-06-19", "false", "API changes"],
    ["0.1.4", "2021-06-07", "false", "display_with attribute"],
];

let settings = Settings::default()
    .with(Width::wrap(width).priority(Priority::max(true)))
    .with(Width::increase(width))
    .with(Height::limit(height))
    .with(Height::increase(height));

let mut table = Table::from_iter(data);
table.with(settings);

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

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

### Builder Index Table Output

Source: https://github.com/zhiburt/tabled/blob/master/tabled/examples/README.md

Demonstrates a table generated using the builder pattern, featuring a more complex border and indexed rows/columns. Suitable for structured data presentation.

```text
┌───────────┬─────────┬──────┬────────┐
│           │ Manjaro │ Arch │ Debian │
├───────────┼─────────┼──────┼────────┤
│ based_on  │ Arch    │ None │ None   │
├───────────┼─────────┼──────┼────────┤
│ is_active │ true    │ true │ true   │
├───────────┼─────────┼──────┼────────┤
│ is_cool   │ true    │ true │ true   │
└───────────┴─────────┴──────┴────────┘
```

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

### Generate Table with Critcmp

Source: https://github.com/zhiburt/tabled/blob/master/tabled/benches/lib_comp/README.md

Generate tables using the 'critcmp' tool, which is a dependency for running certain benchmarks. Ensure you have the correct manifest path.

```bash
cargo run --manifest-path=readme/Cargo.toml
```
Tokens:
Raw