#Tabular

#Features

• 11 built-in style presets
• Customizable borders and horizontal lines
• Alignment, padding, width, height, and formatting controls
• Row, column, cell, and segment based table editing
• Column span and row span
• Panel, merge, highlight, shadow, split, extract, remove, and border correction
• Builder helpers with index and transpose support
• Rotate, reverse, concatenate, and duplicate selected records
• ANSI text colors, style parsing, and color-preserving width operations
• Composable table and cell options with measurements and resizing priorities
• Unicode 17 display width, colored padding, and margins

#Installation

moon add hustcer/tabular

import {
  "hustcer/tabular",
}

#Quick Start

///|
test "README quick start" {
  let table = @tabular.Table::from_rows([
    ["Name", "Language", "Stars"],
    ["Deno", "Rust/TS", "101k"],
    ["Bun", "Zig/C++", "76k"],
    ["Node.js", "C++/JS", "110k"],
  ])

  table.apply(@tabular.Style::modern()) |> ignore
  table.with_(@tabular.Alignment::center()) |> ignore
  assert_eq(
    table.to_string(),
    (
      #|┌─────────┬──────────┬───────┐
      #|│  Name   │ Language │ Stars │
      #|├─────────┼──────────┼───────┤
      #|│  Deno   │ Rust/TS  │ 101k  │
      #|├─────────┼──────────┼───────┤
      #|│   Bun   │ Zig/C++  │  76k  │
      #|├─────────┼──────────┼───────┤
      #|│ Node.js │  C++/JS  │ 110k  │
      #|└─────────┴──────────┴───────┘
    ),
  )
}

┌─────────┬──────────┬───────┐
│  Name   │ Language │ Stars │
├─────────┼──────────┼───────┤
│  Deno   │ Rust/TS  │ 101k  │
├─────────┼──────────┼───────┤
│   Bun   │ Zig/C++  │  76k  │
├─────────┼──────────┼───────┤
│ Node.js │  C++/JS  │ 110k  │
└─────────┴──────────┴───────┘

#Style Presets

table.apply(@tabular.Style::ascii()) |> ignore
table.apply(@tabular.Style::modern()) |> ignore
table.apply(@tabular.Style::rounded()) |> ignore
table.apply(@tabular.Style::extended()) |> ignore
table.apply(@tabular.Style::dots()) |> ignore
table.apply(@tabular.Style::empty()) |> ignore
table.apply(@tabular.Style::blank()) |> ignore
table.apply(@tabular.Style::re_structured_text()) |> ignore
table.apply(@tabular.Style::ascii_rounded()) |> ignore
table.apply(@tabular.Style::markdown()) |> ignore
table.apply(@tabular.Style::psql()) |> ignore

#Gallery

+----------+------+
| language | year |
+----------+------+
|   Rust   | 2010 |
+----------+------+
| MoonBit  | 2022 |
+----------+------+

┌──────────┬──────┐
│ language │ year │
├──────────┼──────┤
│   Rust   │ 2010 │
├──────────┼──────┤
│ MoonBit  │ 2022 │
└──────────┴──────┘

╭──────────┬──────╮
│ language │ year │
├──────────┼──────┤
│   Rust   │ 2010 │
├──────────┼──────┤
│ MoonBit  │ 2022 │
╰──────────┴──────╯

| language | year |
|----------|------|
|   Rust   | 2010 |
| MoonBit  | 2022 |

 language | year
----------+------
   Rust   | 2010
 MoonBit  | 2022

:.................:
: language : year :
:..........:......:
:   Rust   : 2010 :
:..........:......:
: MoonBit  : 2022 :
:.................:

╔══════════╦══════╗
║ language ║ year ║
╠══════════╬══════╣
║   Rust   ║ 2010 ║
╠══════════╬══════╣
║ MoonBit  ║ 2022 ║
╚══════════╩══════╝

 language  year
   Rust    2010
 MoonBit   2022

========== ======
 language   year
========== ======
   Rust     2010
 MoonBit    2022
========== ======

.-----------------.
| language | year |
|   Rust   | 2010 |
| MoonBit  | 2022 |
'-----------------'

#Custom Style

let style = @tabular.Style::ascii()
  .top('─')
  .bottom('─')
  .left('│')
  .right('│')
  .horizontal('─')
  .vertical('│')
  .corner_top_left('┌')
  .corner_top_right('┐')
  .corner_bottom_left('└')
  .corner_bottom_right('┘')

table.apply(style) |> ignore

let style = @tabular.Style::ascii()
  .remove_horizontal()
  .horizontals([
    (1, @tabular.HorizontalLine::full('-', '+', '+', '+')),
  ])

table.apply(style) |> ignore

#Builder

///|
test "README builder" {
  let builder = @tabular.Builder::default()
  builder.push_record(["Name", "Age", "City"])
  builder.push_record(["Alice", "30", "NYC"])
  builder.push_record(["Bob", "25", "LA"])
  let table = builder.build()
  assert_eq(table.shape(), (3, 3))
  assert_eq(table.rows[1], ["Alice", "30", "NYC"])
}

///|
let builder = @tabular.Builder::from_rows([
  ["Name", "Age"],
  ["Alice", "30"],
  ["Bob", "25"],
])

///|
let table1 = builder.index().build()

///|
let table2 = builder.index().transpose().build()

///|
let table3 = builder.index().hide().build()

#Common Edits

table.set_align(@tabular.Align::right()) |> ignore
table.set_padding(@tabular.Padding::new(1, 1, 0, 0)) |> ignore
table.set_width(@tabular.Width::wrap(10)) |> ignore
table.set_height(@tabular.Height::increase(2)) |> ignore

table.modify_rows(
  @tabular.Rows::first(),
  @tabular.Setting::align(@tabular.Align::center()),
) |> ignore

table.modify_cols(
  @tabular.Cols::one(1),
  @tabular.Setting::width(@tabular.Width::wrap(8)),
) |> ignore

table.modify_cell(
  @tabular.Cell::new(1, 2),
  @tabular.Setting::format(@tabular.Format::surround("[", "]")),
) |> ignore

#Spans

///|
test "README spans" {
  let table = @tabular.Table::from_rows([
    ["Team", "Q1", "Q2", "Q3"],
    ["A", "12", "18", "22"],
    ["B", "10", "16", "21"],
  ])

  table.apply(@tabular.Style::modern()) |> ignore
  table.with_(@tabular.Alignment::center()) |> ignore
  table.modify_cell(@tabular.Cell::new(0, 0), @tabular.Span::col(2)) |> ignore
  table.correct_borders() |> ignore
  assert_eq(
    table.to_string(),
    (
      #|┌────────┬────┬────┐
      #|│  Team  │ Q2 │ Q3 │
      #|├───┬────┼────┼────┤
      #|│ A │ 12 │ 18 │ 22 │
      #|├───┼────┼────┼────┤
      #|│ B │ 10 │ 16 │ 21 │
      #|└───┴────┴────┴────┘
    ),
  )
}

┌────────┬────┬────┐
│  Team  │ Q2 │ Q3 │
├───┬────┼────┼────┤
│ A │ 12 │ 18 │ 22 │
├───┼────┼────┼────┤
│ B │ 10 │ 16 │ 21 │
└───┴────┴────┴────┘

#Panels And Merge

let table = @tabular.Table::from_rows([
  ["0", "1", "2"],
  ["0", "1", "1"],
  ["1", "1", "2"],
  ["1", "1", "1"],
])

table.panel(@tabular.Panel::header("Runtime Comparison")) |> ignore
table.merge(@tabular.Merge::horizontal()) |> ignore
println(table.to_string())

#Highlight And Shadow

table.highlight(
  @tabular.Highlight::outline_cell(@tabular.Cell::new(1, 1), '*'),
) |> ignore

table.shadow(@tabular.Shadow::new(1)) |> ignore

#Split, Extract, Remove

table.extract_rows(@tabular.Rows::new(0, 2)) |> ignore
table.remove_cols(@tabular.Cols::one(0)) |> ignore
table.split(@tabular.Split::col(2).concat()) |> ignore

#Data Transforms

///|
test {
  let table = @tabular.Table::from_rows([["a", "b"], ["c", "d"]])
  table.rotate(@tabular.Rotate::Left) |> ignore
  assert_eq(table.rows, [["b", "d"], ["a", "c"]])

  table.reverse(@tabular.Reverse::rows(0)) |> ignore
  table.concat(
    @tabular.Concat::horizontal(@tabular.Table::from_rows([["e"], ["f"]])),
  )
  |> ignore
  table.duplicate(
    @tabular.Duplicate::new(
      source=@tabular.Rows::one(0),
      destination=@tabular.Rows::one(1),
    ),
  )
  |> ignore
  assert_eq(table.rows, [["a", "c", "e"], ["a", "c", "e"]])
}

#Composable Settings

///|
test {
  let settings = @tabular.Settings::default()
    .with_(@tabular.Style::psql())
    .with_(@tabular.Alignment::left())
    .modify(@tabular.Rows::first(), @tabular.Alignment::center())
  let table = @tabular.Table::from_rows([
      ["Name", "Status"],
      ["task", "pending"],
    ])
    .with_(settings)
    .modify(@tabular.Cell::new(1, 1), "done")
  assert_eq(table.shape(), (2, 2))
  assert_eq(table.rows[1], ["task", "done"])
}

#Text Formatting

///|
test {
  let table = @tabular.Table::from_rows([["hello"], ["a\nbc"]]).with_(
    (
      @tabular.Alignment::right(),
      @tabular.AlignmentStrategy::PerLine,
      @tabular.AlignmentFill::new('.'),
    ),
  )
  assert_eq(
    table.to_string(),
    "+-------+\n| hello |\n+-------+\n| ....a |\n| ...bc |\n+-------+",
  )
}

///|
test {
  let red = @tabular.Color::parse_or_abort("\u001b[31mtext\u001b[39m")
  assert_eq(red.colorize("hello"), "\u001b[31mhello\u001b[39m")
  assert_true(@tabular.Color::try_parse("") is Err(_))
  let table = @tabular.Table::from_rows([[red.colorize("abcdef")]]).modify(
    (0, 0),
    @tabular.Width::wrap(3),
  )
  assert_eq(
    table.to_string(),
    "+-----+\n| \u001b[31mabc\u001b[39m |\n| \u001b[31mdef\u001b[39m |\n+-----+",
  )
}

#Width and Dimensions

///|
test {
  let table = @tabular.Table::from_rows([["abcdef", "x"]])
    .modify((0, 0), @tabular.Width::truncate(4).suffix("..."))
    .with_(@tabular.Width::increase(20))
  assert_eq(table.rows, [["a...", "x"]])
  assert_eq(table.total_width(), 20)
}

#Height

///|
test {
  let table = @tabular.Table::from_rows([["first\nsecond"], ["last"]])
  table.modify((0, 0), @tabular.Height::limit(1)) |> ignore
  assert_eq(table.rows, [["first"], ["last"]])
  table.with_(@tabular.Height::increase(10)) |> ignore
  assert_eq(table.total_height(), 10)
  table.with_(@tabular.Height::list([0, 2])) |> ignore
  assert_eq(table.total_height(), 5)
}

#Padding and Margins

///|
test {
  let table = @tabular.Table::from_rows([["x"]])
    .with_(
      @tabular.Padding::new(1, 1, 1, 1).fill(
        left='>',
        right='<',
        top='^',
        bottom='v',
      ),
    )
    .with_(@tabular.PaddingColor::filled(@tabular.Color::bg_blue()))
    .with_(@tabular.Margin::new(left=1, right=1, top=0, bottom=0))
  assert_eq(
    @papergrid.strip_ansi(table.to_string()),
    " +---+ \n |^^^| \n |>x<| \n |vvv| \n +---+ ",
  )
}

#Validation

moon fmt --check
moon check --target all --deny-warn
moon build --target all --deny-warn
moon test --target all --deny-warn
moon info
git diff --exit-code -- '*.mbti'

#License