render.go

package tabula

import (
	"strings"

	"charm.land/lipgloss/v2"
)

// How to handle row rendering
// ===========================
//
// Properties that contribute to the final width of a cell:
// 	- text content
// 	- padding times two; defaults to [CellPadding]
// 	- border characters (optional; shared between adjacent cells)
// 	- per-column padding (left and right; defaults to [CellPadding])
// 	- extra padding to fill up the cell (so all cells of that column
//    are equally wide)
// 	- maxGrowth is a special case...
//
// To render the table while also respecting these and the table's constraints,
// the [Table.Render] method follows a three-step algorithm:
//
// 	1. Calculate the natural/intrinsic width of each column:
//     `naturalWidth = max(contentWidth) + 2*padding + border`
//     - where `contentWidth` is the max width across all rows and the header
//     - deduplicated borders have a simple cell ownership rule: (a) the
//       separator between two cells belong to the *right* cell (its left
//       border), (b) the far-right outer border (if any) belongs to the last
//       cell
//     - `naturalWidth` is calculated for all columns, including maxGrowth
//     - the table's minimum width is:
//         `fixedWidth = sum(naturalWidths)`
//  2. Distribute the remaining space: `remainingSpace = tableWidth - fixedWidth`
//     - if the table has columns with maxGrowth, share the remaining space
// 	     equally between them (give the first columns the extra space if the
//       remaining space cannot be divided equally):
//       `extraSpacePerColumn = remainingSpace / numMaxGrowthColumns`
//     - if there are no maxGrowth columns or remainingSpace <= 0, no extra
//       width is distributed
//     - if `remainingSpace < 0`, overflow handling is currently TODO
//  3. Actually render the table with the calculated widths for each column
//
// This takes advantage of separating the rendering from the measurement /
// model calculation.
//
// ------------------------------

// naturalWidth calculates the intrinsic width of a column across all rows.
// This means the maximum content width plus padding and borders. The borders
// are deduplicated based on ownership rules. Does NOT include any extra
// padding such as when maxGrowth is enabled.
func (t *Table) naturalWidth(col Column) int {
	var maxContentWidth int

	// calculate the max content width across all rows for this column
	for _, row := range t.rows {
		cell := row.cells[col.index]
		width := lipgloss.Width(cell)
		if width > maxContentWidth {
			maxContentWidth = width
		}
	}

	// also consider the header content
	if w := lipgloss.Width(col.text); w > maxContentWidth {
		maxContentWidth = w
	}

	// if there's a summary row, also check that one
	if t.summary != nil && len(t.summary.cells) >= col.index {
		width := lipgloss.Width(t.summary.cells[col.index])
		if width > maxContentWidth {
			maxContentWidth = width
		}
	}

	var borderWidth int
	borderCharWidth := lipgloss.Width(RowBorderCharacter)

	if t.ownsLeftBorder(col) {
		borderWidth += borderCharWidth
	}
	if t.ownsRightBorder(col) {
		borderWidth += borderCharWidth
	}

	naturalWidth := maxContentWidth + col.leftPadding + col.rightPadding + borderWidth

	return naturalWidth
}

// distributeRemainingSpace calculates how to distribute the remaining space
// `tableWidth - fixedWidth` among the columns where maxGrowth=true. It returns
// a slice that has the same length as the number of columns, where each value
// is the extra width to add to that column. Only the maxGrowth columns will
// have a non-zero value.
func (t *Table) distributeRemainingSpace(r int) []int {
	var maxGrowthColumns int
	for _, col := range t.columns {
		if col.maxGrowth {
			maxGrowthColumns++
		}
	}

	// allocate for all columns anyway, easier to map back later
	maxGrowthWidths := make([]int, len(t.columns))

	if maxGrowthColumns == 0 || r <= 0 {
		return maxGrowthWidths
	}

	remainder := r % maxGrowthColumns
	share := r / maxGrowthColumns
	for _, col := range t.columns {
		if col.maxGrowth {
			maxGrowthWidths[col.index] = share
			if remainder > 0 {
				maxGrowthWidths[col.index]++
				remainder--
			}
		}
	}

	return maxGrowthWidths
}

// ownsLeftBorder determines whether the given column "owns" the left border
// (i.e. is responsible for rendering it). This is used to deduplicate borders
// between adjacent cells.
func (t *Table) ownsLeftBorder(col Column) bool {
	if col.index == 0 {
		return col.leftBorder
	}

	prev := t.columns[col.index-1]
	return prev.rightBorder || col.leftBorder
}

// ownsRightBorder determines whether the given column "owns" the right border
// (i.e. is responsible for rendering it). This is used to deduplicate borders
// between adjacent cells. This is only ever true for the last column, and only
// if it has a right border.
func (t *Table) ownsRightBorder(col Column) bool {
	return col.index == len(t.columns)-1 && col.rightBorder
}

// model is the numerical representation of the table used for rendering. Once
// calculated, [Table.draw] can actually render the table based on this model.
type model struct {
	naturalWidths   []int // len(t.columns)
	fixedWidth      int   // minimum width of the table (without extra space)
	tableWidth      int   // actual width of the table (with extar space)
	remainingSpace  int   // total remaining space
	maxGrowthWidths []int // len(t.columns); only non-zero for maxGrowth columns
}

// resolve calculates the model / numerical representation of the table used
// for rendering.
func (t *Table) resolve() model {

	naturalWidths := make([]int, len(t.columns))
	for i, col := range t.columns {
		naturalWidths[i] = t.naturalWidth(col)
	}

	fixedWidth := sum(naturalWidths)
	remainingSpace := t.width - fixedWidth

	if remainingSpace < 0 {
		// TODO: handle truncation
		// keep overflowing for now
	}

	maxGrowthWidths := t.distributeRemainingSpace(remainingSpace)

	tableWidth := fixedWidth + sum(maxGrowthWidths)

	return model{
		naturalWidths:   naturalWidths,
		fixedWidth:      fixedWidth,
		tableWidth:      tableWidth,
		remainingSpace:  remainingSpace,
		maxGrowthWidths: maxGrowthWidths,
	}
}

// ownedBorderWidth calculates the total width of the borders that a column is
// responsible for rendering.
func (t *Table) ownedBorderWidth(col Column) int {
	borderCharWidth := lipgloss.Width(RowBorderCharacter)
	width := 0
	if t.ownsLeftBorder(col) {
		width += borderCharWidth
	}
	if t.ownsRightBorder(col) {
		width += borderCharWidth
	}
	return width
}

// renderCell renders a single cell's content with the appropriate width,
// padding, alignment, and borders based on the resolved model.
func (t *Table) renderCell(row string, col Column, m model) string {
	finalWidth := m.naturalWidths[col.index] + m.maxGrowthWidths[col.index]
	cellWidth := finalWidth - t.ownedBorderWidth(col)

	style := lipgloss.NewStyle().
		Width(cellWidth).
		PaddingLeft(col.leftPadding).
		PaddingRight(col.rightPadding).
		Align(col.alignment)

	return style.Render(row)
}

// renderRow renders a single row of the table, including borders and padding,
// based on the resolved model.
func (t *Table) renderRow(r Row, m model) string {
	var b strings.Builder
	for _, col := range t.columns {
		if t.ownsLeftBorder(col) {
			b.WriteString(RowBorderCharacter)
		}
		var text string
		if col.index < len(r.cells) {
			text = r.cells[col.index]
		}
		b.WriteString(t.renderCell(text, col, m))
		if t.ownsRightBorder(col) {
			b.WriteString(RowBorderCharacter)
		}
	}
	b.WriteRune('\n')
	return b.String()
}

// renderHeader renders the header row with borders above and below it.
func (t *Table) renderHeader(m model) string {
	var b strings.Builder

	// TODO: make the border length configurable:
	// - minimum (`m.tableWidth`)
	// - maximum (``), potentially overflows
	// - terminal width

	headerBorder := strings.Repeat(HeaderCharacter, m.tableWidth) + "\n"
	headerRow := Row{}
	for _, col := range t.columns {
		headerRow.cells = append(headerRow.cells, col.text)
	}
	b.WriteString(headerBorder)
	b.WriteString(t.renderRow(headerRow, m))
	b.WriteString(headerBorder)

	return b.String()
}

// draw renders the table as a string
func (t *Table) draw(m model) string {
	var b strings.Builder

	b.WriteString(t.renderHeader(m))

	for _, row := range t.rows {
		b.WriteString(t.renderRow(row, m))
	}

	if t.summary != nil {
		border := strings.Repeat(SummaryRowCharacter, m.tableWidth) + "\n"
		b.WriteString(border)
		b.WriteString(t.renderRow(*t.summary, m))
	}

	return b.String()
}

// Render renders the table as a string.
func (t *Table) Render() string {
	m := t.resolve()
	return t.draw(m)
}