diff --git a/go.mod b/go.mod index de4423a4ed..95c1c9aa3d 100644 --- a/go.mod +++ b/go.mod @@ -58,7 +58,7 @@ require ( github.com/nats-io/nats-server/v2 v2.11.4 github.com/nats-io/nats.go v1.42.0 github.com/oklog/run v1.1.0 - github.com/olekukonko/tablewriter v1.0.6 + github.com/olekukonko/tablewriter v1.0.7 github.com/onsi/ginkgo v1.16.5 github.com/onsi/ginkgo/v2 v2.23.4 github.com/onsi/gomega v1.37.0 @@ -266,7 +266,7 @@ require ( github.com/nats-io/nuid v1.0.1 // indirect github.com/nxadm/tail v1.4.8 // indirect github.com/olekukonko/errors v0.0.0-20250405072817-4e6d85265da6 // indirect - github.com/olekukonko/ll v0.0.8-0.20250516010636-22ea57d81985 // indirect + github.com/olekukonko/ll v0.0.8 // indirect github.com/opentracing/opentracing-go v1.2.0 // indirect github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c // indirect github.com/pablodz/inotifywaitgo v0.0.9 // indirect diff --git a/go.sum b/go.sum index c0388a4d11..50cc3684a5 100644 --- a/go.sum +++ b/go.sum @@ -844,11 +844,11 @@ github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DV github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= github.com/olekukonko/errors v0.0.0-20250405072817-4e6d85265da6 h1:r3FaAI0NZK3hSmtTDrBVREhKULp8oUeqLT5Eyl2mSPo= github.com/olekukonko/errors v0.0.0-20250405072817-4e6d85265da6/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y= -github.com/olekukonko/ll v0.0.8-0.20250516010636-22ea57d81985 h1:V2wKiwjwAfRJRtUP6pC7wt4opeF14enO0du2dRV6Llo= -github.com/olekukonko/ll v0.0.8-0.20250516010636-22ea57d81985/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g= +github.com/olekukonko/ll v0.0.8 h1:sbGZ1Fx4QxJXEqL/6IG8GEFnYojUSQ45dJVwN2FH2fc= +github.com/olekukonko/ll v0.0.8/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= -github.com/olekukonko/tablewriter v1.0.6 h1:/T45mIHc5hcEvibgzBzvMy7ruT+RjgoQRvkHbnl6OWA= -github.com/olekukonko/tablewriter v1.0.6/go.mod h1:SJ0MV1aHb/89fLcsBMXMp30Xg3g5eGoOUu0RptEk4AU= +github.com/olekukonko/tablewriter v1.0.7 h1:HCC2e3MM+2g72M81ZcJU11uciw6z/p82aEnm4/ySDGw= +github.com/olekukonko/tablewriter v1.0.7/go.mod h1:H428M+HzoUXC6JU2Abj9IT9ooRmdq9CxuDmKMtrOCMs= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= diff --git a/vendor/github.com/olekukonko/ll/global.go b/vendor/github.com/olekukonko/ll/global.go index a4085dfb10..2ebea73b19 100644 --- a/vendor/github.com/olekukonko/ll/global.go +++ b/vendor/github.com/olekukonko/ll/global.go @@ -431,6 +431,15 @@ func Print(args ...any) { defaultLogger.Print(args...) } +// Println logs a message at Info level without format specifiers, minimizing allocations +// by concatenating arguments with spaces. It is thread-safe via the log method. +// Example: +// +// ll.Println("message", "value") // Output: [] INFO: message value [New Line] +func Println(args ...any) { + defaultLogger.Println(args...) +} + // Printf logs a message at Info level with a format string using the default logger. // It formats the message and delegates to defaultLogger’s Printf method. Thread-safe via // the Logger’s log method. @@ -573,7 +582,7 @@ func Disable() *Logger { // x := 42 // ll.Dbg(x) // Output: [file.go:123] x = 42 func Dbg(any ...interface{}) { - defaultLogger.Dbg(any...) + defaultLogger.dbg(2, any...) } // Dump displays a hex and ASCII representation of a value’s binary form using the default logger. @@ -638,3 +647,13 @@ func Line(lines ...int) *Logger { func Indent(depth int) *Logger { return defaultLogger.Indent(depth) } + +// Mark logs the current file and line number where it's called, without any additional debug information. +// It's useful for tracing execution flow without the verbosity of Dbg. +// Example: +// +// logger.Mark() // *MARK*: [file.go:123] +func Mark(names ...string) { + defaultLogger.mark(2, names...) + +} diff --git a/vendor/github.com/olekukonko/ll/ll.go b/vendor/github.com/olekukonko/ll/ll.go index 5b1344ea1d..3a660b9596 100644 --- a/vendor/github.com/olekukonko/ll/ll.go +++ b/vendor/github.com/olekukonko/ll/ll.go @@ -232,18 +232,6 @@ func (l *Logger) Debug(args ...any) { l.log(lx.LevelDebug, lx.ClassText, concatSpaced(args...), nil, false) } -func (l *Logger) Debug2(args ...any) { - // Skip logging if Debug level is not enabled - if !l.enabled { - return - } - l.log(lx.LevelDebug, lx.ClassText, concatSpaced(args...), nil, false) -} - -func (l *Logger) Debug3(args ...any) { - l.log(lx.LevelDebug, lx.ClassText, concatSpaced(args...), nil, false) -} - // Debugf logs a formatted message at Debug level, delegating to Debug. It is thread-safe. // Example: // @@ -736,6 +724,44 @@ func (l *Logger) Line(lines ...int) *Logger { return l } +// Mark logs the current file and line number where it's called, without any additional debug information. +// It's useful for tracing execution flow without the verbosity of Dbg. +// Example: +// +// logger.Mark() // *MARK*: [file.go:123] +func (l *Logger) Mark(name ...string) { + l.mark(2, name...) +} + +func (l *Logger) mark(skip int, names ...string) { + // Skip logging if Info level is not enabled + if !l.shouldLog(lx.LevelInfo) { + return + } + + // Get caller information (file, line) + _, file, line, ok := runtime.Caller(skip) + if !ok { + l.log(lx.LevelError, lx.ClassText, "Mark: Unable to parse runtime caller", nil, false) + return + } + + // Extract just the filename (without full path) + shortFile := file + if idx := strings.LastIndex(file, "/"); idx >= 0 { + shortFile = file[idx+1:] + } + + name := strings.Join(names, l.separator) + if name == "" { + name = "MARK" + } + + // Format as [filename:line] + out := fmt.Sprintf("[*%s*]: [%s:%d]\n", name, shortFile, line) + l.log(lx.LevelInfo, lx.ClassRaw, out, nil, false) +} + // Measure benchmarks function execution, logging the duration at Info level with a // "duration" field. It is thread-safe via Fields and log methods. // Example: @@ -920,6 +946,24 @@ func (l *Logger) Print(args ...any) { return } + // Skip logging if Info level is not enabled + if !l.shouldLog(lx.LevelInfo) { + return + } + l.log(lx.LevelNone, lx.ClassRaw, concatSpaced(args...), nil, false) +} + +// Println logs a message at Info level without format specifiers, minimizing allocations +// by concatenating arguments with spaces. It is thread-safe via the log method. +// Example: +// +// logger := New("app").Enable() +// logger.Println("message", "value") // Output: [app] INFO: message value +func (l *Logger) Println(args ...any) { + if l.suspend { + return + } + // Skip logging if Info level is not enabled if !l.shouldLog(lx.LevelInfo) { return diff --git a/vendor/github.com/olekukonko/tablewriter/MIGRATION.md b/vendor/github.com/olekukonko/tablewriter/MIGRATION.md new file mode 100644 index 0000000000..6500cd32d9 --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/MIGRATION.md @@ -0,0 +1,3042 @@ +# Migration Guide: tablewriter v0.0.5 to v1.0.x +> **NOTE:** This document is work in progress, use with `caution`. This document is a comprehensive guide. For specific issues or advanced scenarios, please refer to the source code or open an issue. + +The `tablewriter` library has undergone a significant redesign between versions **v0.0.5** and **v1.0.x**, transitioning from a primarily method-driven API to a more robust, modular, and configuration-driven framework. This guide provides a detailed roadmap for migrating your v0.0.5 codebase to v1.0.x. It includes mappings of old methods to new approaches, practical examples, and explanations of new features. + +We believe these changes significantly improve the library's flexibility, maintainability, and power, enabling new features and making complex table configurations more manageable. + +## Why Migrate to v1.0.x? + +The v1.0.x redesign enhances `tablewriter`’s flexibility, maintainability, and feature set: +- **Extensibility**: Decoupled rendering supports diverse output formats (e.g., HTML, Markdown, CSV). +- **Robust Configuration**: Centralized `Config` struct and fluent builders ensure atomic, predictable setups. +- **Streaming Capability**: Dedicated API for row-by-row rendering, ideal for large or real-time datasets. +- **Type Safety**: Specific types (e.g., `tw.State`, `tw.Align`) reduce errors and improve clarity. +- **Consistent API**: Unified interface for intuitive usage across simple and complex use cases. +- **New Features**: Hierarchical merging, granular padding, table captions, and fixed column widths. + +These improvements make v1.0.x more powerful, but they require updating code to leverage the new configuration-driven framework and take advantage of advanced functionalities. + +## Key New Features in v1.0.x + +- **Fluent Configuration Builders**: `NewConfigBuilder()` enables chained, readable setups (`config.go:NewConfigBuilder`). +- **Centralized Configuration**: `Config` struct governs table behavior and data processing (`config.go:Config`). +- **Decoupled Renderer**: `tw.Renderer` interface with `tw.Rendition` for visual styling, allowing custom renderers (`tw/renderer.go`). +- **True Streaming Support**: `Start()`, `Append()`, `Close()` for incremental rendering (`stream.go`). +- **Hierarchical Cell Merging**: `tw.MergeHierarchical` for complex data structures (`tw/tw.go:MergeMode` constant, logic in `zoo.go`). +- **Granular Padding Control**: Per-side (`Top`, `Bottom`, `Left`, `Right`) and per-column padding (`tw/cell.go:CellPadding`, `tw/types.go:Padding`). +- **Enhanced Type System**: `tw.State`, `tw.Align`, `tw.Spot`, and others for clarity and safety (`tw/state.go`, `tw/types.go`). +- **Comprehensive Error Handling**: Methods like `Render()` and `Append()` return errors (`tablewriter.go`, `stream.go`). +- **Fixed Column Width System**: `Config.Widths` for precise column sizing, especially in streaming (`config.go:Config`, `tw/cell.go:CellWidth`). +- **Table Captioning**: Flexible placement and styling with `tw.Caption` (`tw/types.go:Caption`). +- **Advanced Data Processing**: Support for `tw.Formatter`, per-column filters, and stringer caching (`tw/cell.go:CellFilter`, `tablewriter.go:WithStringer`). + +## Core Philosophy Changes in v1.0.x + +Understanding these shifts is essential for a successful migration: + +1. **Configuration-Driven Approach**: + - **Old**: Relied on `table.SetXxx()` methods for incremental, stateful modifications to table properties. + - **New**: Table behavior is defined by a `tablewriter.Config` struct (`config.go:Config`), while visual styling is managed by a `tw.Rendition` struct (`tw/renderer.go:Rendition`). These are typically set at table creation using `NewTable()` with `Option` functions or via a fluent `ConfigBuilder`, ensuring atomic and predictable configuration changes. + +2. **Decoupled Rendering Engine**: + - **Old**: Rendering logic was tightly integrated into the `Table` struct, limiting output flexibility. + - **New**: The `tw.Renderer` interface (`tw/renderer.go:Renderer`) defines rendering logic, with `renderer.NewBlueprint()` as the default text-based renderer. The renderer’s appearance (e.g., borders, symbols) is controlled by `tw.Rendition`, enabling support for alternative formats like HTML or Markdown. + +3. **Unified Section Configuration**: + - **Old**: Headers, rows, and footers had separate, inconsistent configuration methods. + - **New**: `tw.CellConfig` (`tw/cell.go:CellConfig`) standardizes configuration across headers, rows, and footers, encompassing formatting (`tw.CellFormatting`), padding (`tw.CellPadding`), column widths (`tw.CellWidth`), alignments (`tw.CellAlignment`), and filters (`tw.CellFilter`). + +4. **Fluent Configuration Builders**: + - **Old**: Configuration was done via individual setters, often requiring multiple method calls. + - **New**: `tablewriter.NewConfigBuilder()` (`config.go:NewConfigBuilder`) provides a chained, fluent API for constructing `Config` objects, with nested builders for `Header()`, `Row()`, `Footer()`, `Alignment()`, `Behavior()`, and `ForColumn()` to simplify complex setups. + +5. **Explicit Streaming Mode**: + - **Old**: No dedicated streaming support; tables were rendered in batch mode. + - **New**: Streaming for row-by-row rendering is enabled via `Config.Stream.Enable` or `WithStreaming(tw.StreamConfig{Enable: true})` and managed with `Table.Start()`, `Table.Append()` (or `Table.Header()`, `Table.Footer()`), and `Table.Close()` (`stream.go`). This is ideal for large datasets or continuous output. + +6. **Enhanced Error Handling**: + - **Old**: Methods like `Render()` did not return errors, making error detection difficult. + - **New**: Key methods (`Render()`, `Start()`, `Close()`, `Append()`, `Bulk()`) return errors to promote robust error handling and improve application reliability (`tablewriter.go`, `stream.go`). + +7. **Richer Type System & `tw` Package**: + - **Old**: Used integer constants (e.g., `ALIGN_CENTER`) and booleans, leading to potential errors. + - **New**: The `tw` sub-package introduces type-safe constructs like `tw.State` (`tw/state.go`), `tw.Align` (`tw/types.go`), `tw.Position` (`tw/types.go`), and `tw.CellConfig` (`tw/cell.go`), replacing magic constants and enhancing code clarity. + +## Configuration Methods in v1.0.x + +v1.0.x offers four flexible methods to configure tables, catering to different use cases and complexity levels. Each method can be used independently or combined, providing versatility for both simple and advanced setups. + +1. **Using `WithConfig` Option**: + - **Description**: Pass a fully populated `tablewriter.Config` struct during `NewTable` initialization using the `WithConfig` option. + - **Use Case**: Ideal for predefined, reusable configurations that can be serialized or shared across multiple tables. + - **Pros**: Explicit, portable, and suitable for complex setups; allows complete control over all configuration aspects. + - **Cons**: Verbose for simple changes, requiring manual struct population. + - **Example**: + +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + cfg := tablewriter.Config{ + Header: tw.CellConfig{ + Alignment: tw.CellAlignment{Global: tw.AlignCenter}, + Formatting: tw.CellFormatting{AutoFormat: tw.On}, + }, + Row: tw.CellConfig{ + Alignment: tw.CellAlignment{Global: tw.AlignLeft}, + }, + MaxWidth: 80, + Behavior: tw.Behavior{TrimSpace: tw.On}, + } + table := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfg)) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() +} +``` +**Output**: + ``` +┌───────┬────────┐ +│ NAME │ STATUS │ +├───────┼────────┤ +│ Node1 │ Ready │ +└───────┴────────┘ + ``` + +2. **Using `Table.Configure` method**: + - **Description**: After creating a `Table` instance, use the `Configure` method with a function that modifies the table's `Config` struct. + - **Use Case**: Suitable for quick, ad-hoc tweaks post-initialization, especially for simple or dynamic adjustments. + - **Pros**: Straightforward for minor changes; no need for additional structs or builders if you already have a `Table` instance. + - **Cons**: Less readable for complex configurations compared to a builder; modifications are applied to an existing instance. + - **Example**: +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout) + table.Configure(func(cfg *tablewriter.Config) { + cfg.Header.Alignment.Global = tw.AlignCenter + cfg.Row.Alignment.Global = tw.AlignLeft + }) + + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() +} +``` +**Output**: Same as above. + +3. **Standalone `Option` Functions**: + - **Description**: Use `WithXxx` functions (e.g., `WithHeaderAlignment`, `WithDebug`) during `NewTable` initialization or via `table.Options()` to apply targeted settings. + - **Use Case**: Best for simple, specific configuration changes without needing a full `Config` struct. + - **Pros**: Concise, readable, and intuitive for common settings; ideal for minimal setups. + - **Cons**: Limited for complex, multi-faceted configurations; requires multiple options for extensive changes. + - **Example**: +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithHeaderAlignment(tw.AlignCenter), + tablewriter.WithRowAlignment(tw.AlignLeft), + tablewriter.WithDebug(true), + ) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() +} +``` + **Output**: Same as above. + +4. **Fluent `ConfigBuilder`**: + - **Description**: Use `tablewriter.NewConfigBuilder()` to construct a `Config` struct through a chained, fluent API, then apply it with `WithConfig(builder.Build())`. + - **Use Case**: Optimal for complex, dynamic, or programmatically generated configurations requiring fine-grained control. + - **Pros**: Highly readable, maintainable, and expressive; supports nested builders for sections and columns. + - **Cons**: Slightly verbose; requires understanding builder methods and `Build()` call. + - **Example**: +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + cnfBuilder := tablewriter.NewConfigBuilder() + cnfBuilder.Header().Alignment().WithGlobal(tw.AlignCenter) + // Example of configuring a specific column (less emphasis on this for now) + // cnfBuilder.ForColumn(0).WithAlignment(tw.AlignLeft).Build() // Call Build() to return to ConfigBuilder + + table := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cnfBuilder.Build())) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() +} +``` +**Output**: Same as above. + +**Best Practices**: +- Use `WithConfig` or `ConfigBuilder` for complex setups or reusable configurations. +- Opt for `Option` functions for simple, targeted changes. +- Use `Table.Configure` for direct modifications after table creation, but avoid changes during rendering. +- Combine methods as needed (e.g., `ConfigBuilder` for initial setup, `Option` functions for overrides). + +## Default Parameters in v1.0.x + +The `defaultConfig()` function (`config.go:defaultConfig`) establishes baseline settings for new tables, ensuring predictable behavior unless overridden. Below is a detailed table of default parameters, organized by configuration section, to help you understand the starting point for table behavior and appearance. + +| Section | Parameter | Default Value | Description | +|---------------|-------------------------------|-----------------------------------|-----------------------------------------------------------------------------| +| **Header** | `Alignment.Global` | `tw.AlignCenter` | Centers header text globally unless overridden by `PerColumn`. | +| Header | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global` unless specified. | +| Header | `Formatting.AutoFormat` | `tw.On` | Applies title case (e.g., "col_one" → "COL ONE") to header content. | +| Header | `Formatting.AutoWrap` | `tw.WrapTruncate` | Truncates long header text with "…" based on width constraints. | +| Header | `Formatting.MergeMode` | `tw.MergeNone` | Disables cell merging in headers by default. | +| Header | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of header cells. | +| Header | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global` unless specified. | +| Header | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for header cells unless set. | +| Header | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits unless specified. | +| Header | `Filter.Global` | `nil` | No global content transformation for header cells. | +| Header | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations unless specified. | +| **Row** | `Alignment.Global` | `tw.AlignLeft` | Left-aligns row text globally unless overridden by `PerColumn`. | +| Row | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global`. | +| Row | `Formatting.AutoFormat` | `tw.Off` | Disables auto-formatting (e.g., title case) for row content. | +| Row | `Formatting.AutoWrap` | `tw.WrapNormal` | Wraps long row text naturally at word boundaries based on width constraints.| +| Row | `Formatting.MergeMode` | `tw.MergeNone` | Disables cell merging in rows by default. | +| Row | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of row cells. | +| Row | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global`. | +| Row | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for row cells. | +| Row | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits. | +| Row | `Filter.Global` | `nil` | No global content transformation for row cells. | +| Row | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations. | +| **Footer** | `Alignment.Global` | `tw.AlignRight` | Right-aligns footer text globally unless overridden by `PerColumn`. | +| Footer | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global`. | +| Footer | `Formatting.AutoFormat` | `tw.Off` | Disables auto-formatting for footer content. | +| Footer | `Formatting.AutoWrap` | `tw.WrapNormal` | Wraps long footer text naturally. | +| Footer | `Formatting.MergeMode` | `tw.MergeNone` | Disables cell merging in footers. | +| Footer | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of footer cells. | +| Footer | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global`. | +| Footer | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for footer cells. | +| Footer | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits. | +| Footer | `Filter.Global` | `nil` | No global content transformation for footer cells. | +| Footer | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations. | +| **Global** | `MaxWidth` | `0` (unlimited) | No overall table width limit. | +| Global | `Behavior.AutoHide` | `tw.Off` | Displays empty columns (ignored in streaming). | +| Global | `Behavior.TrimSpace` | `tw.On` | Trims leading/trailing spaces from cell content. | +| Global | `Behavior.Header` | `tw.Control{Hide: tw.Off}` | Shows header if content is provided. | +| Global | `Behavior.Footer` | `tw.Control{Hide: tw.Off}` | Shows footer if content is provided. | +| Global | `Behavior.Compact` | `tw.Compact{Merge: tw.Off}` | No compact width optimization for merged cells. | +| Global | `Debug` | `false` | Disables debug logging. | +| Global | `Stream.Enable` | `false` | Disables streaming mode by default. | +| Global | `Widths.Global` | `0` (unlimited) | No fixed column width unless specified. | +| Global | `Widths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column fixed widths unless specified. | + +**Notes**: +- Defaults can be overridden using any configuration method. +- `tw.PaddingDefault` is `{Left: " ", Right: " "}` (`tw/preset.go`). +- Alignment within `tw.CellFormatting` is deprecated; `tw.CellAlignment` is preferred. `tw.AlignDefault` falls back to `Global` or `tw.AlignLeft` (`tw/types.go`). +- Streaming mode uses `Widths` for fixed column sizing (`stream.go`). + +## Renderer Types and Customization + +v1.0.x introduces a flexible rendering system via the `tw.Renderer` interface (`tw/renderer.go:Renderer`), allowing for both default text-based rendering and custom output formats. This decouples rendering logic from table data processing, enabling support for diverse formats like HTML, CSV, or JSON. + +### Default Renderer: `renderer.NewBlueprint` +- **Description**: `renderer.NewBlueprint()` creates a text-based renderer. Its visual styles are configured using `tw.Rendition`. +- **Use Case**: Standard terminal or text output with configurable borders, symbols, and separators. +- **Configuration**: Styled via `tw.Rendition`, which controls: + - `Borders`: Outer table borders (`tw.Border`) with `tw.State` for each side (`tw/renderer.go`). + - `Settings`: Internal lines (`tw.Lines`) and separators (`tw.Separators`) (`tw/renderer.go`). + - `Symbols`: Characters for drawing table lines and junctions (`tw.Symbols`) (`tw/symbols.go`). + - **Example**: +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" // Import the renderer package + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), // Default Blueprint renderer + tablewriter.WithRendition(tw.Rendition{ // Apply custom rendition + Symbols: tw.NewSymbols(tw.StyleRounded), + Borders: tw.Border{Top: tw.On, Bottom: tw.On, Left: tw.On, Right: tw.On}, + Settings: tw.Settings{ + Separators: tw.Separators{BetweenRows: tw.On}, + Lines: tw.Lines{ShowHeaderLine: tw.On}, + }, + }), + ) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() +} +``` +**Output**: + ``` + ╭───────┬────────╮ + │ Name │ Status │ + ├───────┼────────┤ + │ Node1 │ Ready │ + ╰───────┴────────╯ + ``` + +### Custom Renderer Implementation +- **Description**: Implement the `tw.Renderer` interface to create custom output formats (e.g., HTML, CSV). +- **Use Case**: Non-text outputs, specialized formatting, or integration with other systems. +- **Interface Methods**: + - `Start(w io.Writer) error`: Initializes rendering. + - `Header(headers [][]string, ctx tw.Formatting)`: Renders header rows. + - `Row(row []string, ctx tw.Formatting)`: Renders a data row. + - `Footer(footers [][]string, ctx tw.Formatting)`: Renders footer rows. + - `Line(ctx tw.Formatting)`: Renders separator lines. + - `Close() error`: Finalizes rendering. + - `Config() tw.Rendition`: Returns renderer's current rendition configuration. + - `Logger(logger *ll.Logger)`: Sets logger for debugging. + - **Example (HTML Renderer)**: + +```go +package main + +import ( + "fmt" + "github.com/olekukonko/ll" // For logger type + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "io" + "os" +) + +// BasicHTMLRenderer implements tw.Renderer +type BasicHTMLRenderer struct { + writer io.Writer + config tw.Rendition // Store the rendition + logger *ll.Logger + err error +} + +func (r *BasicHTMLRenderer) Start(w io.Writer) error { + r.writer = w + _, r.err = r.writer.Write([]byte("\n")) + return r.err +} + +// Header expects [][]string for potentially multi-line headers +func (r *BasicHTMLRenderer) Header(headers [][]string, ctx tw.Formatting) { + if r.err != nil { return } + _, r.err = r.writer.Write([]byte(" \n")) + if r.err != nil { return } + // Iterate over cells from the context for the current line + for _, cellCtx := range ctx.Row.Current { + content := fmt.Sprintf(" \n", cellCtx.Data) + _, r.err = r.writer.Write([]byte(content)) + if r.err != nil { return } + } + _, r.err = r.writer.Write([]byte(" \n")) +} + +// Row expects []string for a single line row, but uses ctx for actual data +func (r *BasicHTMLRenderer) Row(row []string, ctx tw.Formatting) { // row param is less relevant here, ctx.Row.Current is key + if r.err != nil { return } + _, r.err = r.writer.Write([]byte(" \n")) + if r.err != nil { return } + for _, cellCtx := range ctx.Row.Current { + content := fmt.Sprintf(" \n", cellCtx.Data) + _, r.err = r.writer.Write([]byte(content)) + if r.err != nil { return } + } + _, r.err = r.writer.Write([]byte(" \n")) +} + +func (r *BasicHTMLRenderer) Footer(footers [][]string, ctx tw.Formatting) { + if r.err != nil { return } + // Similar to Header/Row, using ctx.Row.Current for the footer line data + // The footers [][]string param might be used if the renderer needs multi-line footer logic + r.Row(nil, ctx) // Reusing Row logic, passing nil for the direct row []string as ctx contains the data +} + +func (r *BasicHTMLRenderer) Line(ctx tw.Formatting) { /* No lines in basic HTML */ } + +func (r *BasicHTMLRenderer) Close() error { + if r.err != nil { + return r.err + } + _, r.err = r.writer.Write([]byte("
%s
%s
\n")) + return r.err +} + +func (r *BasicHTMLRenderer) Config() tw.Rendition { return r.config } +func (r *BasicHTMLRenderer) Logger(logger *ll.Logger) { r.logger = logger } + +func main() { + table := tablewriter.NewTable(os.Stdout, tablewriter.WithRenderer(&BasicHTMLRenderer{ + config: tw.Rendition{Symbols: tw.NewSymbols(tw.StyleASCII)}, // Provide a default Rendition + })) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() +} +``` +**Output**: +```html + + + + + + + + + +
NAMESTATUS
Node1Ready
+``` + +**Notes**: +- The `renderer.NewBlueprint()` is sufficient for most text-based use cases. +- Custom renderers require implementing all interface methods to handle table structure correctly. `tw.Formatting` (which includes `tw.RowContext`) provides cell content and metadata. + +## Function Mapping Table (v0.0.5 → v1.0.x) + +The following table maps v0.0.5 methods to their v1.0.x equivalents, ensuring a quick reference for migration. All deprecated methods are retained for compatibility but should be replaced with new APIs. + +| v0.0.5 Method | v1.0.x Equivalent(s) | Notes | +|-----------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------| +| `NewWriter(w)` | `NewTable(w, opts...)` | `NewWriter` deprecated; wraps `NewTable` (`tablewriter.go`). | +| `SetHeader([]string)` | `Header(...any)` | Variadic or slice; supports any type (`tablewriter.go`). | +| `Append([]string)` | `Append(...any)` | Variadic, slice, or struct (`tablewriter.go`). | +| `AppendBulk([][]string)` | `Bulk([]any)` | Slice of rows; supports any type (`tablewriter.go`). | +| `SetFooter([]string)` | `Footer(...any)` | Variadic or slice; supports any type (`tablewriter.go`). | +| `Render()` | `Render()` (returns `error`) | Batch mode; streaming uses `Start/Close` (`tablewriter.go`). | +| `SetBorder(bool)` | `WithRendition(tw.Rendition{Borders: ...})` or `WithBorders(tw.Border)` (deprecated) | Use `tw.Border` (`deprecated.go`, `tw/renderer.go`). | +| `SetRowLine(bool)` | `WithRendition(tw.Rendition{Settings: {Separators: {BetweenRows: tw.On}}})` | `tw.Separators` (`tw/renderer.go`). | +| `SetHeaderLine(bool)` | `WithRendition(tw.Rendition{Settings: {Lines: {ShowHeaderLine: tw.On}}})` | `tw.Lines` (`tw/renderer.go`). | +| `SetColumnSeparator(string)` | `WithRendition(tw.Rendition{Symbols: ...})` or `WithSymbols(tw.Symbols)` (deprecated)| `tw.NewSymbols` or custom `tw.Symbols` (`tw/symbols.go`). | +| `SetCenterSeparator(string)` | `WithRendition(tw.Rendition{Symbols: ...})` or `WithSymbols(tw.Symbols)` (deprecated)| `tw.Symbols` (`tw/symbols.go`). | +| `SetRowSeparator(string)` | `WithRendition(tw.Rendition{Symbols: ...})` or `WithSymbols(tw.Symbols)` (deprecated)| `tw.Symbols` (`tw/symbols.go`). | +| `SetAlignment(int)` | `WithRowAlignment(tw.Align)` or `Config.Row.Alignment.Global` | `tw.Align` type (`config.go`). | +| `SetHeaderAlignment(int)` | `WithHeaderAlignment(tw.Align)` or `Config.Header.Alignment.Global` | `tw.Align` type (`config.go`). | +| `SetAutoFormatHeaders(bool)` | `WithHeaderAutoFormat(tw.State)` or `Config.Header.Formatting.AutoFormat` | `tw.State` (`config.go`). | +| `SetAutoWrapText(bool)` | `WithRowAutoWrap(int)` or `Config.Row.Formatting.AutoWrap` (uses `tw.Wrap...` const) | `tw.WrapNormal`, `tw.WrapTruncate`, etc. (`config.go`). | +| `SetAutoMergeCells(bool)` | `WithRowMergeMode(int)` or `Config.Row.Formatting.MergeMode` (uses `tw.Merge...` const) | Supports `Vertical`, `Hierarchical` (`config.go`). | +| `SetColMinWidth(col, w)` | `WithColumnWidths(tw.NewMapper[int,int]().Set(col, w))` or `Config.Widths.PerColumn` | `Config.Widths` for fixed widths (`config.go`). | +| `SetTablePadding(string)` | Use `Config.
.Padding.Global` with `tw.Padding` | No direct equivalent; manage via cell padding (`tw/cell.go`). | +| `SetDebug(bool)` | `WithDebug(bool)` or `Config.Debug` | Logs via `table.Debug()` (`config.go`). | +| `Clear()` | `Reset()` | Clears data and state (`tablewriter.go`). | +| `SetNoWhiteSpace(bool)` | `WithTrimSpace(tw.Off)` (if `true`) or `WithPadding(tw.PaddingNone)` | Manage via `Config.Behavior.TrimSpace` or padding (`config.go`). | +| `SetColumnColor(Colors)` | Embed ANSI codes in cell data, use `tw.Formatter`, or `Config.
.Filter` | Colors via data or filters (`tw/cell.go`). | +| `SetHeaderColor(Colors)` | Embed ANSI codes in cell data, use `tw.Formatter`, or `Config.Header.Filter` | Colors via data or filters (`tw/cell.go`). | +| `SetFooterColor(Colors)` | Embed ANSI codes in cell data, use `tw.Formatter`, or `Config.Footer.Filter` | Colors via data or filters (`tw/cell.go`). | + +**Notes**: +- Deprecated methods are in `deprecated.go` but should be replaced. +- `tw` package types (e.g., `tw.Align`, `tw.State`) are required for new APIs. +- Examples for each mapping are provided in the migration steps below. + +## Detailed Migration Steps: Initialization, Data Input, Rendering + +This section provides step-by-step guidance for migrating core table operations, with code examples and explanations to ensure clarity. Each step maps v0.0.5 methods to v1.0.x equivalents, highlighting changes, best practices, and potential pitfalls. + +### 1. Table Initialization +Initialization has shifted from `NewWriter` to `NewTable`, which supports flexible configuration via `Option` functions, `Config` structs, or `ConfigBuilder`. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // ... use table + _ = table // Avoid "declared but not used" +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "fmt" // Added for FormattableEntry example + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" // Import renderer + "github.com/olekukonko/tablewriter/tw" + "os" + "strings" // Added for Formatter example +) + +func main() { + // Minimal Setup (Default Configuration) + tableMinimal := tablewriter.NewTable(os.Stdout) + _ = tableMinimal // Avoid "declared but not used" + + // Using Option Functions for Targeted Configuration + tableWithOptions := tablewriter.NewTable(os.Stdout, + tablewriter.WithHeaderAlignment(tw.AlignCenter), // Center header text + tablewriter.WithRowAlignment(tw.AlignLeft), // Left-align row text + tablewriter.WithDebug(true), // Enable debug logging + ) + _ = tableWithOptions // Avoid "declared but not used" + + // Using a Full Config Struct for Comprehensive Control + cfg := tablewriter.Config{ + Header: tw.CellConfig{ + Alignment: tw.CellAlignment{ + Global: tw.AlignCenter, + PerColumn: []tw.Align{tw.AlignLeft, tw.AlignRight}, // Column-specific alignment + }, + Formatting: tw.CellFormatting{AutoFormat: tw.On}, + }, + Row: tw.CellConfig{ + Alignment: tw.CellAlignment{Global: tw.AlignLeft}, + Formatting: tw.CellFormatting{AutoWrap: tw.WrapNormal}, + }, + Footer: tw.CellConfig{ + Alignment: tw.CellAlignment{Global: tw.AlignRight}, + }, + MaxWidth: 80, // Constrain total table width + Behavior: tw.Behavior{ + AutoHide: tw.Off, // Show empty columns + TrimSpace: tw.On, // Trim cell spaces + }, + Widths: tw.CellWidth{ + Global: 20, // Default fixed column width + PerColumn: tw.NewMapper[int, int]().Set(0, 15), // Column 0 fixed at 15 + }, + } + tableWithConfig := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfg)) + _ = tableWithConfig // Avoid "declared but not used" + + // Using ConfigBuilder for Fluent, Complex Configuration + builder := tablewriter.NewConfigBuilder(). + WithMaxWidth(80). + WithAutoHide(tw.Off). + WithTrimSpace(tw.On). + WithDebug(true). // Enable debug logging + Header(). + Alignment(). + WithGlobal(tw.AlignCenter). + Build(). // Returns *ConfigBuilder + Header(). + Formatting(). + WithAutoFormat(tw.On). + WithAutoWrap(tw.WrapTruncate). // Test truncation + WithMergeMode(tw.MergeNone). // Explicit merge mode + Build(). // Returns *HeaderConfigBuilder + Padding(). + WithGlobal(tw.Padding{Left: "[", Right: "]", Overwrite: true}). + Build(). // Returns *HeaderConfigBuilder + Build(). // Returns *ConfigBuilder + Row(). + Formatting(). + WithAutoFormat(tw.On). // Uppercase rows + Build(). // Returns *RowConfigBuilder + Build(). // Returns *ConfigBuilder + Row(). + Alignment(). + WithGlobal(tw.AlignLeft). + Build(). // Returns *ConfigBuilder + Build() // Finalize Config + + tableWithFluent := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(builder)) + _ = tableWithFluent // Avoid "declared but not used" +} +``` + +**Key Changes**: +- **Deprecation**: `NewWriter` is deprecated but retained for compatibility, internally calling `NewTable` (`tablewriter.go:NewWriter`). Transition to `NewTable` for new code. +- **Flexibility**: `NewTable` accepts an `io.Writer` and variadic `Option` functions (`tablewriter.go:NewTable`), enabling configuration via: + - `WithConfig(Config)`: Applies a complete `Config` struct (`config.go:WithConfig`). + - `WithRenderer(tw.Renderer)`: Sets a custom renderer, defaulting to `renderer.NewBlueprint()` (`tablewriter.go:WithRenderer`). + - `WithRendition(tw.Rendition)`: Configures visual styles for the renderer (`tablewriter.go:WithRendition`). + - `WithStreaming(tw.StreamConfig)`: Enables streaming mode (`tablewriter.go:WithStreaming`). + - Other `WithXxx` functions for specific settings (e.g., `WithHeaderAlignment`, `WithDebug`). +- **ConfigBuilder**: Provides a fluent API for complex setups; `Build()` finalizes the `Config` (`config.go:ConfigBuilder`). +- **Method Chaining in Builder**: Remember to call `Build()` on nested builders to return to the parent builder (e.g., `builder.Header().Alignment().WithGlobal(...).Build().Formatting()...`). + +**Migration Tips**: +- Replace `NewWriter` with `NewTable` and specify configurations explicitly. +- Use `ConfigBuilder` for complex setups or when readability is paramount. +- Apply `Option` functions for quick, targeted changes. +- Ensure `tw` package is imported for types like `tw.Align` and `tw.CellConfig`. +- Verify renderer settings if custom styling is needed, as `renderer.NewBlueprint()` is the default. + +**Potential Pitfalls**: +- **Unintended Defaults**: Without explicit configuration, `defaultConfig()` applies (see Default Parameters), which may differ from v0.0.5 behavior (e.g., `Header.Formatting.AutoFormat = tw.On`). +- **Renderer Absence**: If no renderer is set, `NewTable` defaults to `renderer.NewBlueprint()`; explicitly set for custom formats. +- **ConfigBuilder Errors**: Always call `Build()` at the end of a builder chain and on nested builders; omitting it can lead to incomplete configurations or runtime errors. +- **Concurrent Modification**: Avoid modifying `Table.config` (if using the `Configure` method or direct access) in concurrent scenarios or during rendering to prevent race conditions. + +### 2. Data Input +Data input methods in v1.0.x are more flexible, accepting `any` type for headers, rows, and footers, with robust conversion logic to handle strings, structs, and custom types. + +#### 2.1. Setting Headers +Headers define the table’s column labels and are typically the first data added. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + table.SetHeader([]string{"Name", "Sign", "Rating"}) + // ... +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.Formatter + "os" + "strings" +) + +// Struct with Formatter +type HeaderData struct { // Renamed to avoid conflict + Label string +} + +func (h HeaderData) Format() string { return strings.ToUpper(h.Label) } // Implements tw.Formatter + +func main() { + table := tablewriter.NewTable(os.Stdout) + + // Variadic Arguments (Preferred for Simplicity) + table.Header("Name", "Sign", "Rating") + + // Slice of Strings + // table.Header([]string{"Name", "Sign", "Rating"}) // Example, comment out if using variadic + + // Slice of Any Type (Flexible) + // table.Header([]any{"Name", "Sign", 123}) // Numbers converted to strings + + // Using Formatter + // table.Header(HeaderData{"name"}, HeaderData{"sign"}, HeaderData{"rating"}) // Outputs "NAME", "SIGN", "RATING" + + table.Append("Example", "Row", "Data") // Add some data to render + table.Render() +} +``` + +**Key Changes**: +- **Method**: `SetHeader([]string)` replaced by `Header(...any)` (`tablewriter.go:Header`). +- **Flexibility**: Accepts variadic arguments or a single slice; supports any type, not just strings. +- **Conversion**: Elements are processed by `processVariadic` (`zoo.go:processVariadic`) and converted to strings via `convertCellsToStrings` (`zoo.go:convertCellsToStrings`), supporting: + - Basic types (e.g., `string`, `int`, `float64`). + - `fmt.Stringer` implementations. + - `tw.Formatter` implementations (custom string conversion). + - Structs (exported fields as cells or single cell if `Stringer`/`Formatter`). +- **Streaming**: In streaming mode, `Header()` renders immediately via `streamRenderHeader` (`stream.go:streamRenderHeader`). +- **Formatting**: Headers are formatted per `Config.Header` settings (e.g., `AutoFormat`, `Alignment`) during rendering (`zoo.go:prepareContent`). + +**Migration Tips**: +- Replace `SetHeader` with `Header`, using variadic arguments for simplicity. +- Use slices for dynamic header lists or when passing from a variable. +- Implement `tw.Formatter` for custom header formatting (e.g., uppercase). +- Ensure header count matches expected columns to avoid width mismatches. +- In streaming mode, call `Header()` before rows, as it fixes column widths (`stream.go`). + +**Potential Pitfalls**: +- **Type Mismatch**: Non-string types are converted to strings; ensure desired formatting (e.g., use `tw.Formatter` for custom types). +- **Streaming Widths**: Headers influence column widths in streaming; set `Config.Widths` explicitly if specific widths are needed (`stream.go:streamCalculateWidths`). +- **Empty Headers**: Missing headers may cause rendering issues; provide placeholders (e.g., `""`) if needed. +- **AutoFormat**: Default `Header.Formatting.AutoFormat = tw.On` applies title case; disable with `WithHeaderAutoFormat(tw.Off)` if unwanted (`config.go`). + +#### 2.2. Appending Rows +Rows represent the table’s data entries, and v1.0.x enhances flexibility with support for varied input types. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + table.SetHeader([]string{"ColA", "ColB", "ColC"}) // Add header for context + table.Append([]string{"A", "The Good", "500"}) + table.Append([]string{"B", "The Very Bad", "288"}) + data := [][]string{ + {"C", "The Ugly", "120"}, + {"D", "The Gopher", "800"}, + } + table.AppendBulk(data) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.Formatter + "log" + "os" +) + +// Struct for examples +type Entry struct { + ID string + Label string + Score int +} + +// Struct with Formatter +type FormattableEntry struct { + ID string + Label string + Score int +} + +func (e FormattableEntry) Format() string { return fmt.Sprintf("%s (%d)", e.Label, e.Score) } // Implements tw.Formatter + +func main() { + table := tablewriter.NewTable(os.Stdout) + table.Header("ID", "Description", "Value") // Header for context + + // Variadic Arguments (Single Row) + table.Append("A", "The Good", 500) // Numbers converted to strings + + // Slice of Any Type (Single Row) + table.Append([]any{"B", "The Very Bad", "288"}) + + // Struct with Fields + table.Append(Entry{ID: "C", Label: "The Ugly", Score: 120}) // Fields as cells + + // Struct with Formatter (will produce a single cell for this row based on Format()) + // To make it fit 3 columns, the formatter would need to produce a string that looks like 3 cells, or the table config would need to adapt. + // For this example, let's assume it's meant to be one wide cell, or adjust the header. + // For now, let's simplify and append it to a table with one header. + tableOneCol := tablewriter.NewTable(os.Stdout) + tableOneCol.Header("Formatted Entry") + tableOneCol.Append(FormattableEntry{ID: "D", Label: "The Gopher", Score: 800}) // Single cell "The Gopher (800)" + tableOneCol.Render() + fmt.Println("---") + + + // Re-initialize main table for Bulk example + table = tablewriter.NewTable(os.Stdout) + table.Header("ID", "Description", "Value") + + // Multiple Rows with Bulk + data := []any{ + []any{"E", "The Fast", 300}, + Entry{ID: "F", Label: "The Swift", Score: 400}, // Struct instance + // FormattableEntry{ID: "G", Label: "The Bold", Score: 500}, // Would also be one cell + } + if err := table.Bulk(data); err != nil { + log.Fatalf("Bulk append failed: %v", err) + } + table.Render() +} +``` + +**Key Changes**: +- **Method**: `Append([]string)` replaced by `Append(...any)`; `AppendBulk([][]string)` replaced by `Bulk([]any)` (`tablewriter.go`). +- **Input Flexibility**: `Append` accepts: + - Multiple arguments as cells of a single row. + - A single slice (e.g., `[]string`, `[]any`) as cells of a single row. + - A single struct, processed by `convertItemToCells` (`zoo.go`): + - Uses `tw.Formatter` or `fmt.Stringer` for single-cell output. + - Extracts exported fields as multiple cells otherwise. +- **Bulk Input**: `Bulk` accepts a slice where each element is a row (e.g., `[][]any`, `[]Entry`), processed by `appendSingle` (`zoo.go:appendSingle`). +- **Streaming**: Rows render immediately in streaming mode via `streamAppendRow` (`stream.go:streamAppendRow`). +- **Error Handling**: `Append` and `Bulk` return errors for invalid conversions or streaming issues (`tablewriter.go`). + +**Migration Tips**: +- Replace `Append([]string)` with `Append(...any)` for variadic input. +- Use `Bulk` for multiple rows, ensuring each element is a valid row representation. +- Implement `tw.Formatter` for custom struct formatting to control cell output. +- Match row cell count to headers to avoid alignment issues. +- In streaming mode, append rows after `Start()` and before `Close()` (`stream.go`). + +**Potential Pitfalls**: +- **Cell Count Mismatch**: Uneven row lengths may cause rendering errors; pad with empty strings (e.g., `""`) if needed. +- **Struct Conversion**: Unexported fields are ignored; ensure fields are public or use `Formatter`/`Stringer` (`zoo.go`). +- **Streaming Order**: Rows must be appended after headers in streaming to maintain width consistency (`stream.go`). +- **Error Ignored**: Always check `Bulk` errors, as invalid data can cause failures. + +#### 2.3. Setting Footers +Footers provide summary or closing data for the table, often aligned differently from rows. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + table.SetHeader([]string{"ColA", "ColB", "ColC", "ColD"}) // Add header for context + table.SetFooter([]string{"", "", "Total", "1408"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.Formatter + "os" +) + +// Using Formatter +type FooterSummary struct { // Renamed to avoid conflict + Label string + Value float64 +} + +func (s FooterSummary) Format() string { return fmt.Sprintf("%s: %.2f", s.Label, s.Value) } // Implements tw.Formatter + +func main() { + table := tablewriter.NewTable(os.Stdout) + table.Header("ColA", "ColB", "ColC", "ColD") // Header for context + + // Variadic Arguments + table.Footer("", "", "Total", 1408) + + // Slice of Any Type + // table.Footer([]any{"", "", "Total", 1408.50}) + + table.Render() // Render this table + + fmt.Println("--- Another Table with Formatter Footer ---") + table2 := tablewriter.NewTable(os.Stdout) + table2.Header("Summary Info") // Single column header + // Using Formatter for a single cell footer + table2.Footer(FooterSummary{Label: "Grand Total", Value: 1408.50}) // Single cell: "Grand Total: 1408.50" + table2.Render() +} +``` + +**Key Changes**: +- **Method**: `SetFooter([]string)` replaced by `Footer(...any)` (`tablewriter.go:Footer`). +- **Input Flexibility**: Like `Header`, accepts variadic arguments, slices, or structs with `Formatter`/`Stringer` support (`zoo.go:processVariadic`). +- **Streaming**: Footers are buffered via `streamStoreFooter` and rendered during `Close()` (`stream.go:streamStoreFooter`, `stream.go:streamRenderFooter`). +- **Formatting**: Controlled by `Config.Footer` settings (e.g., `Alignment`, `AutoWrap`) (`zoo.go:prepareTableSection`). + +**Migration Tips**: +- Replace `SetFooter` with `Footer`, preferring variadic input for simplicity. +- Use `tw.Formatter` for custom footer formatting (e.g., formatted numbers). +- Ensure footer cell count matches headers/rows to maintain alignment. +- In streaming mode, call `Footer()` before `Close()` to include it in rendering. + +**Potential Pitfalls**: +- **Alignment Differences**: Default `Footer.Alignment.Global = tw.AlignRight` differs from rows (`tw.AlignLeft`); adjust if needed (`config.go`). +- **Streaming Timing**: Footers not rendered until `Close()`; ensure `Close()` is called (`stream.go`). +- **Empty Footers**: Missing footers may affect table appearance; use placeholders if needed. + +### 3. Rendering the Table +Rendering has been overhauled to support both batch and streaming modes, with mandatory error handling for robustness. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + table.SetHeader([]string{"Data"}) + table.Append([]string{"Example"}) + table.Render() +} +``` + +**New (v1.0.x) - Batch Mode:** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "log" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout) + table.Header("Data") + table.Append("Example") + if err := table.Render(); err != nil { + log.Fatalf("Table rendering failed: %v", err) + } +} +``` + +**New (v1.0.x) - Streaming Mode:** +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "log" + "os" +) + +func main() { + tableStream := tablewriter.NewTable(os.Stdout, + tablewriter.WithConfig(tablewriter.Config{ + Stream: tw.StreamConfig{Enable: true}, + Widths: tw.CellWidth{ + Global: 12, // Fixed column width for streaming + PerColumn: tw.NewMapper[int, int]().Set(0, 15), // Column 0 at 15 + }, + }), + ) + // Alternative: Using WithStreaming Option + // tableStream := tablewriter.NewTable(os.Stdout, + // tablewriter.WithStreaming(tw.StreamConfig{Enable: true}), + // tablewriter.WithColumnMax(12), // Sets Config.Widths.Global + // ) + + if err := tableStream.Start(); err != nil { + log.Fatalf("Failed to start table stream: %v", err) + } + tableStream.Header("Column 1", "Column 2") + for i := 0; i < 3; i++ { + if err := tableStream.Append(fmt.Sprintf("Data %d-1", i), fmt.Sprintf("Data %d-2", i)); err != nil { + log.Printf("Failed to append row %d: %v", i, err) // Log and continue or handle differently + } + } + tableStream.Footer("End", "Summary") + if err := tableStream.Close(); err != nil { + log.Fatalf("Failed to close table stream: %v", err) + } +} +``` + +**Key Changes**: +- **Batch Mode**: + - `Render()` processes all data (headers, rows, footers) in one go (`tablewriter.go:render`). + - Calculates column widths dynamically based on content, `Config.Widths`, `ColMaxWidths`, and `MaxWidth` (`zoo.go:calculateAndNormalizeWidths`). + - Invokes renderer methods: `Start()`, `Header()`, `Row()`, `Footer()`, `Line()`, `Close()` (`tw/renderer.go`). + - Returns errors for invalid configurations or I/O issues. +- **Streaming Mode**: + - Enabled via `Config.Stream.Enable` or `WithStreaming(tw.StreamConfig{Enable: true})` (`tablewriter.go:WithStreaming`). + - `Start()` initializes the stream, fixing column widths based on `Config.Widths` or first data (header/row) (`stream.go:streamCalculateWidths`). + - `Header()`, `Append()` render immediately (`stream.go:streamRenderHeader`, `stream.go:streamAppendRow`). + - `Footer()` buffers data, rendered by `Close()` (`stream.go:streamStoreFooter`, `stream.go:streamRenderFooter`). + - `Close()` finalizes rendering with footer and borders (`stream.go:Close`). + - All methods return errors for robust handling. +- **Error Handling**: Mandatory error checks replace silent failures, improving reliability. + +**Migration Tips**: +- Replace `Render()` calls with error-checked versions in batch mode. +- For streaming, adopt `Start()`, `Append()`, `Close()` workflow, ensuring `Start()` precedes data input. +- Set `Config.Widths` for consistent column widths in streaming mode (`config.go`). +- Use `WithRendition` to customize visual output, as renderer settings are decoupled (`tablewriter.go`). +- Test rendering with small datasets to verify configuration before scaling. + +**Potential Pitfalls**: +- **Missing Error Checks**: Failing to check errors can miss rendering failures; always use `if err != nil`. +- **Streaming Widths**: Widths are fixed after `Start()`; inconsistent data may cause truncation (`stream.go`). +- **Renderer Misconfiguration**: Ensure `tw.Rendition` matches desired output style (`tw/renderer.go`). +- **Incomplete Streaming**: Forgetting `Close()` in streaming mode omits footer and final borders (`stream.go`). +- **Batch vs. Streaming**: Using `Render()` in streaming mode causes errors; use `Start()`/`Close()` instead (`tablewriter.go`). + + +## Styling and Appearance Configuration + +Styling in v1.0.x is split between `tablewriter.Config` for data processing (e.g., alignment, padding, wrapping) and `tw.Rendition` for visual rendering (e.g., borders, symbols, lines). This section details how to migrate v0.0.5 styling methods to v1.0.x, providing examples, best practices, and migration tips to maintain or enhance table appearance. + +### 4.1. Table Styles +Table styles define the visual structure through border and separator characters. In v0.0.5, styles were set via individual separator methods, whereas v1.0.x uses `tw.Rendition.Symbols` for a cohesive approach, offering predefined styles and custom symbol sets. + +**Available Table Styles**: +The `tw.Symbols` interface (`tw/symbols.go`) supports a variety of predefined styles, each tailored to specific use cases, as well as custom configurations for unique requirements. + +| Style Name | Use Case | Symbols Example | Recommended Context | +|----------------|-----------------------------------|-------------------------------------|-----------------------------------------| +| `StyleASCII` | Simple, terminal-friendly | `+`, `-`, `|` | Basic CLI output, minimal dependencies; ensures compatibility across all terminals, including older or non-Unicode systems. | +| `StyleLight` | Clean, lightweight borders | `┌`, `└`, `─`, `│` | Modern terminals, clean and professional aesthetics; suitable for most CLI applications requiring a modern look. | +| `StyleHeavy` | Thick, prominent borders | `┏`, `┗`, `━`, `┃` | High-visibility reports, dashboards, or logs; emphasizes table structure for critical data presentation. | +| `StyleDouble` | Double-line borders | `╔`, `╚`, `═`, `║` | Formal documents, structured data exports; visually distinct for presentations or printed outputs. | +| `StyleRounded` | Rounded corners, aesthetic | `╭`, `╰`, `─`, `│` | User-friendly CLI applications, reports; enhances visual appeal with smooth, rounded edges. | +| `StyleMarkdown`| Markdown-compatible | `|`, `-`, `:` | Documentation, GitHub READMEs, or Markdown-based platforms; ensures proper rendering in Markdown viewers. | +*Note: `StyleBold` was mentioned but not defined in the symbols code, `StyleHeavy` is similar.* + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetCenterSeparator("*") // Example, actual v0.0.5 method might vary + // table.SetColumnSeparator("!") + // table.SetRowSeparator("=") + // table.SetBorder(true) + table.SetHeader([]string{"Header1", "Header2"}) + table.Append([]string{"Cell1", "Cell2"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + // Using a Predefined Style (Rounded Corners for Aesthetic Output) + tableStyled := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), // Ensure renderer is set + tablewriter.WithRendition(tw.Rendition{ + Symbols: tw.NewSymbols(tw.StyleRounded), // Predefined rounded style + Borders: tw.Border{Top: tw.On, Bottom: tw.On, Left: tw.On, Right: tw.On}, + Settings: tw.Settings{ + Separators: tw.Separators{BetweenRows: tw.On}, // Lines between rows + }, + }), + ) + tableStyled.Header("Name", "Status") + tableStyled.Append("Node1", "Ready") + tableStyled.Render() + + // Using Fully Custom Symbols (Mimicking v0.0.5 Custom Separators) + mySymbols := tw.NewSymbolCustom("my-style"). // Fluent builder for custom symbols + WithCenter("*"). // Junction of lines + WithColumn("!"). // Vertical separator + WithRow("="). // Horizontal separator + WithTopLeft("/"). + WithTopMid("-"). + WithTopRight("\\"). + WithMidLeft("["). + WithMidRight("]"). // Corrected from duplicate WithMidRight("+") + // WithMidMid was not a method in SymbolCustom + WithBottomLeft("\\"). + WithBottomMid("_"). + WithBottomRight("/"). + WithHeaderLeft("("). + WithHeaderMid("-"). + WithHeaderRight(")") // Header-specific + tableCustomSymbols := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), + tablewriter.WithRendition(tw.Rendition{ + Symbols: mySymbols, + Borders: tw.Border{Top: tw.On, Bottom: tw.On, Left: tw.On, Right: tw.On}, + }), + ) + tableCustomSymbols.Header("Name", "Status") + tableCustomSymbols.Append("Node1", "Ready") + tableCustomSymbols.Render() +} +``` + +**Output (Styled, Rounded):** +``` +╭───────┬────────╮ +│ NAME │ STATUS │ +├───────┼────────┤ +│ Node1 │ Ready │ +╰───────┴────────╯ +``` + +**Output (Custom Symbols):** +``` +/=======-========\ +! NAME ! STATUS ! +[=======*========] +! Node1 ! Ready ! +\=======_========/ +``` + +**Key Changes**: +- **Deprecated Methods**: `SetCenterSeparator`, `SetColumnSeparator`, `SetRowSeparator`, and `SetBorder` are deprecated and moved to `deprecated.go`. These are replaced by `tw.Rendition.Symbols` and `tw.Rendition.Borders` for a unified styling approach (`tablewriter.go`). +- **Symbol System**: The `tw.Symbols` interface defines all drawing characters used for table lines, junctions, and corners (`tw/symbols.go:Symbols`). + - `tw.NewSymbols(tw.BorderStyle)` provides predefined styles (e.g., `tw.StyleASCII`, `tw.StyleMarkdown`, `tw.StyleRounded`) for common use cases. (Note: `tw.Style` should be `tw.BorderStyle`) + - `tw.NewSymbolCustom(name string)` enables fully custom symbol sets via a fluent builder, allowing precise control over each character (e.g., `WithCenter`, `WithTopLeft`). +- **Renderer Dependency**: Styling requires a renderer, set via `WithRenderer`; the default is `renderer.NewBlueprint()` if not specified (`tablewriter.go:WithRenderer`). +- **Border Control**: `tw.Rendition.Borders` uses `tw.State` (`tw.On`, `tw.Off`) to enable or disable borders on each side (Top, Bottom, Left, Right) (`tw/renderer.go:Border`). +- **Extensibility**: Custom styles can be combined with custom renderers for non-text outputs, enhancing flexibility (`tw/renderer.go`). + +**Migration Tips**: +- Replace individual separator setters (`SetCenterSeparator`, etc.) with `tw.NewSymbols` for predefined styles or `tw.NewSymbolCustom` for custom designs to maintain or enhance v0.0.5 styling. +- Use `WithRendition` to apply `tw.Rendition` settings, ensuring a renderer is explicitly set to avoid default behavior (`tablewriter.go`). +- Test table styles in your target environment (e.g., terminal, Markdown viewer, or log file) to ensure compatibility with fonts and display capabilities. +- For Markdown-based outputs (e.g., GitHub READMEs), use `tw.StyleMarkdown` to ensure proper rendering in Markdown parsers (`tw/symbols.go`). +- Combine `tw.Rendition.Symbols` with `tw.Rendition.Borders` and `tw.Rendition.Settings` to replicate or improve v0.0.5’s border and line configurations (`tw/renderer.go`). +- Document custom symbol sets in code comments to aid maintenance, as they can be complex (`tw/symbols.go`). + +**Potential Pitfalls**: +- **Missing Renderer**: If `WithRenderer` is omitted, `NewTable` defaults to `renderer.NewBlueprint` with minimal styling, which may not match v0.0.5’s `SetBorder(true)` behavior; always specify for custom styles (`tablewriter.go`). +- **Incomplete Custom Symbols**: When using `tw.NewSymbolCustom`, failing to set all required symbols (e.g., `TopLeft`, `Center`, `HeaderLeft`) can cause rendering errors or inconsistent visuals; ensure all necessary characters are defined (`tw/symbols.go`). +- **Terminal Compatibility Issues**: Advanced styles like `StyleDouble` or `StyleHeavy` may not render correctly in older terminals or non-Unicode environments; use `StyleASCII` for maximum compatibility across platforms (`tw/symbols.go`). +- **Border and Symbol Mismatch**: Inconsistent `tw.Rendition.Borders` and `tw.Symbols` settings (e.g., enabling borders but using minimal symbols) can lead to visual artifacts; test with small tables to verify alignment (`tw/renderer.go`). +- **Markdown Rendering**: Non-Markdown styles (e.g., `StyleRounded`) may not render correctly in Markdown viewers; use `StyleMarkdown` for documentation or web-based outputs (`tw/symbols.go`). + +### 4.2. Borders and Separator Lines +Borders and internal lines define the table’s structural appearance, controlling the visibility of outer edges and internal divisions. In v0.0.5, these were set via specific methods, while v1.0.x uses `tw.Rendition` fields for a more integrated approach. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetBorder(false) // Disable all outer borders + // table.SetRowLine(true) // Enable lines between data rows + // table.SetHeaderLine(true) // Enable line below header + table.SetHeader([]string{"Header1", "Header2"}) + table.Append([]string{"Cell1", "Cell2"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + // Standard Bordered Table with Internal Lines + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), + tablewriter.WithRendition(tw.Rendition{ + Borders: tw.Border{ // Outer table borders + Left: tw.On, + Right: tw.On, + Top: tw.On, + Bottom: tw.On, + }, + Settings: tw.Settings{ + Lines: tw.Lines{ // Major internal separator lines + ShowHeaderLine: tw.On, // Line after header + ShowFooterLine: tw.On, // Line before footer (if footer exists) + }, + Separators: tw.Separators{ // General row and column separators + BetweenRows: tw.On, // Horizontal lines between data rows + BetweenColumns: tw.On, // Vertical lines between columns + }, + }, + }), + ) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() + + // Borderless Table (kubectl-style, No Lines or Separators) + // Configure the table with a borderless, kubectl-style layout + config := tablewriter.NewConfigBuilder(). + Header(). + Padding(). + WithGlobal(tw.PaddingNone). // No header padding + Build(). + Alignment(). + WithGlobal(tw.AlignLeft). // Left-align header + Build(). + Row(). + Padding(). + WithGlobal(tw.PaddingNone). // No row padding + Build(). + Alignment(). + WithGlobal(tw.AlignLeft). // Left-align rows + Build(). + Footer(). + Padding(). + WithGlobal(tw.PaddingNone). // No footer padding + Build(). + Alignment(). + WithGlobal(tw.AlignLeft). // Left-align footer (if used) + Build(). + WithDebug(true). // Enable debug logging + Build() + + // Create borderless table + tableBorderless := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), // Assumes valid renderer + tablewriter.WithRendition(tw.Rendition{ + Borders: tw.BorderNone, // No borders + Symbols: tw.NewSymbols(tw.StyleNone), // No border symbols + Settings: tw.Settings{ + Lines: tw.LinesNone, // No header/footer lines + Separators: tw.SeparatorsNone, // No row/column separators + }, + }), + tablewriter.WithConfig(config), + ) + + // Set headers and data + tableBorderless.Header("Name", "Status") + tableBorderless.Append("Node1", "Ready") + tableBorderless.Render() +} +``` + +**Output (Standard Bordered):** +``` +┌───────┬────────┐ +│ Name │ Status │ +├───────┼────────┤ +│ Node1 │ Ready │ +└───────┴────────┘ +``` + +**Output (Borderless):** +``` +NAME STATUS +Node1 Ready +``` + +**Key Changes**: +- **Deprecated Methods**: `SetBorder`, `SetRowLine`, and `SetHeaderLine` are deprecated and moved to `deprecated.go`. These are replaced by fields in `tw.Rendition` (`tw/renderer.go`): + - `Borders`: Controls outer table borders (`tw.Border`) with `tw.State` (`tw.On`, `tw.Off`) for each side (Top, Bottom, Left, Right). + - `Settings.Lines`: Manages major internal lines (`ShowHeaderLine` for header, `ShowFooterLine` for footer) (`tw.Lines`). + - `Settings.Separators`: Controls general separators between rows (`BetweenRows`) and columns (`BetweenColumns`) (`tw.Separators`). +- **Presets for Simplicity**: `tw.BorderNone`, `tw.LinesNone`, and `tw.SeparatorsNone` provide quick configurations for minimal or borderless tables (`tw/preset.go`). +- **Renderer Integration**: Border and line settings are applied via `WithRendition`, requiring a renderer to be set (`tablewriter.go:WithRendition`). +- **Granular Control**: Each border side and line type can be independently configured, offering greater flexibility than v0.0.5’s boolean toggles. +- **Dependency on Symbols**: The appearance of borders and lines depends on `tw.Rendition.Symbols`; ensure compatible symbol sets (`tw/symbols.go`). + +**Migration Tips**: +- Replace `SetBorder(false)` with `tw.Rendition.Borders = tw.BorderNone` to disable all outer borders (`tw/preset.go`). +- Use `tw.Rendition.Settings.Separators.BetweenRows = tw.On` to replicate `SetRowLine(true)`, ensuring row separators are visible (`tw/renderer.go`). +- Set `tw.Rendition.Settings.Lines.ShowHeaderLine = tw.On` to mimic `SetHeaderLine(true)` for a line below the header (`tw/renderer.go`). +- For kubectl-style borderless tables, combine `tw.BorderNone`, `tw.LinesNone`, `tw.SeparatorsNone`, and `WithPadding(tw.PaddingNone)` (applied via `ConfigBuilder` or `WithConfig`) to eliminate all lines and spacing (`tw/preset.go`, `config.go`). +- Test border and line configurations with small tables to verify visual consistency, especially when combining with custom `tw.Symbols`. +- Use `WithDebug(true)` to log rendering details if borders or lines appear incorrectly (`config.go`). + +**Potential Pitfalls**: +- **Separator Absence**: If `tw.Rendition.Settings.Separators.BetweenColumns` is `tw.Off` and borders are disabled, columns may lack visual separation; use `tw.CellPadding` or ensure content spacing (`tw/cell.go`). +- **Line and Border Conflicts**: Mismatched settings (e.g., enabling `ShowHeaderLine` but disabling `Borders.Top`) can cause uneven rendering; align `Borders`, `Lines`, and `Separators` settings (`tw/renderer.go`). +- **Renderer Dependency**: Border settings require a renderer; omitting `WithRenderer` defaults to `renderer.NewBlueprint` with minimal styling, which may not match v0.0.5 expectations (`tablewriter.go`). +- **Streaming Limitations**: In streaming mode, separator rendering is fixed after `Start()`; ensure `tw.Rendition` is set correctly before rendering begins (`stream.go`). +- **Symbol Mismatch**: Using minimal `tw.Symbols` (e.g., `StyleASCII`) with complex `Borders` settings may lead to visual artifacts; test with matching symbol sets (`tw/symbols.go`). + +### 4.3. Alignment +Alignment controls the positioning of text within table cells, now configurable per section (Header, Row, Footer) with both global and per-column options for greater precision. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" // Assuming ALIGN_CENTER etc. were constants here + "os" +) + +const ( // Mocking v0.0.5 constants for example completeness + ALIGN_CENTER = 1 // Example values + ALIGN_LEFT = 2 +) + + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetAlignment(ALIGN_CENTER) // Applied to data rows + // table.SetHeaderAlignment(ALIGN_LEFT) // Applied to header + // No specific footer alignment setter + table.SetHeader([]string{"Header1", "Header2"}) + table.Append([]string{"Cell1", "Cell2"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + cfg := tablewriter.Config{ + Header: tw.CellConfig{ + Alignment: tw.CellAlignment{Global: tw.AlignLeft}, + }, + Row: tw.CellConfig{ + Alignment: tw.CellAlignment{ + Global: tw.AlignCenter, + PerColumn: []tw.Align{tw.AlignLeft, tw.AlignRight}, // Col 0 left, Col 1 right + }, + }, + Footer: tw.CellConfig{ + Alignment: tw.CellAlignment{Global: tw.AlignRight}, + }, + } + table := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfg)) + + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Footer("", "Active") // Ensure footer has content to show alignment + table.Render() +} +``` + +**Output:** +``` +┌───────┬────────┐ +│ NAME │ STATUS │ +├───────┼────────┤ +│ Node1 │ Ready │ +├───────┼────────┤ +│ │ Active │ +└───────┴────────┘ +``` + +**Key Changes**: +- **Deprecated Methods**: `SetAlignment` and `SetHeaderAlignment` are replaced by `WithRowAlignment`, `WithHeaderAlignment`, `WithFooterAlignment`, or direct `Config` settings (`config.go`). These old methods are retained in `deprecated.go` for compatibility but should be migrated. +- **Alignment Structure**: Alignment is managed within `tw.CellConfig.Alignment` (`tw/cell.go:CellAlignment`), which includes: + - `Global`: A single `tw.Align` value applied to all cells in the section (`tw.AlignLeft`, `tw.AlignCenter`, `tw.AlignRight`, `tw.AlignNone`). + - `PerColumn`: A slice of `tw.Align` values for column-specific alignment, overriding `Global` for specified columns. +- **Footer Alignment**: v1.0.x introduces explicit footer alignment via `WithFooterAlignment` or `Config.Footer.Alignment`, addressing v0.0.5’s lack of footer-specific control (`config.go`). +- **Type Safety**: `tw.Align` string constants replace v0.0.5’s integer constants (e.g., `ALIGN_CENTER`), improving clarity and reducing errors (`tw/types.go`). +- **Builder Support**: `ConfigBuilder` provides `Alignment()` methods for each section. `ForColumn(idx).WithAlignment()` applies alignment to a specific column across all sections (`config.go:ConfigBuilder`, `config.go:ColumnConfigBuilder`). +- **Deprecated Fields**: `tw.CellConfig.ColumnAligns` (slice) and `tw.CellFormatting.Alignment` (single value) are supported for backward compatibility but should be migrated to `tw.CellAlignment.Global` and `tw.CellAlignment.PerColumn` (`tw/cell.go`). + +**Migration Tips**: +- Replace `SetAlignment(ALIGN_X)` with `WithRowAlignment(tw.AlignX)` or `Config.Row.Alignment.Global = tw.AlignX` to set row alignment (`config.go`). +- Use `WithHeaderAlignment(tw.AlignX)` for headers and `WithFooterAlignment(tw.AlignX)` for footers to maintain or adjust v0.0.5 behavior (`config.go`). +- Specify per-column alignments with `ConfigBuilder.Row().Alignment().WithPerColumn([]tw.Align{...})` or by setting `Config.Row.Alignment.PerColumn` for fine-grained control (`config.go`). +- Use `ConfigBuilder.ForColumn(idx).WithAlignment(tw.AlignX)` to apply consistent alignment to a specific column across all sections (Header, Row, Footer) (`config.go`). +- Verify alignment settings against defaults (`Header: tw.AlignCenter`, `Row: tw.AlignLeft`, `Footer: tw.AlignRight`) to ensure expected output (`config.go:defaultConfig`). +- Test alignment with varied cell content lengths to confirm readability, especially when combined with wrapping or padding settings (`zoo.go:prepareContent`). + +**Potential Pitfalls**: +- **Alignment Precedence**: `PerColumn` settings override `Global` within a section; ensure column-specific alignments are intentional (`tw/cell.go:CellAlignment`). +- **Deprecated Fields**: Relying on `ColumnAligns` or `tw.CellFormatting.Alignment` is temporary; migrate to `tw.CellAlignment` to avoid future issues (`tw/cell.go`). +- **Cell Count Mismatch**: Rows or footers with fewer cells than headers can cause alignment errors; pad with empty strings (`""`) to match column count (`zoo.go`). +- **Streaming Width Impact**: In streaming mode, alignment depends on fixed column widths set by `Config.Widths`; narrow widths may truncate content, misaligning text (`stream.go:streamCalculateWidths`). +- **Default Misalignment**: The default `Footer.Alignment.Global = tw.AlignRight` differs from rows (`tw.AlignLeft`); explicitly set `WithFooterAlignment` if consistency is needed (`config.go`). + +### 4.4. Auto-Formatting (Header Title Case) +Auto-formatting applies transformations like title case to cell content, primarily for headers to enhance readability, but it can be enabled for rows or footers in v1.0.x. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetAutoFormatHeaders(true) // Default: true; applies title case to headers + table.SetHeader([]string{"col_one", "status_report"}) + table.Append([]string{"Node1", "Ready"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + // Using Direct Config Struct to turn OFF default AutoFormat for Header + cfg := tablewriter.Config{ + Header: tw.CellConfig{Formatting: tw.CellFormatting{AutoFormat: tw.Off}}, // Turn OFF title case for headers + Row: tw.CellConfig{Formatting: tw.CellFormatting{AutoFormat: tw.Off}}, // No formatting for rows (default) + Footer: tw.CellConfig{Formatting: tw.CellFormatting{AutoFormat: tw.Off}}, // No formatting for footers (default) + } + tableNoAutoFormat := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfg)) + + tableNoAutoFormat.Header("col_one", "status_report") // Stays as "col_one", "status_report" + tableNoAutoFormat.Append("Node1", "Ready") + tableNoAutoFormat.Render() + + // Using Option Function for Headers (default is ON, this makes it explicit) + tableWithAutoFormat := tablewriter.NewTable(os.Stdout, + tablewriter.WithHeaderAutoFormat(tw.On), // Explicitly enable title case (default behavior) + ) + + tableWithAutoFormat.Header("col_one", "status_report") // Becomes "COL ONE", "STATUS REPORT" + tableWithAutoFormat.Append("Node1", "Ready") + tableWithAutoFormat.Render() +} +``` + +**Output:** +``` +┌─────────┬───────────────┐ +│ col_one │ status_report │ +├─────────┼───────────────┤ +│ Node1 │ Ready │ +└─────────┴───────────────┘ +┌─────────┬───────────────┐ +│ COL ONE │ STATUS REPORT │ +├─────────┼───────────────┤ +│ Node1 │ Ready │ +└─────────┴───────────────┘ +``` + +**Key Changes**: +- **Method**: `SetAutoFormatHeaders` is replaced by `Config.Header.Formatting.AutoFormat`, or equivalent builder methods (`config.go`). +- **Extended Scope**: Auto-formatting can now be applied to rows and footers via `Config.Row.Formatting.AutoFormat` and `Config.Footer.Formatting.AutoFormat`, unlike v0.0.5’s header-only support (`tw/cell.go`). +- **Type Safety**: `tw.State` (`tw.On`, `tw.Off`, `tw.Unknown`) controls formatting state, replacing boolean flags (`tw/state.go`). +- **Behavior**: When `tw.On`, the `tw.Title` function converts text to uppercase and replaces underscores and some periods with spaces (e.g., "col_one" → "COL ONE") (`tw/fn.go:Title`, `zoo.go:prepareContent`). +- **Defaults**: `Header.Formatting.AutoFormat = tw.On`, `Row.Formatting.AutoFormat = tw.Off`, `Footer.Formatting.AutoFormat = tw.Off` (`config.go:defaultConfig`). + +**Migration Tips**: +- To maintain v0.0.5’s default header title case behavior, no explicit action is needed as `WithHeaderAutoFormat(tw.On)` is the default. If you were using `SetAutoFormatHeaders(false)`, you'd use `WithHeaderAutoFormat(tw.Off)`. +- Explicitly set `WithRowAutoFormat(tw.Off)` or `WithFooterAutoFormat(tw.Off)` if you want to ensure rows and footers remain unformatted, as v1.0.x allows enabling formatting for these sections (`config.go`). +- Use `ConfigBuilder.Header().Formatting().WithAutoFormat(tw.State)` for precise control over formatting per section (`config.go`). +- Test header output with underscores or periods (e.g., "my_column") to verify title case transformation meets expectations. +- For custom formatting beyond title case (e.g., custom capitalization), use `tw.CellFilter` instead of `AutoFormat` (`tw/cell.go`). + +**Potential Pitfalls**: +- **Default Header Formatting**: `Header.Formatting.AutoFormat = tw.On` by default may unexpectedly alter header text (e.g., "col_one" → "COL ONE"); disable with `WithHeaderAutoFormat(tw.Off)` if raw headers are preferred (`config.go`). +- **Row/Footer Formatting**: Enabling `AutoFormat` for rows or footers (not default) applies title case, which may not suit data content; verify with `tw.Off` unless intended (`tw/cell.go`). +- **Filter Conflicts**: Combining `AutoFormat` with `tw.CellFilter` can lead to overlapping transformations; prioritize filters for complex formatting (`zoo.go:prepareContent`). +- **Performance Overhead**: Auto-formatting large datasets may add minor processing time; disable for performance-critical applications (`zoo.go`). + +### 4.5. Text Wrapping +Text wrapping determines how long cell content is handled within width constraints, offering more options in v1.0.x compared to v0.0.5’s binary toggle. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetAutoWrapText(true) // Enable normal word wrapping + // table.SetAutoWrapText(false) // Disable wrapping + table.SetHeader([]string{"Long Header Text Example", "Status"}) + table.Append([]string{"This is some very long cell content that might wrap", "Ready"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.WrapNormal etc. + "os" +) + +func main() { + // Using Option Functions for Quick Wrapping Settings on a specific section (e.g., Row) + // To actually see wrapping, a MaxWidth for the table or columns is needed. + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithRowAutoWrap(tw.WrapNormal), // Set row wrapping + tablewriter.WithHeaderAutoWrap(tw.WrapTruncate), // Header truncates (default) + tablewriter.WithMaxWidth(30), // Force wrapping by setting table max width + ) + table.Header("Long Header Text", "Status") + table.Append("This is a very long cell content", "Ready") + table.Footer("Summary", "Active") + table.Render() + + // For more fine-grained control (e.g., different wrapping for header, row, footer): + cfgBuilder := tablewriter.NewConfigBuilder() + cfgBuilder.Header().Formatting().WithAutoWrap(tw.WrapTruncate) // Header: Truncate + cfgBuilder.Row().Formatting().WithAutoWrap(tw.WrapNormal) // Row: Normal wrap + cfgBuilder.Footer().Formatting().WithAutoWrap(tw.WrapBreak) // Footer: Break words + cfgBuilder.WithMaxWidth(40) // Overall table width constraint + + tableFullCfg := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfgBuilder.Build())) + tableFullCfg.Header("Another Very Long Header Example That Will Be Truncated", "Info") + tableFullCfg.Append("This is an example of row content that should wrap normally based on available space.", "Detail") + tableFullCfg.Footer("FinalSummaryInformationThatMightBreakAcrossLines", "End") + tableFullCfg.Render() +} +``` + +**Output (tableOpt):** +``` +┌──────────────┬────────┐ +│ LONG HEADER… │ STATUS │ +├──────────────┼────────┤ +│ This is a │ Ready │ +│ very long │ │ +│ cell content │ │ +├──────────────┼────────┤ +│ Summary │ Active │ +└──────────────┴────────┘ +``` +*(Second table output will vary based on content and width)* + +**Key Changes**: +- **Method**: `SetAutoWrapText` is replaced by `Config.
.Formatting.AutoWrap` or specific `With
AutoWrap` options (`config.go`). +- **Wrapping Modes**: `int` constants for `AutoWrap` (e.g., `tw.WrapNone`, `tw.WrapNormal`, `tw.WrapTruncate`, `tw.WrapBreak`) replace v0.0.5’s binary toggle (`tw/tw.go`). +- **Section-Specific Control**: Wrapping is configurable per section (Header, Row, Footer), unlike v0.0.5’s global setting (`tw/cell.go`). +- **Defaults**: `Header: tw.WrapTruncate`, `Row: tw.WrapNormal`, `Footer: tw.WrapNormal` (`config.go:defaultConfig`). +- **Width Dependency**: Wrapping behavior relies on width constraints set by `Config.Widths` (fixed column widths), `Config.
.ColMaxWidths` (max content width), or `Config.MaxWidth` (total table width) (`zoo.go:calculateContentMaxWidth`, `zoo.go:prepareContent`). + +**Migration Tips**: +- Replace `SetAutoWrapText(true)` with `WithRowAutoWrap(tw.WrapNormal)` to maintain v0.0.5’s default wrapping for rows (`config.go`). +- Use `WithHeaderAutoWrap(tw.WrapTruncate)` to align with v1.0.x’s default header behavior, ensuring long headers are truncated (`config.go`). +- Set `Config.Widths` or `Config.MaxWidth` explicitly to enforce wrapping, as unconstrained widths may prevent wrapping (`config.go`). +- Use `ConfigBuilder.
().Formatting().WithAutoWrap(int_wrap_mode)` for precise control over wrapping per section (`config.go`). +- Test wrapping with varied content lengths (e.g., short and long text) to ensure readability and proper width allocation. +- Consider `tw.WrapNormal` for data rows to preserve content integrity, reserving `tw.WrapTruncate` for headers or footers (`tw/tw.go`). + +**Potential Pitfalls**: +- **Missing Width Constraints**: Without `Config.Widths`, `ColMaxWidths`, or `MaxWidth`, wrapping may not occur, leading to overflow; always define width limits for wrapping (`zoo.go`). +- **Streaming Width Impact**: In streaming mode, wrapping depends on fixed widths set at `Start()`; narrow widths may truncate content excessively (`stream.go:streamCalculateWidths`). +- **Truncation Data Loss**: `tw.WrapTruncate` may obscure critical data in rows; use `tw.WrapNormal` or wider columns to retain content (`tw/tw.go`). +- **Performance Overhead**: Wrapping large datasets with `tw.WrapNormal` or `tw.WrapBreak` can add processing time; optimize widths for performance-critical applications (`zoo.go:prepareContent`). +- **Inconsistent Section Wrapping**: Default wrapping differs (`Header: tw.WrapTruncate`, `Row/Footer: tw.WrapNormal`); align settings if uniform behavior is needed (`config.go`). + +### 4.6. Padding +Padding adds spacing within cells, enhancing readability and affecting cell width calculations. v1.0.x introduces granular, per-side padding, replacing v0.0.5’s single inter-column padding control. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetTablePadding("\t") // Set inter-column space character when borders are off + // Default: single space within cells + table.SetHeader([]string{"Header1"}) + table.Append([]string{"Cell1"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + // Using Direct Config Struct + cfg := tablewriter.Config{ + Header: tw.CellConfig{ + Padding: tw.CellPadding{ + Global: tw.Padding{Left: "[", Right: "]", Top: "-", Bottom: "-"}, // Padding for all header cells + PerColumn: []tw.Padding{ // Specific padding for header column 0 + {Left: ">>", Right: "<<", Top: "=", Bottom: "="}, // Overrides Global for column 0 + }, + }, + }, + Row: tw.CellConfig{ + Padding: tw.CellPadding{ + Global: tw.PaddingDefault, // One space left/right for all row cells + }, + }, + Footer: tw.CellConfig{ + Padding: tw.CellPadding{ + Global: tw.Padding{Top: "~", Bottom: "~"}, // Top/bottom padding for all footer cells + }, + }, + } + table := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfg)) + + table.Header("Name", "Status") // Two columns + table.Append("Node1", "Ready") + table.Footer("End", "Active") + table.Render() +} +``` + +**Output:** +``` +┌────────┬────────┐ +│========│[------]│ +│>>NAME<<│[STATUS]│ +│========│[------]│ +├────────┼────────┤ +│ Node1 │ Ready │ +│~~~~~~~~│~~~~~~~~│ +│End │Active │ +│~~~~~~~~│~~~~~~~~│ +└────────┴────────┘ +``` + +**Key Changes**: +- **No Direct Equivalent for `SetTablePadding`**: `SetTablePadding` controlled inter-column spacing when borders were off in v0.0.5; v1.0.x has no direct equivalent for *inter-column* spacing separate from cell padding. Inter-column visual separation is now primarily handled by `tw.Rendition.Settings.Separators.BetweenColumns` and the chosen `tw.Symbols`. +- **Granular Cell Padding**: `tw.CellPadding` (`tw/cell.go:CellPadding`) supports: + - `Global`: A `tw.Padding` struct with `Left`, `Right`, `Top`, `Bottom` strings and an `Overwrite` flag (`tw/types.go:Padding`). This padding is *inside* the cell. + - `PerColumn`: A slice of `tw.Padding` for column-specific padding, overriding `Global` for specified columns. +- **Per-Side Control**: `Top` and `Bottom` padding add extra lines *within* cells, unlike v0.0.5’s left/right-only spacing (`zoo.go:prepareContent`). +- **Defaults**: `tw.PaddingDefault` is `{Left: " ", Right: " "}` for all sections (applied inside cells); `Top` and `Bottom` are empty by default (`tw/preset.go`). +- **Width Impact**: Cell padding contributes to column widths, calculated in `Config.Widths` (`zoo.go:calculateAndNormalizeWidths`). +- **Presets**: `tw.PaddingNone` (`{Left: "", Right: "", Top: "", Bottom: "", Overwrite: true}`) removes padding for tight layouts (`tw/preset.go`). + +**Migration Tips**: +- To achieve spacing similar to `SetTablePadding("\t")` when borders are off, you would set cell padding: `WithPadding(tw.Padding{Left: "\t", Right: "\t"})`. If you truly mean space *between* columns and not *inside* cells, ensure `tw.Rendition.Settings.Separators.BetweenColumns` is `tw.On` and customize `tw.Symbols.Column()` if needed. +- Use `tw.PaddingNone` (e.g., via `ConfigBuilder.
().Padding().WithGlobal(tw.PaddingNone)`) for no cell padding. +- Set `Top` and `Bottom` padding for vertical spacing *within* cells, enhancing readability for multi-line content (`tw/types.go`). +- Use `ConfigBuilder.
().Padding().WithPerColumn` for column-specific padding to differentiate sections or columns (`config.go`). +- Test padding with varied content and widths to ensure proper alignment and spacing, especially with wrapping enabled (`zoo.go`). +- Combine padding with `Config.Widths` or `ColMaxWidths` to control total cell size (`config.go`). + +**Potential Pitfalls**: +- **Inter-Column Spacing vs. Cell Padding**: Be clear whether you want space *between* columns (separators) or *inside* cells (padding). `SetTablePadding` was ambiguous; v1.0.x distinguishes these. +- **Width Inflation**: Cell padding increases column widths, potentially exceeding `Config.MaxWidth` or causing truncation in streaming; adjust `Config.Widths` accordingly (`zoo.go`). +- **Top/Bottom Padding**: Non-empty `Top` or `Bottom` padding adds vertical lines *within* cells, increasing cell height; use sparingly for dense tables (`zoo.go:prepareContent`). +- **Streaming Constraints**: Padding is fixed in streaming mode after `Start()`; ensure `Config.Widths` accommodates padding (`stream.go`). +- **Default Padding**: `tw.PaddingDefault` adds spaces *inside* cells; set `tw.PaddingNone` for no internal cell padding (`tw/preset.go`). + +### 4.7. Column Widths (Fixed Widths and Max Content Widths) +Column width control in v1.0.x is more sophisticated, offering fixed widths, maximum content widths, and overall table width constraints, replacing v0.0.5’s limited `SetColMinWidth`. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetColMinWidth(0, 10) // Set minimum width for column 0 + table.SetHeader([]string{"Header1", "Header2"}) + table.Append([]string{"Cell1-Content", "Cell2-Content"}) + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + // Direct Config for Width Control + cfg := tablewriter.Config{ + Widths: tw.CellWidth{ // Fixed total column widths (content + padding) + Global: 20, // Default fixed width for all columns + PerColumn: tw.NewMapper[int, int]().Set(0, 15), // Column 0 fixed at 15 + }, + Header: tw.CellConfig{ + ColMaxWidths: tw.CellWidth{ // Max content width (excluding padding) for header cells + Global: 15, // Max content width for all header cells + PerColumn: tw.NewMapper[int, int]().Set(0, 10), // Header Col 0 max content at 10 + }, + // Default header padding is " " on left/right, so content 10 + padding 2 = 12. + // If Widths.PerColumn[0] is 15, there's space. + }, + Row: tw.CellConfig{ + ColMaxWidths: tw.CellWidth{Global: 18}, // Max content width for row cells (18 + default padding 2 = 20) + }, + MaxWidth: 80, // Constrain total table width (optional, columns might shrink) + } + tableWithCfg := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfg)) + tableWithCfg.Header("Very Long Header Name", "Status Information") + tableWithCfg.Append("Some long content for the first column", "Ready") + tableWithCfg.Render() + + // Option Functions for Width Settings + tableWithOpts := tablewriter.NewTable(os.Stdout, + tablewriter.WithColumnMax(20), // Sets Config.Widths.Global (fixed total col width) + tablewriter.WithColumnWidths(tw.NewMapper[int, int]().Set(0, 15)), // Sets Config.Widths.PerColumn for col 0 + tablewriter.WithMaxWidth(80), // Sets Config.MaxWidth + // For max content width per section, you'd use WithHeaderConfig, WithRowConfig, etc. + // e.g., tablewriter.WithRowMaxWidth(18) // Sets Config.Row.ColMaxWidths.Global + ) + tableWithOpts.Header("Long Header", "Status") + tableWithOpts.Append("Long Content", "Ready") + tableWithOpts.Render() +} +``` + +**Output (tableWithCfg - illustrative, exact wrapping depends on content and full config):** +``` +┌───────────┬──────────────────┐ +│ VERY LONG │ STATUS INFORMAT… │ +│ HEADER NA…│ │ +├───────────┼──────────────────┤ +│ Some long │ Ready │ +│ content f…│ │ +└───────────┴──────────────────┘ +``` + +**Key Changes**: +- **Enhanced Width System**: v1.0.x introduces three levels of width control, replacing `SetColMinWidth` (`config.go`): + - **Config.Widths**: Sets fixed total widths (content + padding) for columns, applied globally or per-column (`tw.CellWidth`). + - `Global`: Default fixed width for all columns. + - `PerColumn`: `tw.Mapper[int, int]` for specific column widths. + - **Config.
.ColMaxWidths**: Sets maximum content widths (excluding padding) for a section (Header, Row, Footer) (`tw.CellWidth`). + - `Global`: Max content width for all cells in the section. + - `PerColumn`: `tw.Mapper[int, int]` for specific columns in the section. + - **Config.MaxWidth**: Constrains the total table width, shrinking columns proportionally if needed (`config.go`). +- **Streaming Support**: In streaming mode, `Config.Widths` fixes column widths at `Start()`; `ColMaxWidths` is used only for wrapping/truncation (`stream.go:streamCalculateWidths`). +- **Calculation Logic**: Widths are computed by `calculateAndNormalizeWidths` in batch mode and `streamCalculateWidths` in streaming mode, considering content, padding, and constraints (`zoo.go`, `stream.go`). +- **Deprecated Approach**: `SetColMinWidth` is replaced by `Config.Widths.PerColumn` or `Config.
.ColMaxWidths.PerColumn` for more precise control (`deprecated.go`). + +**Migration Tips**: +- Replace `SetColMinWidth(col, w)` with `WithColumnWidths(tw.NewMapper[int, int]().Set(col, w))` for fixed column widths or `Config.
.ColMaxWidths.PerColumn` for content width limits (`config.go`). +- Use `Config.Widths.Global` or `WithColumnMax(w)` to set a default fixed width for all columns, ensuring consistency (`tablewriter.go`). +- Apply `Config.MaxWidth` to constrain total table width, especially for wide datasets (`config.go`). +- Use `ConfigBuilder.ForColumn(idx).WithMaxWidth(w)` to set per-column content width limits across sections (`config.go`). *(Note: This sets it for Header, Row, and Footer)* +- In streaming mode, set `Config.Widths` before `Start()` to fix widths, avoiding content-based sizing (`stream.go`). +- Test width settings with varied content to ensure wrapping and truncation behave as expected (`zoo.go`). + +**Potential Pitfalls**: +- **Width Precedence**: `Config.Widths.PerColumn` overrides `Widths.Global`; `ColMaxWidths` applies *within* those fixed total widths for content wrapping/truncation (`zoo.go`). +- **Streaming Width Fixing**: Widths are locked after `Start()` in streaming; inconsistent data may cause truncation (`stream.go`). +- **Padding Impact**: Padding adds to total width when considering `Config.Widths`; account for `tw.CellPadding` when setting fixed column widths (`zoo.go`). +- **MaxWidth Shrinkage**: `Config.MaxWidth` may shrink columns unevenly; test with `MaxWidth` to avoid cramped layouts (`zoo.go`). +- **No Width Constraints**: Without `Widths` or `MaxWidth`, columns size to content, potentially causing overflow; define limits (`zoo.go`). + +### 4.8. Colors +Colors in v0.0.5 were applied via specific color-setting methods, while v1.0.x embeds ANSI escape codes in cell content or uses data-driven formatting for greater flexibility. + +**Old (v0.0.5):** +```go +package main +// Assuming tablewriter.Colors and color constants existed in v0.0.5 +// This is a mock representation as the actual v0.0.5 definitions are not provided. +// import "github.com/olekukonko/tablewriter" +// import "os" + +// type Colors []interface{} // Mock +// const ( +// Bold = 1; FgGreenColor = 2; FgRedColor = 3 // Mock constants +// ) + +func main() { + // table := tablewriter.NewWriter(os.Stdout) + // table.SetColumnColor( + // tablewriter.Colors{tablewriter.Bold, tablewriter.FgGreenColor}, // Column 0 + // tablewriter.Colors{tablewriter.FgRedColor}, // Column 1 + // ) + // table.SetHeader([]string{"Name", "Status"}) + // table.Append([]string{"Node1", "Ready"}) + // table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.Formatter + "os" +) + +// Direct ANSI Code Embedding +const ( + Reset = "\033[0m" + Bold = "\033[1m" + FgGreen = "\033[32m" + FgRed = "\033[31m" +) + +// Using tw.Formatter for Custom Types +type Status string + +func (s Status) Format() string { // Implements tw.Formatter + color := FgGreen + if s == "Error" || s == "Inactive" { + color = FgRed + } + return color + string(s) + Reset +} + +func main() { + // Example 1: Direct ANSI embedding + tableDirectANSI := tablewriter.NewTable(os.Stdout, + tablewriter.WithHeaderAutoFormat(tw.Off), // Keep header text as is for coloring + ) + tableDirectANSI.Header(Bold+FgGreen+"Name"+Reset, Bold+FgRed+"Status"+Reset) + tableDirectANSI.Append([]any{"Node1", FgGreen + "Ready" + Reset}) + tableDirectANSI.Append([]any{"Node2", FgRed + "Error" + Reset}) + tableDirectANSI.Render() + + fmt.Println("\n--- Table with Formatter for Colors ---") + + // Example 2: Using tw.Formatter + tableFormatter := tablewriter.NewTable(os.Stdout) + tableFormatter.Header("Name", "Status") // AutoFormat will apply to "NAME", "STATUS" + tableFormatter.Append([]any{"Alice", Status("Active")}) + tableFormatter.Append([]any{"Bob", Status("Inactive")}) + tableFormatter.Render() + + fmt.Println("\n--- Table with CellFilter for Colors ---") + // Example 3: Using CellFilter + tableWithFilters := tablewriter.NewTable(os.Stdout, + tablewriter.WithConfig( + tablewriter.NewConfigBuilder(). + Row(). + Filter(). + WithPerColumn([]func(string) string{ + nil, // No filter for Item column + func(s string) string { // Status column: apply color + if s == "Ready" || s == "Active" { + return FgGreen + s + Reset + } + return FgRed + s + Reset + }, + }). + Build(). // Return to RowConfigBuilder + Build(). // Return to ConfigBuilder + Build(), // Finalize Config + ), + ) + tableWithFilters.Header("Item", "Availability") + tableWithFilters.Append("ItemA", "Ready") + tableWithFilters.Append("ItemB", "Unavailable") + tableWithFilters.Render() +} +``` + +**Output (Text Approximation, Colors Not Shown):** +``` +┌──────┬────────┐ +│ Name │ Status │ +├──────┼────────┤ +│Node1 │ Ready │ +│Node2 │ Error │ +└──────┴────────┘ + +--- Table with Formatter for Colors --- +┌───────┬──────────┐ +│ NAME │ STATUS │ +├───────┼──────────┤ +│ Alice │ Active │ +│ Bob │ Inactive │ +└───────┴──────────┘ + +--- Table with CellFilter for Colors --- +┌───────┬────────────┐ +│ ITEM │ AVAILABILI │ +│ │ TY │ +├───────┼────────────┤ +│ ItemA │ Ready │ +│ ItemB │ Unavailabl │ +│ │ e │ +└───────┴────────────┘ +``` + +**Key Changes**: +- **Removed Color Methods**: `SetColumnColor`, `SetHeaderColor`, and `SetFooterColor` are removed; colors are now applied by embedding ANSI escape codes in cell content or via data-driven mechanisms (`tablewriter.go`). +- **Flexible Coloring Options**: + - **Direct ANSI Codes**: Embed codes (e.g., `\033[32m` for green) in strings for manual control (`zoo.go:convertCellsToStrings`). + - **tw.Formatter**: Implement `Format() string` on custom types to control cell output, including colors (`tw/types.go:Formatter`). + - **tw.CellFilter**: Use `Config.
.Filter.Global` or `PerColumn` to apply transformations like coloring dynamically (`tw/cell.go:CellFilter`). +- **Width Handling**: `tw.DisplayWidth()` correctly calculates display width of ANSI-coded strings, ignoring escape sequences (`tw/fn.go:DisplayWidth`). +- **No Built-In Color Presets**: Unlike v0.0.5’s potential `tablewriter.Colors`, v1.0.x requires manual ANSI code management or external libraries for color constants. + +**Migration Tips**: +- Replace `SetColumnColor` with direct ANSI code embedding for simple cases (e.g., `FgGreen+"text"+Reset`) (`zoo.go`). +- Implement `tw.Formatter` on custom types for reusable, semantic color logic (e.g., `Status` type above) (`tw/types.go`). +- Use `ConfigBuilder.
().Filter().WithPerColumn` to apply color filters to specific columns, mimicking v0.0.5’s per-column coloring (`config.go`). +- Define ANSI constants in your codebase or use a library (e.g., `github.com/fatih/color`) to simplify color management. +- Test colored output in your target terminal to ensure ANSI codes render correctly. +- Combine filters with `AutoFormat` or wrapping for consistent styling (`zoo.go:prepareContent`). + +**Potential Pitfalls**: +- **Terminal Support**: Some terminals may not support ANSI codes, causing artifacts; test in your environment or provide a non-colored fallback. +- **Filter Overlap**: Combining `tw.CellFilter` with `AutoFormat` or other transformations can lead to unexpected results; prioritize filters for coloring (`zoo.go`). +- **Width Miscalculation**: Incorrect ANSI code handling (e.g., missing `Reset`) can skew width calculations; use `tw.DisplayWidth` (`tw/fn.go`). +- **Streaming Consistency**: In streaming mode, ensure color codes are applied consistently across rows to avoid visual discrepancies (`stream.go`). +- **Performance**: Applying filters to large datasets may add overhead; optimize filter logic for efficiency (`zoo.go`). + +## Advanced Features in v1.0.x + +v1.0.x introduces several advanced features that enhance table functionality beyond v0.0.5’s capabilities. This section covers cell merging, captions, filters, stringers, and performance optimizations, providing migration guidance and examples for leveraging these features. + +### 5. Cell Merging +Cell merging combines adjacent cells with identical content, improving readability for grouped data. v1.0.x expands merging options beyond v0.0.5’s horizontal merging. + +**Old (v0.0.5):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewWriter(os.Stdout) + // table.SetAutoMergeCells(true) // Enable horizontal merging + table.SetHeader([]string{"Category", "Item", "Notes"}) + table.Append([]string{"Fruit", "Apple", "Red"}) + table.Append([]string{"Fruit", "Apple", "Green"}) // "Apple" might merge if SetAutoMergeCells was on + table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + // Horizontal Merging (Similar to v0.0.5) + tableH := tablewriter.NewTable(os.Stdout, + tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}}}), + tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{Symbols: tw.NewSymbols(tw.StyleASCII)})), // Specify renderer for symbols + ) + tableH.Header("Category", "Item", "Item", "Notes") // Note: Two "Item" headers for demo + tableH.Append("Fruit", "Apple", "Apple", "Red") // "Apple" cells merge + tableH.Render() + + // Vertical Merging + tableV := tablewriter.NewTable(os.Stdout, + tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeVertical}}}), + tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{Symbols: tw.NewSymbols(tw.StyleASCII)})), + ) + tableV.Header("User", "Permission") + tableV.Append("Alice", "Read") + tableV.Append("Alice", "Write") // "Alice" cells merge vertically + tableV.Append("Bob", "Read") + tableV.Render() + + // Hierarchical Merging + tableHier := tablewriter.NewTable(os.Stdout, + tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHierarchical}}}), + tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{Symbols: tw.NewSymbols(tw.StyleASCII)})), + ) + tableHier.Header("Group", "SubGroup", "Item") + tableHier.Append("Tech", "CPU", "i7") + tableHier.Append("Tech", "CPU", "i9") // "Tech" and "CPU" merge + tableHier.Append("Tech", "RAM", "16GB") // "Tech" merges, "RAM" is new + tableHier.Append("Office", "CPU", "i5") // "Office" is new + tableHier.Render() +} +``` + +**Output (Horizontal):** +``` ++----------+-------+-------+-------+ +| CATEGORY | ITEM | ITEM | NOTES | ++----------+-------+-------+-------+ +| Fruit | Apple | Red | ++----------+---------------+-------+ +``` + +**Output (Vertical):** +``` ++-------+------------+ +| USER | PERMISSION | ++-------+------------+ +| Alice | Read | +| | Write | ++-------+------------+ +| Bob | Read | ++-------+------------+ +``` + +**Output (Hierarchical):** +``` ++---------+----------+------+ +| GROUP | SUBGROUP | ITEM | ++---------+----------+------+ +| Tech | CPU | i7 | +| | | i9 | +| +----------+------+ +| | RAM | 16GB | ++---------+----------+------+ +| Office | CPU | i5 | ++---------+----------+------+ +``` + +**Key Changes**: +- **Method**: `SetAutoMergeCells` is replaced by `WithRowMergeMode(int_merge_mode)` or `Config.Row.Formatting.MergeMode` (`config.go`). Uses `tw.Merge...` constants. +- **Merge Modes**: `tw.MergeMode` constants (`tw.MergeNone`, `tw.MergeHorizontal`, `tw.MergeVertical`, `tw.MergeHierarchical`) define behavior (`tw/tw.go`). +- **Section-Specific**: Merging can be applied to `Header`, `Row`, or `Footer` via `Config.
.Formatting.MergeMode` (`tw/cell.go`). +- **Processing**: Merging is handled during content preparation (`zoo.go:prepareWithMerges`, `zoo.go:applyVerticalMerges`, `zoo.go:applyHierarchicalMerges`). +- **Width Adjustment**: Horizontal merging adjusts column widths (`zoo.go:applyHorizontalMergeWidths`). +- **Renderer Support**: `tw.MergeState` in `tw.CellContext` ensures correct border drawing for merged cells (`tw/cell.go:CellContext`). +- **Streaming Limitation**: Streaming mode supports only simple horizontal merging due to fixed widths (`stream.go:streamAppendRow`). + +**Migration Tips**: +- Replace `SetAutoMergeCells(true)` with `WithRowMergeMode(tw.MergeHorizontal)` to maintain v0.0.5’s horizontal merging behavior (`config.go`). +- Use `tw.MergeVertical` for vertical grouping (e.g., repeated user names) or `tw.MergeHierarchical` for nested data structures (`tw/tw.go`). +- Apply merging to specific sections via `ConfigBuilder.
().Formatting().WithMergeMode(int_merge_mode)` (`config.go`). +- Test merging with sample data to verify visual output, especially for hierarchical merging with complex datasets. +- In streaming mode, ensure `Config.Widths` supports merged cell widths to avoid truncation (`stream.go`). +- Use `WithDebug(true)` to log merge processing for troubleshooting (`config.go`). + +**Potential Pitfalls**: +- **Streaming Restrictions**: Vertical and hierarchical merging are unsupported in streaming mode; use batch mode for these features (`stream.go`). +- **Width Misalignment**: Merged cells may require wider columns; adjust `Config.Widths` or `ColMaxWidths` (`zoo.go`). +- **Data Dependency**: Merging requires identical content; case or whitespace differences prevent merging (`zoo.go`). +- **Renderer Errors**: Incorrect `tw.MergeState` handling in custom renderers can break merged cell borders; test thoroughly (`tw/cell.go`). +- **Performance**: Hierarchical merging with large datasets may slow rendering; optimize data or limit merging (`zoo.go`). + +### 6. Table Captions +Captions add descriptive text above or below the table, a new feature in v1.0.x not present in v0.0.5. + +**Old (v0.0.5):** +```go +package main +// No direct caption support in v0.0.5. Users might have printed text manually. +// import "github.com/olekukonko/tablewriter" +// import "os" +// import "fmt" + +func main() { + // fmt.Println("Movie ratings.") // Manual caption + // table := tablewriter.NewWriter(os.Stdout) + // table.SetHeader([]string{"Name", "Sign", "Rating"}) + // table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout) + table.Caption(tw.Caption{ // tw/types.go:Caption + Text: "System Status Overview - A Very Long Caption Example To Demonstrate Wrapping Behavior", + Spot: tw.SpotTopCenter, // Placement: TopLeft, TopCenter, TopRight, BottomLeft, BottomCenter, BottomRight + Align: tw.AlignCenter, // Text alignment within caption width + Width: 30, // Fixed width for caption text wrapping; if 0, wraps to table width + }) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Append("SuperLongNodeNameHere", "ActiveNow") + table.Render() +} +``` + +**Output:** +``` + System Status Overview - A Very +Long Caption Example To Demonst… +┌─────────────────────┬──────────┐ +│ NAME │ STATUS │ +├─────────────────────┼──────────┤ +│ Node1 │ Ready │ +│ SuperLongNodeNameHe │ ActiveNo │ +│ re │ w │ +└─────────────────────┴──────────┘ +``` + +**Key Changes**: +- **New Feature**: `Table.Caption(tw.Caption)` introduces captions, absent in v0.0.5 (`tablewriter.go:Caption`). +- **Configuration**: `tw.Caption` (`tw/types.go:Caption`) includes: + - `Text`: Caption content. + - `Spot`: Placement (`tw.SpotTopLeft`, `tw.SpotBottomCenter`, etc.); defaults to `tw.SpotBottomCenter` if `tw.SpotNone`. + - `Align`: Text alignment (`tw.AlignLeft`, `tw.AlignCenter`, `tw.AlignRight`). + - `Width`: Optional fixed width for wrapping; defaults to table width. +- **Rendering**: Captions are rendered by `printTopBottomCaption` before or after the table based on `Spot` (`tablewriter.go:printTopBottomCaption`). +- **Streaming**: Captions are rendered during `Close()` in streaming mode if placed at the bottom (`stream.go`). + +**Migration Tips**: +- Add captions to enhance table context, especially for reports or documentation (`tw/types.go`). +- Use `tw.SpotTopCenter` for prominent placement above the table, aligning with common report formats. +- Set `Align` to match table aesthetics (e.g., `tw.AlignCenter` for balanced appearance). +- Specify `Width` for consistent wrapping, especially with long captions or narrow tables (`tablewriter.go`). +- Test caption placement and alignment with different table sizes to ensure readability. + +**Potential Pitfalls**: +- **Spot Default**: If `Spot` is `tw.SpotNone`, caption defaults to `tw.SpotBottomCenter`, which may surprise users expecting no caption (`tablewriter.go`). +- **Width Overflow**: Without `Width`, captions wrap to table width, potentially causing misalignment; set explicitly for control (`tw/types.go`). +- **Streaming Delay**: Bottom-placed captions in streaming mode appear only at `Close()`; ensure `Close()` is called (`stream.go`). +- **Alignment Confusion**: Caption `Align` is independent of table cell alignment; verify separately (`tw/cell.go`). + +### 7. Filters +Filters allow dynamic transformation of cell content during rendering, a new feature in v1.0.x for tasks like formatting, coloring, or sanitizing data. + +**Old (v0.0.5):** +```go +package main +// No direct support for cell content transformation in v0.0.5. +// Users would typically preprocess data before appending. +// import "github.com/olekukonko/tablewriter" +// import "os" +// import "strings" + +func main() { + // table := tablewriter.NewWriter(os.Stdout) + // table.SetHeader([]string{"Name", "Status"}) + // status := " Ready " + // preprocessedStatus := "Status: " + strings.TrimSpace(status) + // table.Append([]string{"Node1", preprocessedStatus}) + // table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.CellConfig etc. + "os" + "strings" +) + +func main() { + // Per-Column Filter for Specific Transformations + cfgBuilder := tablewriter.NewConfigBuilder() + cfgBuilder.Row().Filter().WithPerColumn([]func(string) string{ + nil, // No filter for Name column + func(s string) string { // Status column: prefix and trim + return "Status: " + strings.TrimSpace(s) + }, + }) + + tableWithFilter := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfgBuilder.Build())) + tableWithFilter.Header("Name", "Status") + tableWithFilter.Append("Node1", " Ready ") // Note the extra spaces + tableWithFilter.Append("Node2", "Pending") + tableWithFilter.Render() + + // Global filter example (applied to all cells in the Row section) + cfgGlobalFilter := tablewriter.NewConfigBuilder() + cfgGlobalFilter.Row().Filter().WithGlobal(func(s string) string { + return "[" + s + "]" // Wrap all row cells in brackets + }) + tableGlobalFilter := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfgGlobalFilter.Build())) + tableGlobalFilter.Header("Item", "Count") + tableGlobalFilter.Append("Apple", "5") + tableGlobalFilter.Render() +} +``` + +**Output (Per-Column Filter):** +``` +┌───────┬─────────────────┐ +│ NAME │ STATUS │ +├───────┼─────────────────┤ +│ Node1 │ Status: Ready │ +│ Node2 │ Status: Pending │ +└───────┴─────────────────┘ +``` + +**Output (Global Filter):** +``` +┌───────┬─────────┐ +│ ITEM │ COUNT │ +├───────┼─────────┤ +│[Apple]│ [5] │ +└───────┴─────────┘ +``` + +**Key Changes**: +- **New Feature**: `tw.CellFilter` (`tw/cell.go:CellFilter`) introduces: + - `Global`: A `func(s []string) []string` applied to entire rows (all cells in that row) of a section. + - `PerColumn`: A slice of `func(string) string` for column-specific transformations on individual cells. +- **Configuration**: Set via `Config.
.Filter` (`Header`, `Row`, `Footer`) using `ConfigBuilder` or direct `Config` (`config.go`). +- **Processing**: Filters are applied during content preparation, after `AutoFormat` but before rendering (`zoo.go:convertCellsToStrings` calls `prepareContent` which applies some transformations, filters are applied in `convertCellsToStrings` itself). +- **Use Cases**: Formatting (e.g., uppercase, prefixes), coloring (via ANSI codes), sanitization (e.g., removing sensitive data), or data normalization. + +**Migration Tips**: +- Use filters to replace manual content preprocessing in v0.0.5 (e.g., string manipulation before `Append`). +- Apply `Global` filters for uniform transformations across all cells of rows in a section (e.g., uppercasing all row data) (`tw/cell.go`). +- Use `PerColumn` filters for column-specific formatting (e.g., adding prefixes to status columns) (`config.go`). +- Combine filters with `tw.Formatter` for complex types or ANSI coloring for visual enhancements (`tw/cell.go`). +- Test filters with diverse inputs to ensure transformations preserve data integrity (`zoo.go`). + +**Potential Pitfalls**: +- **Filter Order**: Filters apply before some other transformations like padding and alignment; combining can lead to interactions. +- **Performance**: Complex filters on large datasets may slow rendering; optimize logic (`zoo.go`). +- **Nil Filters**: Unset filters (`nil`) are ignored, but incorrect indexing in `PerColumn` can skip columns (`tw/cell.go`). +- **Streaming Consistency**: Filters must be consistent in streaming mode, as widths are fixed at `Start()` (`stream.go`). + +### 8. Stringers and Caching +Stringers allow custom string conversion for data types, with v1.0.x adding caching for performance. + +**Old (v0.0.5):** +```go +package main +// v0.0.5 primarily relied on fmt.Stringer for custom types. +// import "fmt" +// import "github.com/olekukonko/tablewriter" +// import "os" + +// type MyCustomType struct { +// Value string +// } +// func (m MyCustomType) String() string { return "Formatted: " + m.Value } + +func main() { + // table := tablewriter.NewWriter(os.Stdout) + // table.SetHeader([]string{"Custom Data"}) + // table.Append([]string{MyCustomType{"test"}.String()}) // Manual call to String() + // table.Render() +} +``` + +**New (v1.0.x):** +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.Formatter + "os" + "strings" // For Person example +) + +// Example 1: Using WithStringer for general conversion +type CustomInt int + +func main() { + // Table with a general stringer (func(any) []string) + tableWithStringer := tablewriter.NewTable(os.Stdout, + tablewriter.WithStringer(func(v any) []string { // Must return []string + if ci, ok := v.(CustomInt); ok { + return []string{fmt.Sprintf("CustomInt Value: %d!", ci)} + } + return []string{fmt.Sprintf("Value: %v", v)} // Fallback + }), + tablewriter.WithDebug(true), // Enable caching if WithStringerCache() is also used + // tablewriter.WithStringerCache(), // Optional: enable caching + ) + tableWithStringer.Header("Data") + tableWithStringer.Append(123) + tableWithStringer.Append(CustomInt(456)) + tableWithStringer.Render() + + fmt.Println("\n--- Table with Type-Specific Stringer for Structs ---") + + // Example 2: Stringer for a specific struct type + type Person struct { + ID int + Name string + City string + } + + // Stringer for Person to produce 3 cells + personToStrings := func(p Person) []string { + return []string{ + fmt.Sprintf("ID: %d", p.ID), + p.Name, + strings.ToUpper(p.City), + } + } + + tablePersonStringer := tablewriter.NewTable(os.Stdout, + tablewriter.WithStringer(personToStrings), // Pass the type-specific function + ) + tablePersonStringer.Header("User ID", "Full Name", "Location") + tablePersonStringer.Append(Person{1, "Alice", "New York"}) + tablePersonStringer.Append(Person{2, "Bob", "London"}) + tablePersonStringer.Render() + + fmt.Println("\n--- Table with tw.Formatter ---") + // Example 3: Using tw.Formatter for types + type Product struct { + Name string + Price float64 + } + func (p Product) Format() string { // Implements tw.Formatter + return fmt.Sprintf("%s - $%.2f", p.Name, p.Price) + } + tableFormatter := tablewriter.NewTable(os.Stdout) + tableFormatter.Header("Product Details") + tableFormatter.Append(Product{"Laptop", 1200.99}) // Will use Format() + tableFormatter.Render() +} +``` + +**Output (Stringer Examples):** +``` +┌─────────────────────┐ +│ DATA │ +├─────────────────────┤ +│ Value: 123 │ +│ CustomInt Value: 456! │ +└─────────────────────┘ + +--- Table with Type-Specific Stringer for Structs --- +┌─────────┬───────────┬──────────┐ +│ USER ID │ FULL NAME │ LOCATION │ +├─────────┼───────────┼──────────┤ +│ ID: 1 │ Alice │ NEW YORK │ +│ ID: 2 │ Bob │ LONDON │ +└─────────┴───────────┴──────────┘ + +--- Table with tw.Formatter --- +┌─────────────────┐ +│ PRODUCT DETAILS │ +├─────────────────┤ +│ Laptop - $1200… │ +└─────────────────┘ +``` + +**Key Changes**: +- **Stringer Support**: `WithStringer(fn any)` sets a table-wide string conversion function. This function must have a signature like `func(SomeType) []string` or `func(any) []string`. It's used to convert an input item (e.g., a struct) into a slice of strings, where each string is a cell for the row (`tablewriter.go:WithStringer`). +- **Caching**: `WithStringerCache()` enables caching for the function provided via `WithStringer`, improving performance for repeated conversions of the same input type (`tablewriter.go:WithStringerCache`). +- **Formatter**: `tw.Formatter` interface (`Format() string`) allows types to define their own single-string representation for a cell. This is checked before `fmt.Stringer` (`tw/types.go:Formatter`). +- **Priority**: When converting an item to cell(s): + 1. `WithStringer` (if provided and compatible with the item's type). + 2. If not handled by `WithStringer`, or if `WithStringer` is not set: + * If the item is a struct that does *not* implement `tw.Formatter` or `fmt.Stringer`, its exported fields are reflected into multiple cells. + * If the item (or struct) implements `tw.Formatter` (`Format() string`), that's used for a single cell. + * Else, if it implements `fmt.Stringer` (`String() string`), that's used for a single cell. + * Else, default `fmt.Sprintf("%v", ...)` for a single cell. + (`zoo.go:convertCellsToStrings`, `zoo.go:convertItemToCells`) + +**Migration Tips**: +- For types that should produce a single cell with custom formatting, implement `tw.Formatter`. +- For types (especially structs) that should be expanded into multiple cells with custom logic, use `WithStringer` with a function like `func(MyType) []string`. +- If you have a general way to convert *any* type into a set of cells, use `WithStringer(func(any) []string)`. +- Enable `WithStringerCache` for large datasets with repetitive data types if using `WithStringer`. +- Test stringer/formatter output to ensure formatting meets expectations (`zoo.go`). + +**Potential Pitfalls**: +- **Cache Overhead**: `WithStringerCache` may increase memory usage for diverse data; disable for small tables or if not using `WithStringer` (`tablewriter.go`). +- **Stringer Signature**: The function passed to `WithStringer` *must* return `[]string`. A function returning `string` will lead to a warning and fallback behavior. +- **Formatter vs. Stringer Priority**: Be aware of the conversion priority if your types implement multiple interfaces or if you also use `WithStringer`. +- **Streaming**: Stringers/Formatters must produce consistent cell counts in streaming mode to maintain width alignment (`stream.go`). + +## Examples + +This section provides practical examples to demonstrate v1.0.x features, covering common and advanced use cases to aid migration. Each example includes code, output, and notes to illustrate functionality. + +### Example: Minimal Setup +A basic table with default settings, ideal for quick setups. + +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Render() +} +``` + +**Output**: +``` +┌───────┬────────┐ +│ NAME │ STATUS │ +├───────┼────────┤ +│ Node1 │ Ready │ +└───────┴────────┘ +``` + +**Notes**: +- Uses default `renderer.NewBlueprint()` and `defaultConfig()` settings (`tablewriter.go`, `config.go`). +- `Header: tw.AlignCenter`, `Row: tw.AlignLeft` (`config.go:defaultConfig`). +- Simple replacement for v0.0.5’s `NewWriter` and `SetHeader`/`Append`. + +### Example: Streaming with Fixed Widths +Demonstrates streaming mode for real-time data output. + +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "log" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithStreaming(tw.StreamConfig{Enable: true}), + tablewriter.WithColumnMax(10), // Sets Config.Widths.Global + ) + if err := table.Start(); err != nil { + log.Fatalf("Start failed: %v", err) + } + table.Header("Name", "Status") + for i := 0; i < 2; i++ { + err := table.Append(fmt.Sprintf("Node%d", i+1), "Ready") + if err != nil { + log.Printf("Append failed: %v", err) + } + } + if err := table.Close(); err != nil { + log.Fatalf("Close failed: %v", err) + } +} +``` + +**Output**: +``` +┌──────────┬──────────┐ +│ NAME │ STATUS │ +├──────────┼──────────┤ +│ Node1 │ Ready │ +│ Node2 │ Ready │ +└──────────┴──────────┘ +``` + +**Notes**: +- Streaming requires `Start()` and `Close()`; `Config.Widths` (here set via `WithColumnMax`) fixes widths (`stream.go`). +- Replaces v0.0.5’s batch rendering for real-time use cases. +- Ensure error handling for `Start()`, `Append()`, and `Close()`. + +### Example: Markdown-Style Table +Creates a Markdown-compatible table for documentation. + +```go +package main + +import ( + "fmt" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" // Import renderer + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + // Example 1: Using Blueprint renderer with Markdown symbols + tableBlueprintMarkdown := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), // Use Blueprint + tablewriter.WithRendition(tw.Rendition{ + Symbols: tw.NewSymbols(tw.StyleMarkdown), + Borders: tw.Border{Left: tw.On, Right: tw.On}, // Markdown needs left/right borders + }), + tablewriter.WithRowAlignment(tw.AlignLeft), // Common for Markdown + tablewriter.WithHeaderAlignment(tw.AlignCenter), // Center align headers + ) + tableBlueprintMarkdown.Header("Name", "Status") + tableBlueprintMarkdown.Append("Node1", "Ready") + tableBlueprintMarkdown.Append("Node2", "NotReady") + tableBlueprintMarkdown.Render() + + fmt.Println("\n--- Using dedicated Markdown Renderer (if one exists or is built) ---") + // Example 2: Assuming a dedicated Markdown renderer (hypothetical example) + // If a `renderer.NewMarkdown()` existed that directly outputs GitHub Flavored Markdown table syntax: + /* + tableDedicatedMarkdown := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewMarkdown()), // Hypothetical Markdown renderer + ) + tableDedicatedMarkdown.Header("Name", "Status") + tableDedicatedMarkdown.Append("Node1", "Ready") + tableDedicatedMarkdown.Append("Node2", "NotReady") + tableDedicatedMarkdown.Render() + */ + // Since `renderer.NewMarkdown()` isn't shown in the provided code, + // the first example (Blueprint with StyleMarkdown) is the current viable way. +} +``` + +**Output (Blueprint with StyleMarkdown):** +``` +| NAME | STATUS | +|--------|----------| +| Node1 | Ready | +| Node2 | NotReady | +``` + +**Notes**: +- `StyleMarkdown` ensures compatibility with Markdown parsers (`tw/symbols.go`). +- Left alignment for rows and center for headers is common for Markdown readability (`config.go`). +- Ideal for GitHub READMEs or documentation. +- A dedicated Markdown renderer (like the commented-out example) would typically handle alignment syntax (e.g., `|:---:|:---|`). With `Blueprint` and `StyleMarkdown`, alignment is visual within the text rather than Markdown syntax. + +### Example: ASCII-Style Table +Uses `StyleASCII` for maximum terminal compatibility. + +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), + tablewriter.WithRendition(tw.Rendition{ + Symbols: tw.NewSymbols(tw.StyleASCII), + }), + tablewriter.WithRowAlignment(tw.AlignLeft), + ) + table.Header("ID", "Value") + table.Append("1", "Test") + table.Render() +} +``` + +**Output**: +``` ++----+-------+ +│ ID │ VALUE │ ++----+-------+ +│ 1 │ Test │ ++----+-------+ +``` + +**Notes**: +- `StyleASCII` is robust for all terminals (`tw/symbols.go`). +- Replaces v0.0.5’s default style with explicit configuration. + + +### Example: Kubectl-Style Output +Creates a borderless, minimal table similar to `kubectl` command output, emphasizing simplicity and readability. + +```go +package main + +import ( + "os" + "sync" + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" + "github.com/olekukonko/tablewriter/tw" +) + +var wg sync.WaitGroup + +func main() { + data := [][]any{ + {"node1.example.com", "Ready", "compute", "1.11"}, + {"node2.example.com", "Ready", "compute", "1.11"}, + {"node3.example.com", "Ready", "compute", "1.11"}, + {"node4.example.com", "NotReady", "compute", "1.11"}, + } + + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{ + Borders: tw.BorderNone, + Settings: tw.Settings{ + Separators: tw.SeparatorsNone, + Lines: tw.LinesNone, + }, + })), + tablewriter.WithConfig(tablewriter.Config{ + Header: tw.CellConfig{ + Formatting: tw.CellFormatting{Alignment: tw.AlignLeft}, + }, + Row: tw.CellConfig{ + Formatting: tw.CellFormatting{Alignment: tw.AlignLeft}, + Padding: tw.CellPadding{Global: tw.PaddingNone}, + }, + }), + ) + table.Header("Name", "Status", "Role", "Version") + table.Bulk(data) + table.Render() +} +``` + +**Output:** +``` +NAME STATUS ROLE VERSION +node1.example.com Ready compute 1.21.3 +node2.example.com Ready infra 1.21.3 +node3.example.com NotReady compute 1.20.7 +``` + +**Notes**: +- **Configuration**: Uses `tw.BorderNone`, `tw.LinesNone`, `tw.SeparatorsNone`, `tw.NewSymbols(tw.StyleNone)` and specific padding (`Padding{Right:" "}`) for a minimal, borderless layout. +- **Migration from v0.0.5**: Replaces `SetBorder(false)` and manual spacing with `tw.Rendition` and `Config` settings, achieving a cleaner kubectl-like output. +- **Key Features**: + - Left-aligned text for readability (`config.go`). + - `WithTrimSpace(tw.Off)` preserves spacing (`config.go`). + - `Bulk` efficiently adds multiple rows (`tablewriter.go`). + - Padding `Right: " "` is used to create space between columns as separators are off. +- **Best Practices**: Test in terminals to ensure spacing aligns with command-line aesthetics; use `WithDebug(true)` for layout issues (`config.go`). +- **Potential Issues**: Column widths are content-based. For very long content in one column and short in others, it might not look perfectly aligned like fixed-width CLI tools. `Config.Widths` could be used for more control if needed. + +### Example: Hierarchical Merging +Demonstrates hierarchical cell merging for nested data structures, a new feature in v1.0.x. + +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + data := [][]string{ + // Header row is separate + {"table\nwriter", "v0.0.1", "legacy"}, + {"table\nwriter", "v0.0.2", "legacy"}, + {"table\nwriter", "v0.0.2", "legacy"}, // Duplicate for testing merge + {"table\nwriter", "v0.0.2", "legacy"}, // Duplicate for testing merge + {"table\nwriter", "v0.0.5", "legacy"}, + {"table\nwriter", "v1.0.6", "latest"}, + } + + rendition := tw.Rendition{ + Symbols: tw.NewSymbols(tw.StyleLight), // Use light for clearer merge lines + Settings: tw.Settings{ + Separators: tw.Separators{BetweenRows: tw.On}, + Lines: tw.Lines{ShowHeaderLine: tw.On, ShowFooterLine: tw.On}, // Show header line + }, + Borders: tw.Border{Left:tw.On, Right:tw.On, Top:tw.On, Bottom:tw.On}, + } + + tableHier := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), + tablewriter.WithRendition(rendition), + tablewriter.WithConfig(tablewriter.Config{ + Row: tw.CellConfig{ + Formatting: tw.CellFormatting{ + MergeMode: tw.MergeHierarchical, + // Alignment: tw.AlignCenter, // Default is Left, often better for hierarchical + AutoWrap: tw.WrapNormal, // Allow wrapping for "table\nwriter" + }, + }, + }), + ) + + tableHier.Header("Package", "Version", "Status") // Header + tableHier.Bulk(data) // Bulk data + tableHier.Render() + + // --- Vertical Merging Example for Contrast --- + tableVert := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), + tablewriter.WithRendition(rendition), // Reuse same rendition + tablewriter.WithConfig(tablewriter.Config{ + Row: tw.CellConfig{ + Formatting: tw.CellFormatting{ + MergeMode: tw.MergeVertical, + AutoWrap: tw.WrapNormal, + }, + }, + }), + ) + tableVert.Header("Package", "Version", "Status") + tableVert.Bulk(data) + tableVert.Render() +} +``` + +**Output (Hierarchical):** +``` +┌─────────┬─────────┬────────┐ +│ PACKAGE │ VERSION │ STATUS │ +├─────────┼─────────┼────────┤ +│ table │ v0.0.1 │ legacy │ +│ writer │ │ │ +│ ├─────────┼────────┤ +│ │ v0.0.2 │ legacy │ +│ │ │ │ +│ │ │ │ +│ │ │ │ +│ │ │ │ +│ ├─────────┼────────┤ +│ │ v0.0.5 │ legacy │ +│ ├─────────┼────────┤ +│ │ v1.0.6 │ latest │ +└─────────┴─────────┴────────┘ +``` +**Output (Vertical):** +``` +┌─────────┬─────────┬────────┐ +│ PACKAGE │ VERSION │ STATUS │ +├─────────┼─────────┼────────┤ +│ table │ v0.0.1 │ legacy │ +│ writer │ │ │ +│ ├─────────┤ │ +│ │ v0.0.2 │ │ +│ │ │ │ +│ │ │ │ +│ │ │ │ +│ │ │ │ +│ ├─────────┤ │ +│ │ v0.0.5 │ │ +│ ├─────────┼────────┤ +│ │ v1.0.6 │ latest │ +└─────────┴─────────┴────────┘ +``` + +**Notes**: +- **Configuration**: Uses `tw.MergeHierarchical` to merge cells based on matching values in preceding columns (`tw/tw.go`). +- **Migration from v0.0.5**: Extends `SetAutoMergeCells(true)` (horizontal only) with hierarchical merging for complex data (`tablewriter.go`). +- **Key Features**: + - `StyleLight` for clear visuals (`tw/symbols.go`). + - `Bulk` for efficient data loading (`tablewriter.go`). +- **Best Practices**: Test merging with nested data; use batch mode, as streaming doesn’t support hierarchical merging (`stream.go`). +- **Potential Issues**: Ensure data is sorted appropriately for hierarchical merging to work as expected; mismatches prevent merging (`zoo.go`). `AutoWrap: tw.WrapNormal` helps with multi-line cell content like "table\nwriter". + +### Example: Colorized Table +Applies ANSI colors to highlight status values, replacing v0.0.5’s `SetColumnColor`. + +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" // For tw.State, tw.CellConfig etc. + "os" +) + +func main() { + const ( + FgGreen = "\033[32m" + FgRed = "\033[31m" + Reset = "\033[0m" + ) + + cfgBuilder := tablewriter.NewConfigBuilder() + cfgBuilder.Row().Filter().WithPerColumn([]func(string) string{ + nil, // No filter for Name + func(s string) string { // Color Status + if s == "Ready" { + return FgGreen + s + Reset + } + return FgRed + s + Reset + }, + }) + + table := tablewriter.NewTable(os.Stdout, tablewriter.WithConfig(cfgBuilder.Build())) + table.Header("Name", "Status") + table.Append("Node1", "Ready") + table.Append("Node2", "Error") + table.Render() +} +``` + +**Output (Text Approximation, Colors Not Shown):** +``` +┌───────┬────────┐ +│ NAME │ STATUS │ +├───────┼────────┤ +│ Node1 │ Ready │ +│ Node2 │ Error │ +└───────┴────────┘ +``` + +**Notes**: +- **Configuration**: Uses `tw.CellFilter` for per-column coloring, embedding ANSI codes (`tw/cell.go`). +- **Migration from v0.0.5**: Replaces `SetColumnColor` with dynamic filters (`tablewriter.go`). +- **Key Features**: Flexible color application; `tw.DisplayWidth` handles ANSI codes correctly (`tw/fn.go`). +- **Best Practices**: Test in ANSI-compatible terminals; use constants for code clarity. +- **Potential Issues**: Non-ANSI terminals may show artifacts; provide fallbacks (`tw/fn.go`). + +### Example: Vertical Merging +Shows vertical cell merging for repeated values in a column. (This example was very similar to the hierarchical one, so I'll ensure it's distinct by using simpler data). + +```go +package main + +import ( + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/renderer" + "github.com/olekukonko/tablewriter/tw" + "os" +) + +func main() { + table := tablewriter.NewTable(os.Stdout, + tablewriter.WithRenderer(renderer.NewBlueprint()), // Default renderer + tablewriter.WithRendition(tw.Rendition{ + Symbols: tw.NewSymbols(tw.StyleLight), + Settings: tw.Settings{Separators: tw.Separators{BetweenRows: tw.On}}, + Borders: tw.Border{Left:tw.On, Right:tw.On, Top:tw.On, Bottom:tw.On}, + }), + tablewriter.WithConfig( + tablewriter.NewConfigBuilder(). + Row().Formatting().WithMergeMode(tw.MergeVertical).Build(). // Enable Vertical Merge + Build(), + ), + ) + table.Header("User", "Permission", "Target") + table.Append("Alice", "Read", "FileA") + table.Append("Alice", "Write", "FileA") // Alice and FileA will merge vertically + table.Append("Alice", "Read", "FileB") + table.Append("Bob", "Read", "FileA") + table.Append("Bob", "Read", "FileC") // Bob and Read will merge + table.Render() +} +``` + +**Output:** +``` +┌───────┬────────────┬────────┐ +│ USER │ PERMISSION │ TARGET │ +├───────┼────────────┼────────┤ +│ Alice │ Read │ FileA │ +│ │ │ │ +│ ├────────────┤ │ +│ │ Write │ │ +│ ├────────────┼────────┤ +│ │ Read │ FileB │ +├───────┼────────────┼────────┤ +│ Bob │ Read │ FileA │ +│ │ ├────────┤ +│ │ │ FileC │ +└───────┴────────────┴────────┘ +``` + +**Notes**: +- **Configuration**: `tw.MergeVertical` merges identical cells vertically (`tw/tw.go`). +- **Migration from v0.0.5**: Extends `SetAutoMergeCells` with vertical merging (`tablewriter.go`). +- **Key Features**: Enhances grouped data display; requires batch mode (`stream.go`). +- **Best Practices**: Sort data by the columns you intend to merge for best results; test with `StyleLight` for clarity (`tw/symbols.go`). +- **Potential Issues**: Streaming doesn’t support vertical merging; use batch mode (`stream.go`). + +### Example: Custom Renderer (CSV Output) +Implements a custom renderer for CSV output. + +```go +package main + +import ( + "fmt" + "github.com/olekukonko/ll" // For logger type + "github.com/olekukonko/tablewriter" + "github.com/olekukonko/tablewriter/tw" + "io" + "os" + "strings" // For CSV escaping +) + +// CSVRenderer implements tw.Renderer +type CSVRenderer struct { + writer io.Writer + config tw.Rendition // Store the rendition + logger *ll.Logger + err error +} + +func (r *CSVRenderer) Start(w io.Writer) error { + r.writer = w + return nil // No initial output for CSV typically +} + +func (r *CSVRenderer) escapeCSVCell(data string) string { + // Basic CSV escaping: double quotes if it contains comma, newline, or quote + if strings.ContainsAny(data, ",\"\n") { + return `"` + strings.ReplaceAll(data, `"`, `""`) + `"` + } + return data +} + +func (r *CSVRenderer) writeLine(cells map[int]tw.CellContext, numCols int) { + if r.err != nil { return } + var lineParts []string + // Need to iterate in column order for CSV + keys := make([]int, 0, len(cells)) + for k := range cells { + keys = append(keys, k) + } + // This simple sort works for int keys 0,1,2... + // For more complex scenarios, a proper sort might be needed if keys aren't sequential. + for i := 0; i < numCols; i++ { // Assume numCols reflects the intended max columns + if cellCtx, ok := cells[i]; ok { + lineParts = append(lineParts, r.escapeCSVCell(cellCtx.Data)) + } else { + lineParts = append(lineParts, "") // Empty cell if not present + } + } + _, r.err = r.writer.Write([]byte(strings.Join(lineParts, ",") + "\n")) +} + + +func (r *CSVRenderer) Header(headers [][]string, ctx tw.Formatting) { + // For CSV, usually only the first line of headers is relevant + // The ctx.Row.Current will contain the cells for the first line of the header being processed + r.writeLine(ctx.Row.Current, len(ctx.Row.Current)) +} + +func (r *CSVRenderer) Row(row []string, ctx tw.Formatting) { + // ctx.Row.Current contains the cells for the current row line + r.writeLine(ctx.Row.Current, len(ctx.Row.Current)) +} + +func (r *CSVRenderer) Footer(footers [][]string, ctx tw.Formatting) { + // Similar to Header/Row, using ctx.Row.Current for the footer line data + r.writeLine(ctx.Row.Current, len(ctx.Row.Current)) +} + +func (r *CSVRenderer) Line(ctx tw.Formatting) { /* No separator lines in CSV */ } + +func (r *CSVRenderer) Close() error { return r.err } + +func (r *CSVRenderer) Config() tw.Rendition { return r.config } +func (r *CSVRenderer) Logger(logger *ll.Logger) { r.logger = logger } + +func main() { + table := tablewriter.NewTable(os.Stdout, tablewriter.WithRenderer(&CSVRenderer{ + // config can be minimal for CSV as symbols/borders aren't used + config: tw.Rendition{}, + })) + table.Header("Name", "Status", "Notes, with comma") + table.Append("Node1", "Ready", "All systems \"go\"!") + table.Append("Node2", "Error", "Needs\nattention") + table.Footer("Summary", "2 Nodes", "Check logs") + table.Render() +} +``` + +**Output:** +```csv +Name,Status,"Notes, with comma" +Node1,Ready,"All systems ""go""!" +Node2,Error,"Needs +attention" +Summary,2 Nodes,Check logs +``` + +**Notes**: +- **Configuration**: Custom `CSVRenderer` implements `tw.Renderer` for CSV output (`tw/renderer.go`). +- **Migration from v0.0.5**: Extends v0.0.5’s text-only output with custom formats (`tablewriter.go`). +- **Key Features**: Handles basic CSV cell escaping; supports streaming if `Append` is called multiple times. `ctx.Row.Current` (map[int]tw.CellContext) is used to access cell data. +- **Best Practices**: Test with complex data (e.g., commas, quotes, newlines); implement all renderer methods. A more robust CSV renderer would use the `encoding/csv` package. +- **Potential Issues**: Custom renderers require careful error handling and correct interpretation of `tw.Formatting` and `tw.RowContext`. This example's `writeLine` assumes columns are 0-indexed and contiguous for simplicity. + +## Troubleshooting and Common Pitfalls + +This section addresses common migration issues with detailed solutions, covering 30+ scenarios to reduce support tickets. + +| Issue | Cause/Solution | +|-------------------------------------------|-------------------------------------------------------------------------------| +| No output from `Render()` | **Cause**: Missing `Start()`/`Close()` in streaming mode or invalid `io.Writer`. **Solution**: Ensure `Start()` and `Close()` are called in streaming; verify `io.Writer` (`stream.go`). | +| Incorrect column widths | **Cause**: Missing `Config.Widths` in streaming or content-based sizing. **Solution**: Set `Config.Widths` before `Start()`; use `WithColumnMax` (`stream.go`). | +| Merging not working | **Cause**: Streaming mode or mismatched data. **Solution**: Use batch mode for vertical/hierarchical merging; ensure identical content (`zoo.go`). | +| Alignment ignored | **Cause**: `PerColumn` overrides `Global`. **Solution**: Check `Config.Section.Alignment.PerColumn` settings or `ConfigBuilder` calls (`tw/cell.go`). | +| Padding affects widths | **Cause**: Padding included in `Config.Widths`. **Solution**: Adjust `Config.Widths` to account for `tw.CellPadding` (`zoo.go`). | +| Colors not rendering | **Cause**: Non-ANSI terminal or incorrect codes. **Solution**: Test in ANSI-compatible terminal; use `tw.DisplayWidth` (`tw/fn.go`). | +| Caption missing | **Cause**: `Close()` not called in streaming or incorrect `Spot`. **Solution**: Ensure `Close()`; verify `tw.Caption.Spot` (`tablewriter.go`). | +| Filters not applied | **Cause**: Incorrect `PerColumn` indexing or nil filters. **Solution**: Set filters correctly; test with sample data (`tw/cell.go`). | +| Stringer cache overhead | **Cause**: Large datasets with diverse types. **Solution**: Disable `WithStringerCache` for small tables if not using `WithStringer` or if types vary greatly (`tablewriter.go`). | +| Deprecated methods used | **Cause**: Using `WithBorders`, old `tablewriter.Behavior` constants. **Solution**: Migrate to `WithRendition`, `tw.Behavior` struct (`tablewriter.go`, `deprecated.go`). | +| Streaming footer missing | **Cause**: `Close()` not called. **Solution**: Always call `Close()` (`stream.go`). | +| Hierarchical merging fails | **Cause**: Unsorted data or streaming mode. **Solution**: Sort data; use batch mode (`zoo.go`). | +| Custom renderer errors | **Cause**: Incomplete method implementation or misinterpreting `tw.Formatting`. **Solution**: Implement all `tw.Renderer` methods; test thoroughly (`tw/renderer.go`). | +| Width overflow | **Cause**: No `MaxWidth` or wide content. **Solution**: Set `Config.MaxWidth` (`config.go`). | +| Truncated content | **Cause**: Narrow `Config.Widths` or `tw.WrapTruncate`. **Solution**: Widen columns or use `tw.WrapNormal` (`zoo.go`). | +| Debug logs absent | **Cause**: `Debug = false`. **Solution**: Enable `WithDebug(true)` (`config.go`). | +| Alignment mismatch across sections | **Cause**: Different defaults. **Solution**: Set uniform alignment options (e.g., via `ConfigBuilder.
.Alignment()`) (`config.go`). | +| ANSI code artifacts | **Cause**: Non-ANSI terminal. **Solution**: Provide non-colored fallback (`tw/fn.go`). | +| Slow rendering | **Cause**: Complex filters or merging. **Solution**: Optimize logic; limit merging (`zoo.go`). | +| Uneven cell counts | **Cause**: Mismatched rows/headers. **Solution**: Pad with `""` (`zoo.go`). | +| Border inconsistencies | **Cause**: Mismatched `Borders`/`Symbols`. **Solution**: Align settings (`tw/renderer.go`). | +| Streaming width issues | **Cause**: No `Config.Widths`. **Solution**: Set before `Start()` (`stream.go`). | +| Formatter ignored | **Cause**: `WithStringer` might take precedence if compatible. **Solution**: Review conversion priority; `tw.Formatter` is high-priority for single-item-to-single-cell conversion (`zoo.go`). | +| Caption misalignment | **Cause**: Incorrect `Width` or `Align`. **Solution**: Set `tw.Caption.Width`/`Align` (`tablewriter.go`). | +| Per-column padding errors | **Cause**: Incorrect indexing in `Padding.PerColumn`. **Solution**: Verify indices (`tw/cell.go`). | +| Vertical merging in streaming | **Cause**: Unsupported. **Solution**: Use batch mode (`stream.go`). | +| Filter performance | **Cause**: Complex logic. **Solution**: Simplify filters (`zoo.go`). | +| Custom symbols incomplete | **Cause**: Missing characters. **Solution**: Define all symbols (`tw/symbols.go`). | +| Table too wide | **Cause**: No `MaxWidth`. **Solution**: Set `Config.MaxWidth` (`config.go`). | +| Streaming errors | **Cause**: Missing `Start()`. **Solution**: Call `Start()` before data input (`stream.go`). | + +## Additional Notes + +- **Performance Optimization**: Enable `WithStringerCache` for repetitive data types when using `WithStringer`; optimize filters and merging for large datasets (`tablewriter.go`, `zoo.go`). +- **Debugging**: Use `WithDebug(true)` and `table.Debug()` to log configuration and rendering details; invaluable for troubleshooting (`config.go`). +- **Testing Resources**: The `tests/` directory contains examples of various configurations. +- **Community Support**: For advanced use cases or issues, consult the source code or open an issue on the `tablewriter` repository. +- **Future Considerations**: Deprecated methods in `deprecated.go` (e.g., `WithBorders`) are slated for removal in future releases; migrate promptly to ensure compatibility. + +This guide aims to cover all migration scenarios comprehensively. For highly specific or advanced use cases, refer to the source files (`config.go`, `tablewriter.go`, `stream.go`, `tw/*`) or engage with the `tablewriter` community for support. \ No newline at end of file diff --git a/vendor/github.com/olekukonko/tablewriter/README.md b/vendor/github.com/olekukonko/tablewriter/README.md index 8aecd0f55b..f694340f73 100644 --- a/vendor/github.com/olekukonko/tablewriter/README.md +++ b/vendor/github.com/olekukonko/tablewriter/README.md @@ -28,14 +28,14 @@ go get github.com/olekukonko/tablewriter@v0.0.5 #### Latest Version The latest stable version ```bash -go get github.com/olekukonko/tablewriter@v1.0.6 +go get github.com/olekukonko/tablewriter@v1.0.7 ``` **Warning:** Version `v1.0.0` contains missing functionality and should not be used. > **Version Guidance** -> - Production: Use `v0.0.5` (stable) +> - Legacy: Use `v0.0.5` (stable) > - New Features: Use `@latest` (includes generics, super fast streaming APIs) > - Legacy Docs: See [README_LEGACY.md](README_LEGACY.md) @@ -62,7 +62,7 @@ func main() { data := [][]string{ {"Package", "Version", "Status"}, {"tablewriter", "v0.0.5", "legacy"}, - {"tablewriter", "v1.0.6", "latest"}, + {"tablewriter", "v1.0.7", "latest"}, } table := tablewriter.NewWriter(os.Stdout) @@ -77,7 +77,7 @@ func main() { │ PACKAGE │ VERSION │ STATUS │ ├─────────────┼─────────┼────────┤ │ tablewriter │ v0.0.5 │ legacy │ -│ tablewriter │ v1.0.6 │ latest │ +│ tablewriter │ v1.0.7 │ latest │ └─────────────┴─────────┴────────┘ ``` @@ -297,7 +297,7 @@ func main() { } table.Configure(func(config *tablewriter.Config) { - config.Row.Formatting.Alignment = tw.AlignLeft + config.Row.Alignment.Global = tw.AlignLeft }) table.Render() } @@ -368,14 +368,12 @@ func main() { tablewriter.WithRenderer(renderer.NewColorized(colorCfg)), tablewriter.WithConfig(tablewriter.Config{ Row: tw.CellConfig{ - Formatting: tw.CellFormatting{ - AutoWrap: tw.WrapNormal, // Wrap long content - Alignment: tw.AlignLeft, // Left-align rows - }, + Formatting: tw.CellFormatting{AutoWrap: tw.WrapNormal}, // Wrap long content + Alignment: tw.CellAlignment{Global: tw.AlignLeft}, // Left-align rows ColMaxWidths: tw.CellWidth{Global: 25}, }, Footer: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignRight}, + Alignment: tw.CellAlignment{Global: tw.AlignRight}, }, }), ) @@ -480,19 +478,13 @@ func main() { table := tablewriter.NewTable(os.Stdout, tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{ - Settings: tw.Settings{ - Separators: tw.Separators{BetweenRows: tw.On}, - }, + Settings: tw.Settings{Separators: tw.Separators{BetweenRows: tw.On}}, })), tablewriter.WithConfig(tablewriter.Config{ - Header: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignCenter}, - }, + Header: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignCenter}}, Row: tw.CellConfig{ - Formatting: tw.CellFormatting{ - MergeMode: tw.MergeHierarchical, - Alignment: tw.AlignLeft, - }, + Formatting: tw.CellFormatting{MergeMode: tw.MergeHierarchical}, + Alignment: tw.CellAlignment{Global: tw.AlignLeft}, }, }), ) @@ -546,21 +538,20 @@ func main() { table := tablewriter.NewTable(os.Stdout, tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{ - Settings: tw.Settings{ - Separators: tw.Separators{BetweenRows: tw.On}, - }, + Settings: tw.Settings{Separators: tw.Separators{BetweenRows: tw.On}}, })), tablewriter.WithConfig(tablewriter.Config{ Row: tw.CellConfig{ - Formatting: tw.CellFormatting{MergeMode: tw.MergeBoth}, - ColumnAligns: []tw.Align{tw.Skip, tw.Skip, tw.AlignRight, tw.AlignLeft}, + Formatting: tw.CellFormatting{MergeMode: tw.MergeBoth}, + Alignment: tw.CellAlignment{PerColumn: []tw.Align{tw.Skip, tw.Skip, tw.AlignRight, tw.AlignLeft}}, }, + Footer: tw.CellConfig{ Padding: tw.CellPadding{ Global: tw.Padding{Left: "*", Right: "*"}, PerColumn: []tw.Padding{{}, {}, {Bottom: "^"}, {Bottom: "^"}}, }, - ColumnAligns: []tw.Align{tw.Skip, tw.Skip, tw.AlignRight, tw.AlignLeft}, + Alignment: tw.CellAlignment{PerColumn: []tw.Align{tw.Skip, tw.Skip, tw.AlignRight, tw.AlignLeft}}, }, }), ) @@ -617,9 +608,7 @@ func main() { })), tablewriter.WithConfig(tablewriter.Config{ MaxWidth: 10, - Row: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignCenter}, - }, + Row: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignCenter}}, }), ) table.Append([]string{s, s}) @@ -631,16 +620,12 @@ func main() { // Main table table := tablewriter.NewTable(os.Stdout, tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{ - Borders: tw.BorderNone, - Settings: tw.Settings{ - Separators: tw.Separators{BetweenColumns: tw.On}, - }, + Borders: tw.BorderNone, + Settings: tw.Settings{Separators: tw.Separators{BetweenColumns: tw.On}}, })), tablewriter.WithConfig(tablewriter.Config{ MaxWidth: 30, - Row: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignCenter}, - }, + Row: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignCenter}}, }), ) table.Append([]string{createSubTable("A"), createSubTable("B")}) @@ -711,14 +696,11 @@ func main() { tablewriter.WithStringer(employeeStringer), tablewriter.WithConfig(tablewriter.Config{ Header: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignCenter, AutoFormat: tw.On}, - }, - Row: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignLeft}, - }, - Footer: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignRight}, + Formatting: tw.CellFormatting{AutoFormat: tw.On}, + Alignment: tw.CellAlignment{Global: tw.AlignCenter}, }, + Row: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignLeft}}, + Footer: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignRight}}, }), ) table.Header([]string{"ID", "Name", "Age", "Department", "Salary"}) @@ -784,23 +766,17 @@ func main() { } table := tablewriter.NewTable(os.Stdout, - tablewriter.WithRenderer(renderer.NewHTML(os.Stdout, false, htmlCfg)), + tablewriter.WithRenderer(renderer.NewHTML(htmlCfg)), tablewriter.WithConfig(tablewriter.Config{ Header: tw.CellConfig{ - Formatting: tw.CellFormatting{ - Alignment: tw.AlignCenter, - MergeMode: tw.MergeHorizontal, // Merge identical header cells - }, + Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}, // Merge identical header cells + Alignment: tw.CellAlignment{Global: tw.AlignCenter}, }, Row: tw.CellConfig{ - Formatting: tw.CellFormatting{ - MergeMode: tw.MergeHorizontal, // Merge identical row cells - Alignment: tw.AlignLeft, - }, - }, - Footer: tw.CellConfig{ - Formatting: tw.CellFormatting{Alignment: tw.AlignRight}, + Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}, // Merge identical row cells + Alignment: tw.CellAlignment{Global: tw.AlignLeft}, }, + Footer: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignRight}}, }), ) diff --git a/vendor/github.com/olekukonko/tablewriter/config.go b/vendor/github.com/olekukonko/tablewriter/config.go index 64c55786c7..94094f1b00 100644 --- a/vendor/github.com/olekukonko/tablewriter/config.go +++ b/vendor/github.com/olekukonko/tablewriter/config.go @@ -1,89 +1,71 @@ -// Package tablewriter provides functionality for creating and formatting tables with customizable configurations. package tablewriter import ( - "github.com/olekukonko/ll" // Logging library for debug output - "github.com/olekukonko/tablewriter/tw" // Table writer core types and utilities - "io" // Input/output interfaces - "reflect" // Reflection for type handling + "github.com/olekukonko/tablewriter/tw" ) -// ColumnConfigBuilder is used to configure settings for a specific column across all table sections (header, row, footer). -type ColumnConfigBuilder struct { - parent *ConfigBuilder // Reference to the parent ConfigBuilder for chaining - col int // Index of the column being configured -} - -// Build returns the parent ConfigBuilder to allow method chaining. -func (c *ColumnConfigBuilder) Build() *ConfigBuilder { - return c.parent -} - -// WithAlignment sets the text alignment for a specific column in the header section only. -// Invalid alignments are ignored, and the method returns the builder for chaining. -func (c *ColumnConfigBuilder) WithAlignment(align tw.Align) *ColumnConfigBuilder { - if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { - return c - } - // Ensure the ColumnAligns slice is large enough to accommodate the column index - if len(c.parent.config.Header.ColumnAligns) <= c.col { - newAligns := make([]tw.Align, c.col+1) - copy(newAligns, c.parent.config.Header.ColumnAligns) - c.parent.config.Header.ColumnAligns = newAligns - } - c.parent.config.Header.ColumnAligns[c.col] = align - return c -} - -// WithMaxWidth sets the maximum width for a specific column across all sections (header, row, footer). -// Negative widths are ignored, and the method returns the builder for chaining. -func (c *ColumnConfigBuilder) WithMaxWidth(width int) *ColumnConfigBuilder { - if width < 0 { - return c - } - // Initialize PerColumn maps if they don't exist - if c.parent.config.Header.ColMaxWidths.PerColumn == nil { - c.parent.config.Header.ColMaxWidths.PerColumn = make(map[int]int) - c.parent.config.Row.ColMaxWidths.PerColumn = make(map[int]int) - c.parent.config.Footer.ColMaxWidths.PerColumn = make(map[int]int) - } - c.parent.config.Header.ColMaxWidths.PerColumn[c.col] = width - c.parent.config.Row.ColMaxWidths.PerColumn[c.col] = width - c.parent.config.Footer.ColMaxWidths.PerColumn[c.col] = width - return c -} - -// Config represents the overall configuration for a table, including settings for header, rows, footer, and behavior. +// Config represents the table configuration type Config struct { - MaxWidth int // Maximum width of the entire table (0 for unlimited) - Header tw.CellConfig // Configuration for the header section - Row tw.CellConfig // Configuration for the row section - Footer tw.CellConfig // Configuration for the footer section - Debug bool // Enables debug logging when true - Stream tw.StreamConfig // Configuration specific to streaming mode - Behavior Behavior // Behavioral settings like auto-hiding and trimming + MaxWidth int + Header tw.CellConfig + Row tw.CellConfig + Footer tw.CellConfig + Debug bool + Stream tw.StreamConfig + Behavior tw.Behavior + Widths tw.CellWidth } -// ConfigBuilder provides a fluent interface for building a Config struct with both direct and nested configuration methods. +// ConfigBuilder provides a fluent interface for building Config type ConfigBuilder struct { - config Config // The configuration being built + config Config } -// Build finalizes and returns the Config struct after all modifications. +// NewConfigBuilder creates a new ConfigBuilder with defaults +func NewConfigBuilder() *ConfigBuilder { + return &ConfigBuilder{ + config: defaultConfig(), + } +} + +// Build returns the built Config func (b *ConfigBuilder) Build() Config { return b.config } -// Footer returns a builder for advanced configuration of the footer section. -func (b *ConfigBuilder) Footer() *FooterConfigBuilder { - return &FooterConfigBuilder{ - parent: b, - config: &b.config.Footer, - section: "footer", +// Header returns a HeaderConfigBuilder for header configuration +func (b *ConfigBuilder) Header() *HeaderConfigBuilder { + return &HeaderConfigBuilder{ + parent: b, + config: &b.config.Header, } } -// ForColumn returns a builder for configuring a specific column across all sections. +// Row returns a RowConfigBuilder for row configuration +func (b *ConfigBuilder) Row() *RowConfigBuilder { + return &RowConfigBuilder{ + parent: b, + config: &b.config.Row, + } +} + +// Footer returns a FooterConfigBuilder for footer configuration +func (b *ConfigBuilder) Footer() *FooterConfigBuilder { + return &FooterConfigBuilder{ + parent: b, + config: &b.config.Footer, + } +} + +// Behavior returns a BehaviorConfigBuilder for behavior configuration +func (b *ConfigBuilder) Behavior() *BehaviorConfigBuilder { + return &BehaviorConfigBuilder{ + parent: b, + config: &b.config.Behavior, + } +} + +// ForColumn returns a ColumnConfigBuilder for column-specific configuration func (b *ConfigBuilder) ForColumn(col int) *ColumnConfigBuilder { return &ColumnConfigBuilder{ parent: b, @@ -91,22 +73,17 @@ func (b *ConfigBuilder) ForColumn(col int) *ColumnConfigBuilder { } } -// Header returns a builder for advanced configuration of the header section. -func (b *ConfigBuilder) Header() *HeaderConfigBuilder { - return &HeaderConfigBuilder{ - parent: b, - config: &b.config.Header, - section: "header", - } +// WithTrimSpace enables or disables automatic trimming of leading/trailing spaces. +// Ignored in streaming mode. +func (b *ConfigBuilder) WithTrimSpace(state tw.State) *ConfigBuilder { + b.config.Behavior.TrimSpace = state + return b } -// Row returns a builder for advanced configuration of the row section. -func (b *ConfigBuilder) Row() *RowConfigBuilder { - return &RowConfigBuilder{ - parent: b, - config: &b.config.Row, - section: "row", - } +// WithDebug enables/disables debug logging +func (b *ConfigBuilder) WithDebug(debug bool) *ConfigBuilder { + b.config.Debug = debug + return b } // WithAutoHide enables or disables automatic hiding of empty columns (ignored in streaming mode). @@ -115,19 +92,13 @@ func (b *ConfigBuilder) WithAutoHide(state tw.State) *ConfigBuilder { return b } -// WithDebug enables or disables debug logging for the table. -func (b *ConfigBuilder) WithDebug(debug bool) *ConfigBuilder { - b.config.Debug = debug - return b -} - // WithFooterAlignment sets the text alignment for all footer cells. // Invalid alignments are ignored. func (b *ConfigBuilder) WithFooterAlignment(align tw.Align) *ConfigBuilder { if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { return b } - b.config.Footer.Formatting.Alignment = align + b.config.Footer.Alignment.Global = align return b } @@ -179,7 +150,7 @@ func (b *ConfigBuilder) WithHeaderAlignment(align tw.Align) *ConfigBuilder { if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { return b } - b.config.Header.Formatting.Alignment = align + b.config.Header.Alignment.Global = align return b } @@ -242,7 +213,7 @@ func (b *ConfigBuilder) WithRowAlignment(align tw.Align) *ConfigBuilder { if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { return b } - b.config.Row.Formatting.Alignment = align + b.config.Row.Alignment.Global = align return b } @@ -288,864 +259,702 @@ func (b *ConfigBuilder) WithRowMergeMode(mergeMode int) *ConfigBuilder { return b } -// WithTrimSpace enables or disables automatic trimming of leading/trailing spaces. -// Ignored in streaming mode. -func (b *ConfigBuilder) WithTrimSpace(state tw.State) *ConfigBuilder { - b.config.Behavior.TrimSpace = state - return b -} - -// FooterConfigBuilder provides advanced configuration options for the footer section. -type FooterConfigBuilder struct { - parent *ConfigBuilder // Reference to the parent ConfigBuilder - config *tw.CellConfig // Footer configuration being modified - section string // Section name for logging/debugging -} - -// Build returns the parent ConfigBuilder for chaining. -func (f *FooterConfigBuilder) Build() *ConfigBuilder { - return f.parent -} - -// Formatting returns a builder for configuring footer formatting settings. -func (f *FooterConfigBuilder) Formatting() *FooterFormattingBuilder { - return &FooterFormattingBuilder{ - parent: f, - config: &f.config.Formatting, - section: f.section, - } -} - -// Padding returns a builder for configuring footer padding settings. -func (f *FooterConfigBuilder) Padding() *FooterPaddingBuilder { - return &FooterPaddingBuilder{ - parent: f, - config: &f.config.Padding, - section: f.section, - } -} - -// FooterFormattingBuilder configures formatting options for the footer section. -type FooterFormattingBuilder struct { - parent *FooterConfigBuilder // Reference to the parent FooterConfigBuilder - config *tw.CellFormatting // Formatting configuration being modified - section string // Section name for logging/debugging -} - -// Build returns the parent FooterConfigBuilder for chaining. -func (ff *FooterFormattingBuilder) Build() *FooterConfigBuilder { - return ff.parent -} - -// WithAlignment sets the text alignment for footer cells. -// Invalid alignments are ignored. -func (ff *FooterFormattingBuilder) WithAlignment(align tw.Align) *FooterFormattingBuilder { - if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { - return ff - } - ff.config.Alignment = align - return ff -} - -// WithAutoFormat enables or disables automatic formatting for footer cells. -func (ff *FooterFormattingBuilder) WithAutoFormat(autoFormat tw.State) *FooterFormattingBuilder { - ff.config.AutoFormat = autoFormat - return ff -} - -// WithAutoWrap sets the wrapping behavior for footer cells. -// Invalid wrap modes are ignored. -func (ff *FooterFormattingBuilder) WithAutoWrap(autoWrap int) *FooterFormattingBuilder { - if autoWrap < tw.WrapNone || autoWrap > tw.WrapBreak { - return ff - } - ff.config.AutoWrap = autoWrap - return ff -} - -// WithMaxWidth sets the maximum content width for footer cells. -// Negative values are ignored. -//func (ff *FooterFormattingBuilder) WithMaxWidth(maxWidth int) *FooterFormattingBuilder { -// if maxWidth < 0 { -// return ff -// } -// ff.config.Foo = maxWidth -// return ff -//} - -// WithNewarkMode sets the merge behavior for footer cells (likely a typo, should be WithMergeMode). -// Invalid merge modes are ignored. -func (ff *FooterFormattingBuilder) WithNewarkMode(mergeMode int) *FooterFormattingBuilder { - if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { - return ff - } - ff.config.MergeMode = mergeMode - return ff -} - -// FooterPaddingBuilder configures padding options for the footer section. -type FooterPaddingBuilder struct { - parent *FooterConfigBuilder // Reference to the parent FooterConfigBuilder - config *tw.CellPadding // Padding configuration being modified - section string // Section name for logging/debugging -} - -// AddColumnPadding adds padding for a specific column in the footer. -func (fp *FooterPaddingBuilder) AddColumnPadding(padding tw.Padding) *FooterPaddingBuilder { - fp.config.PerColumn = append(fp.config.PerColumn, padding) - return fp -} - -// Build returns the parent FooterConfigBuilder for chaining. -func (fp *FooterPaddingBuilder) Build() *FooterConfigBuilder { - return fp.parent -} - -// WithGlobal sets the global padding for all footer cells. -func (fp *FooterPaddingBuilder) WithGlobal(padding tw.Padding) *FooterPaddingBuilder { - fp.config.Global = padding - return fp -} - -// WithPerColumn sets per-column padding for the footer. -func (fp *FooterPaddingBuilder) WithPerColumn(padding []tw.Padding) *FooterPaddingBuilder { - fp.config.PerColumn = padding - return fp -} - -// HeaderConfigBuilder provides advanced configuration options for the header section. +// HeaderConfigBuilder configures header settings type HeaderConfigBuilder struct { - parent *ConfigBuilder // Reference to the parent ConfigBuilder - config *tw.CellConfig // Header configuration being modified - section string // Section name for logging/debugging + parent *ConfigBuilder + config *tw.CellConfig } -// Build returns the parent ConfigBuilder for chaining. +// Build returns the parent ConfigBuilder func (h *HeaderConfigBuilder) Build() *ConfigBuilder { return h.parent } -// Formatting returns a builder for configuring header formatting settings. +// Alignment returns an AlignmentConfigBuilder for header alignment +func (h *HeaderConfigBuilder) Alignment() *AlignmentConfigBuilder { + return &AlignmentConfigBuilder{ + parent: h.parent, + config: &h.config.Alignment, + section: "header", + } +} + +// Formatting returns a HeaderFormattingBuilder for header formatting func (h *HeaderConfigBuilder) Formatting() *HeaderFormattingBuilder { return &HeaderFormattingBuilder{ parent: h, config: &h.config.Formatting, - section: h.section, + section: "header", } } -// Padding returns a builder for configuring header padding settings. +// Padding returns a HeaderPaddingBuilder for header padding func (h *HeaderConfigBuilder) Padding() *HeaderPaddingBuilder { return &HeaderPaddingBuilder{ parent: h, config: &h.config.Padding, - section: h.section, + section: "header", } } -// HeaderFormattingBuilder configures formatting options for the header section. -type HeaderFormattingBuilder struct { - parent *HeaderConfigBuilder // Reference to the parent HeaderConfigBuilder - config *tw.CellFormatting // Formatting configuration being modified - section string // Section name for logging/debugging +// Filter returns a HeaderFilterBuilder for header filtering +func (h *HeaderConfigBuilder) Filter() *HeaderFilterBuilder { + return &HeaderFilterBuilder{ + parent: h, + config: &h.config.Filter, + section: "header", + } } -// Build returns the parent HeaderConfigBuilder for chaining. +// Callbacks returns a HeaderCallbacksBuilder for header callbacks +func (h *HeaderConfigBuilder) Callbacks() *HeaderCallbacksBuilder { + return &HeaderCallbacksBuilder{ + parent: h, + config: &h.config.Callbacks, + section: "header", + } +} + +// RowConfigBuilder configures row settings +type RowConfigBuilder struct { + parent *ConfigBuilder + config *tw.CellConfig +} + +// Build returns the parent ConfigBuilder +func (r *RowConfigBuilder) Build() *ConfigBuilder { + return r.parent +} + +// Alignment returns an AlignmentConfigBuilder for row alignment +func (r *RowConfigBuilder) Alignment() *AlignmentConfigBuilder { + return &AlignmentConfigBuilder{ + parent: r.parent, + config: &r.config.Alignment, + section: "row", + } +} + +// Formatting returns a RowFormattingBuilder for row formatting +func (r *RowConfigBuilder) Formatting() *RowFormattingBuilder { + return &RowFormattingBuilder{ + parent: r, + config: &r.config.Formatting, + section: "row", + } +} + +// Padding returns a RowPaddingBuilder for row padding +func (r *RowConfigBuilder) Padding() *RowPaddingBuilder { + return &RowPaddingBuilder{ + parent: r, + config: &r.config.Padding, + section: "row", + } +} + +// Filter returns a RowFilterBuilder for row filtering +func (r *RowConfigBuilder) Filter() *RowFilterBuilder { + return &RowFilterBuilder{ + parent: r, + config: &r.config.Filter, + section: "row", + } +} + +// Callbacks returns a RowCallbacksBuilder for row callbacks +func (r *RowConfigBuilder) Callbacks() *RowCallbacksBuilder { + return &RowCallbacksBuilder{ + parent: r, + config: &r.config.Callbacks, + section: "row", + } +} + +// FooterConfigBuilder configures footer settings +type FooterConfigBuilder struct { + parent *ConfigBuilder + config *tw.CellConfig +} + +// Build returns the parent ConfigBuilder +func (f *FooterConfigBuilder) Build() *ConfigBuilder { + return f.parent +} + +// Alignment returns an AlignmentConfigBuilder for footer alignment +func (f *FooterConfigBuilder) Alignment() *AlignmentConfigBuilder { + return &AlignmentConfigBuilder{ + parent: f.parent, + config: &f.config.Alignment, + section: "footer", + } +} + +// Formatting returns a FooterFormattingBuilder for footer formatting +func (f *FooterConfigBuilder) Formatting() *FooterFormattingBuilder { + return &FooterFormattingBuilder{ + parent: f, + config: &f.config.Formatting, + section: "footer", + } +} + +// Padding returns a FooterPaddingBuilder for footer padding +func (f *FooterConfigBuilder) Padding() *FooterPaddingBuilder { + return &FooterPaddingBuilder{ + parent: f, + config: &f.config.Padding, + section: "footer", + } +} + +// Filter returns a FooterFilterBuilder for footer filtering +func (f *FooterConfigBuilder) Filter() *FooterFilterBuilder { + return &FooterFilterBuilder{ + parent: f, + config: &f.config.Filter, + section: "footer", + } +} + +// Callbacks returns a FooterCallbacksBuilder for footer callbacks +func (f *FooterConfigBuilder) Callbacks() *FooterCallbacksBuilder { + return &FooterCallbacksBuilder{ + parent: f, + config: &f.config.Callbacks, + section: "footer", + } +} + +// AlignmentConfigBuilder configures alignment settings +type AlignmentConfigBuilder struct { + parent *ConfigBuilder + config *tw.CellAlignment + section string +} + +// Build returns the parent ConfigBuilder +func (a *AlignmentConfigBuilder) Build() *ConfigBuilder { + return a.parent +} + +// WithGlobal sets global alignment +func (a *AlignmentConfigBuilder) WithGlobal(align tw.Align) *AlignmentConfigBuilder { + if err := align.Validate(); err == nil { + a.config.Global = align + } + return a +} + +// WithPerColumn sets per-column alignments +func (a *AlignmentConfigBuilder) WithPerColumn(alignments []tw.Align) *AlignmentConfigBuilder { + if len(alignments) > 0 { + a.config.PerColumn = alignments + } + return a +} + +// HeaderFormattingBuilder configures header formatting +type HeaderFormattingBuilder struct { + parent *HeaderConfigBuilder + config *tw.CellFormatting + section string +} + +// Build returns the parent HeaderConfigBuilder func (hf *HeaderFormattingBuilder) Build() *HeaderConfigBuilder { return hf.parent } -// WithAlignment sets the text alignment for header cells. -// Invalid alignments are ignored. -func (hf *HeaderFormattingBuilder) WithAlignment(align tw.Align) *HeaderFormattingBuilder { - if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { - return hf - } - hf.config.Alignment = align - return hf -} - -// WithAutoFormat enables or disables automatic formatting for header cells. +// WithAutoFormat enables/disables auto formatting func (hf *HeaderFormattingBuilder) WithAutoFormat(autoFormat tw.State) *HeaderFormattingBuilder { hf.config.AutoFormat = autoFormat return hf } -// WithAutoWrap sets the wrapping behavior for header cells. -// Invalid wrap modes are ignored. +// WithAutoWrap sets auto wrap mode func (hf *HeaderFormattingBuilder) WithAutoWrap(autoWrap int) *HeaderFormattingBuilder { - if autoWrap < tw.WrapNone || autoWrap > tw.WrapBreak { - return hf + if autoWrap >= tw.WrapNone && autoWrap <= tw.WrapBreak { + hf.config.AutoWrap = autoWrap } - hf.config.AutoWrap = autoWrap return hf } -// WithMaxWidth sets the maximum content width for header cells. -// Negative values are ignored. -//func (hf *HeaderFormattingBuilder) WithMaxWidth(maxWidth int) *HeaderFormattingBuilder { -// if maxWidth < 0 { -// return hf -// } -// hf.config.MaxWidth = maxWidth -// return hf -//} - -// WithMergeMode sets the merge behavior for header cells. -// Invalid merge modes are ignored. +// WithMergeMode sets merge mode func (hf *HeaderFormattingBuilder) WithMergeMode(mergeMode int) *HeaderFormattingBuilder { - if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { - return hf + if mergeMode >= tw.MergeNone && mergeMode <= tw.MergeHierarchical { + hf.config.MergeMode = mergeMode } - hf.config.MergeMode = mergeMode return hf } -// HeaderPaddingBuilder configures padding options for the header section. -type HeaderPaddingBuilder struct { - parent *HeaderConfigBuilder // Reference to the parent HeaderConfigBuilder - config *tw.CellPadding // Padding configuration being modified - section string // Section name for logging/debugging -} - -// AddColumnPadding adds padding for a specific column in the header. -func (hp *HeaderPaddingBuilder) AddColumnPadding(padding tw.Padding) *HeaderPaddingBuilder { - hp.config.PerColumn = append(hp.config.PerColumn, padding) - return hp -} - -// Build returns the parent HeaderConfigBuilder for chaining. -func (hp *HeaderPaddingBuilder) Build() *HeaderConfigBuilder { - return hp.parent -} - -// WithGlobal sets the global padding for all header cells. -func (hp *HeaderPaddingBuilder) WithGlobal(padding tw.Padding) *HeaderPaddingBuilder { - hp.config.Global = padding - return hp -} - -// WithPerColumn sets per-column padding for the header. -func (hp *HeaderPaddingBuilder) WithPerColumn(padding []tw.Padding) *HeaderPaddingBuilder { - hp.config.PerColumn = padding - return hp -} - -// Option defines a function type for configuring a Table instance. -type Option func(target *Table) - -// RowConfigBuilder provides advanced configuration options for the row section. -type RowConfigBuilder struct { - parent *ConfigBuilder // Reference to the parent ConfigBuilder - config *tw.CellConfig // Row configuration being modified - section string // Section name for logging/debugging -} - -// Build returns the parent ConfigBuilder for chaining. -func (r *RowConfigBuilder) Build() *ConfigBuilder { - return r.parent -} - -// Formatting returns a builder for configuring row formatting settings. -func (r *RowConfigBuilder) Formatting() *RowFormattingBuilder { - return &RowFormattingBuilder{ - parent: r, - config: &r.config.Formatting, - section: r.section, - } -} - -// Padding returns a builder for configuring row padding settings. -func (r *RowConfigBuilder) Padding() *RowPaddingBuilder { - return &RowPaddingBuilder{ - parent: r, - config: &r.config.Padding, - section: r.section, - } -} - -// RowFormattingBuilder configures formatting options for the row section. +// RowFormattingBuilder configures row formatting type RowFormattingBuilder struct { - parent *RowConfigBuilder // Reference to the parent RowConfigBuilder - config *tw.CellFormatting // Formatting configuration being modified - section string // Section name for logging/debugging + parent *RowConfigBuilder + config *tw.CellFormatting + section string } -// Build returns the parent RowConfigBuilder for chaining. +// Build returns the parent RowConfigBuilder func (rf *RowFormattingBuilder) Build() *RowConfigBuilder { return rf.parent } -// WithAlignment sets the text alignment for row cells. -// Invalid alignments are ignored. -func (rf *RowFormattingBuilder) WithAlignment(align tw.Align) *RowFormattingBuilder { - if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { - return rf - } - rf.config.Alignment = align - return rf -} - -// WithAutoFormat enables or disables automatic formatting for row cells. +// WithAutoFormat enables/disables auto formatting func (rf *RowFormattingBuilder) WithAutoFormat(autoFormat tw.State) *RowFormattingBuilder { rf.config.AutoFormat = autoFormat return rf } -// WithAutoWrap sets the wrapping behavior for row cells. -// Invalid wrap modes are ignored. +// WithAutoWrap sets auto wrap mode func (rf *RowFormattingBuilder) WithAutoWrap(autoWrap int) *RowFormattingBuilder { - if autoWrap < tw.WrapNone || autoWrap > tw.WrapBreak { - return rf + if autoWrap >= tw.WrapNone && autoWrap <= tw.WrapBreak { + rf.config.AutoWrap = autoWrap } - rf.config.AutoWrap = autoWrap return rf } -// WithMergeMode sets the merge behavior for row cells. -// Invalid merge modes are ignored. +// WithMergeMode sets merge mode func (rf *RowFormattingBuilder) WithMergeMode(mergeMode int) *RowFormattingBuilder { - if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { - return rf + if mergeMode >= tw.MergeNone && mergeMode <= tw.MergeHierarchical { + rf.config.MergeMode = mergeMode } - rf.config.MergeMode = mergeMode return rf } -// RowPaddingBuilder configures padding options for the row section. +// FooterFormattingBuilder configures footer formatting +type FooterFormattingBuilder struct { + parent *FooterConfigBuilder + config *tw.CellFormatting + section string +} + +// Build returns the parent FooterConfigBuilder +func (ff *FooterFormattingBuilder) Build() *FooterConfigBuilder { + return ff.parent +} + +// WithAutoFormat enables/disables auto formatting +func (ff *FooterFormattingBuilder) WithAutoFormat(autoFormat tw.State) *FooterFormattingBuilder { + ff.config.AutoFormat = autoFormat + return ff +} + +// WithAutoWrap sets auto wrap mode +func (ff *FooterFormattingBuilder) WithAutoWrap(autoWrap int) *FooterFormattingBuilder { + if autoWrap >= tw.WrapNone && autoWrap <= tw.WrapBreak { + ff.config.AutoWrap = autoWrap + } + return ff +} + +// WithMergeMode sets merge mode +func (ff *FooterFormattingBuilder) WithMergeMode(mergeMode int) *FooterFormattingBuilder { + if mergeMode >= tw.MergeNone && mergeMode <= tw.MergeHierarchical { + ff.config.MergeMode = mergeMode + } + return ff +} + +// HeaderPaddingBuilder configures header padding +type HeaderPaddingBuilder struct { + parent *HeaderConfigBuilder + config *tw.CellPadding + section string +} + +// Build returns the parent HeaderConfigBuilder +func (hp *HeaderPaddingBuilder) Build() *HeaderConfigBuilder { + return hp.parent +} + +// WithGlobal sets global padding +func (hp *HeaderPaddingBuilder) WithGlobal(padding tw.Padding) *HeaderPaddingBuilder { + hp.config.Global = padding + return hp +} + +// WithPerColumn sets per-column padding +func (hp *HeaderPaddingBuilder) WithPerColumn(padding []tw.Padding) *HeaderPaddingBuilder { + hp.config.PerColumn = padding + return hp +} + +// AddColumnPadding adds padding for a specific column in the header +func (hp *HeaderPaddingBuilder) AddColumnPadding(padding tw.Padding) *HeaderPaddingBuilder { + hp.config.PerColumn = append(hp.config.PerColumn, padding) + return hp +} + +// RowPaddingBuilder configures row padding type RowPaddingBuilder struct { - parent *RowConfigBuilder // Reference to the parent RowConfigBuilder - config *tw.CellPadding // Padding configuration being modified - section string // Section name for logging/debugging + parent *RowConfigBuilder + config *tw.CellPadding + section string } -// AddColumnPadding adds padding for a specific column in the rows. -func (rp *RowPaddingBuilder) AddColumnPadding(padding tw.Padding) *RowPaddingBuilder { - rp.config.PerColumn = append(rp.config.PerColumn, padding) - return rp -} - -// Build returns the parent RowConfigBuilder for chaining. +// Build returns the parent RowConfigBuilder func (rp *RowPaddingBuilder) Build() *RowConfigBuilder { return rp.parent } -// WithGlobal sets the global padding for all row cells. +// WithGlobal sets global padding func (rp *RowPaddingBuilder) WithGlobal(padding tw.Padding) *RowPaddingBuilder { rp.config.Global = padding return rp } -// WithPerColumn sets per-column padding for the rows. +// WithPerColumn sets per-column padding func (rp *RowPaddingBuilder) WithPerColumn(padding []tw.Padding) *RowPaddingBuilder { rp.config.PerColumn = padding return rp } -// NewConfigBuilder creates a new ConfigBuilder initialized with default settings. -func NewConfigBuilder() *ConfigBuilder { - return &ConfigBuilder{ - config: defaultConfig(), - } +// AddColumnPadding adds padding for a specific column in the rows +func (rp *RowPaddingBuilder) AddColumnPadding(padding tw.Padding) *RowPaddingBuilder { + rp.config.PerColumn = append(rp.config.PerColumn, padding) + return rp } -// NewWriter creates a new table with default settings for backward compatibility. -// It logs the creation if debugging is enabled. -func NewWriter(w io.Writer) *Table { - t := NewTable(w) - if t.logger != nil { - t.logger.Debug("NewWriter created buffered Table") - } - return t +// FooterPaddingBuilder configures footer padding +type FooterPaddingBuilder struct { + parent *FooterConfigBuilder + config *tw.CellPadding + section string } -// WithAutoHide enables or disables automatic hiding of columns with empty data rows. -// Logs the change if debugging is enabled. -func WithAutoHide(state tw.State) Option { - return func(target *Table) { - target.config.Behavior.AutoHide = state - if target.logger != nil { - target.logger.Debugf("Option: WithAutoHide applied to Table: %v", state) - } - } +// Build returns the parent FooterConfigBuilder +func (fp *FooterPaddingBuilder) Build() *FooterConfigBuilder { + return fp.parent } -// WithColumnMax sets a global maximum column width for the table in streaming mode. -// Negative values are ignored, and the change is logged if debugging is enabled. -func WithColumnMax(width int) Option { - return func(target *Table) { - if width < 0 { - return - } - target.config.Stream.Widths.Global = width - if target.logger != nil { - target.logger.Debugf("Option: WithColumnMax applied to Table: %v", width) - } - } +// WithGlobal sets global padding +func (fp *FooterPaddingBuilder) WithGlobal(padding tw.Padding) *FooterPaddingBuilder { + fp.config.Global = padding + return fp } -// WithTableMax sets a global maximum table width for the table -// Negative values are ignored, and the change is logged if debugging is enabled. -func WithTableMax(width int) Option { - return func(target *Table) { - if width < 0 { - return - } - target.config.MaxWidth = width - if target.logger != nil { - target.logger.Debugf("Option: WithTableMax applied to Table: %v", width) - } - } +// WithPerColumn sets per-column padding +func (fp *FooterPaddingBuilder) WithPerColumn(padding []tw.Padding) *FooterPaddingBuilder { + fp.config.PerColumn = padding + return fp } -// WithColumnWidths sets per-column widths for the table in streaming mode. -// Negative widths are removed, and the change is logged if debugging is enabled. -func WithColumnWidths(widths map[int]int) Option { - return func(target *Table) { - for k, v := range widths { - if v < 0 { - delete(widths, k) - } - } - target.config.Stream.Widths.PerColumn = widths - if target.logger != nil { - target.logger.Debugf("Option: WithColumnWidths applied to Table: %v", widths) - } - } +// AddColumnPadding adds padding for a specific column in the footer +func (fp *FooterPaddingBuilder) AddColumnPadding(padding tw.Padding) *FooterPaddingBuilder { + fp.config.PerColumn = append(fp.config.PerColumn, padding) + return fp } -// WithConfig applies a custom configuration to the table by merging it with the default configuration. -func WithConfig(cfg Config) Option { - return func(target *Table) { - target.config = mergeConfig(defaultConfig(), cfg) - } +// BehaviorConfigBuilder configures behavior settings +type BehaviorConfigBuilder struct { + parent *ConfigBuilder + config *tw.Behavior } -// WithDebug enables or disables debug logging and adjusts the logger level accordingly. -// Logs the change if debugging is enabled. -func WithDebug(debug bool) Option { - return func(target *Table) { - target.config.Debug = debug - } +// Build returns the parent ConfigBuilder +func (bb *BehaviorConfigBuilder) Build() *ConfigBuilder { + return bb.parent } -// WithFooter sets the table footers by calling the Footer method. -func WithFooter(footers []string) Option { - return func(target *Table) { - target.Footer(footers) - } +// WithAutoHide enables/disables auto-hide +func (bb *BehaviorConfigBuilder) WithAutoHide(state tw.State) *BehaviorConfigBuilder { + bb.config.AutoHide = state + return bb } -// WithFooterConfig applies a full footer configuration to the table. -// Logs the change if debugging is enabled. -func WithFooterConfig(config tw.CellConfig) Option { - return func(target *Table) { - target.config.Footer = config - if target.logger != nil { - target.logger.Debug("Option: WithFooterConfig applied to Table.") - } - } +// WithTrimSpace enables/disables trim space +func (bb *BehaviorConfigBuilder) WithTrimSpace(state tw.State) *BehaviorConfigBuilder { + bb.config.TrimSpace = state + return bb } -// WithFooterMergeMode sets the merge mode for footer cells. -// Invalid merge modes are ignored, and the change is logged if debugging is enabled. -func WithFooterMergeMode(mergeMode int) Option { - return func(target *Table) { - if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { - return - } - target.config.Footer.Formatting.MergeMode = mergeMode - if target.logger != nil { - target.logger.Debugf("Option: WithFooterMergeMode applied to Table: %v", mergeMode) - } - } +// WithHeaderHide enables/disables header visibility +func (bb *BehaviorConfigBuilder) WithHeaderHide(state tw.State) *BehaviorConfigBuilder { + bb.config.Header.Hide = state + return bb } -// WithHeader sets the table headers by calling the Header method. -func WithHeader(headers []string) Option { - return func(target *Table) { - target.Header(headers) - } +// WithFooterHide enables/disables footer visibility +func (bb *BehaviorConfigBuilder) WithFooterHide(state tw.State) *BehaviorConfigBuilder { + bb.config.Footer.Hide = state + return bb } -// WithHeaderAlignment sets the text alignment for header cells. -// Invalid alignments are ignored, and the change is logged if debugging is enabled. -func WithHeaderAlignment(align tw.Align) Option { - return func(target *Table) { - if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { - return - } - target.config.Header.Formatting.Alignment = align - if target.logger != nil { - target.logger.Debugf("Option: WithHeaderAlignment applied to Table: %v", align) - } - } +// WithCompactMerge enables/disables compact width optimization for merged cells +func (bb *BehaviorConfigBuilder) WithCompactMerge(state tw.State) *BehaviorConfigBuilder { + bb.config.Compact.Merge = state + return bb } -// WithHeaderConfig applies a full header configuration to the table. -// Logs the change if debugging is enabled. -func WithHeaderConfig(config tw.CellConfig) Option { - return func(target *Table) { - target.config.Header = config - if target.logger != nil { - target.logger.Debug("Option: WithHeaderConfig applied to Table.") - } - } +// ColumnConfigBuilder configures column-specific settings +type ColumnConfigBuilder struct { + parent *ConfigBuilder + col int } -// WithLogger sets a custom logger for the table and updates the renderer if present. -// Logs the change if debugging is enabled. -func WithLogger(logger *ll.Logger) Option { - return func(target *Table) { - target.logger = logger - if target.logger != nil { - target.logger.Debug("Option: WithLogger applied to Table.") - if target.renderer != nil { - target.renderer.Logger(target.logger) - } - } - } +// Build returns the parent ConfigBuilder +func (c *ColumnConfigBuilder) Build() *ConfigBuilder { + return c.parent } -// WithRenderer sets a custom renderer for the table and attaches the logger if present. -// Logs the change if debugging is enabled. -func WithRenderer(f tw.Renderer) Option { - return func(target *Table) { - target.renderer = f - if target.logger != nil { - target.logger.Debugf("Option: WithRenderer applied to Table: %T", f) - f.Logger(target.logger) +// WithAlignment sets alignment for the column +func (c *ColumnConfigBuilder) WithAlignment(align tw.Align) *ColumnConfigBuilder { + if err := align.Validate(); err == nil { + // Ensure slices are large enough + if len(c.parent.config.Header.Alignment.PerColumn) <= c.col { + newAligns := make([]tw.Align, c.col+1) + copy(newAligns, c.parent.config.Header.Alignment.PerColumn) + c.parent.config.Header.Alignment.PerColumn = newAligns } + c.parent.config.Header.Alignment.PerColumn[c.col] = align + + if len(c.parent.config.Row.Alignment.PerColumn) <= c.col { + newAligns := make([]tw.Align, c.col+1) + copy(newAligns, c.parent.config.Row.Alignment.PerColumn) + c.parent.config.Row.Alignment.PerColumn = newAligns + } + c.parent.config.Row.Alignment.PerColumn[c.col] = align + + if len(c.parent.config.Footer.Alignment.PerColumn) <= c.col { + newAligns := make([]tw.Align, c.col+1) + copy(newAligns, c.parent.config.Footer.Alignment.PerColumn) + c.parent.config.Footer.Alignment.PerColumn = newAligns + } + c.parent.config.Footer.Alignment.PerColumn[c.col] = align } + return c } -// WithRowConfig applies a full row configuration to the table. -// Logs the change if debugging is enabled. -func WithRowConfig(config tw.CellConfig) Option { - return func(target *Table) { - target.config.Row = config - if target.logger != nil { - target.logger.Debug("Option: WithRowConfig applied to Table.") +// WithMaxWidth sets max width for the column +func (c *ColumnConfigBuilder) WithMaxWidth(width int) *ColumnConfigBuilder { + if width >= 0 { + // Initialize maps if needed + if c.parent.config.Header.ColMaxWidths.PerColumn == nil { + c.parent.config.Header.ColMaxWidths.PerColumn = make(tw.Mapper[int, int]) + c.parent.config.Row.ColMaxWidths.PerColumn = make(tw.Mapper[int, int]) + c.parent.config.Footer.ColMaxWidths.PerColumn = make(tw.Mapper[int, int]) } + c.parent.config.Header.ColMaxWidths.PerColumn[c.col] = width + c.parent.config.Row.ColMaxWidths.PerColumn[c.col] = width + c.parent.config.Footer.ColMaxWidths.PerColumn[c.col] = width } + return c } -// WithRowMaxWidth sets the maximum content width for row cells. -// Negative values are ignored, and the change is logged if debugging is enabled. -func WithRowMaxWidth(maxWidth int) Option { - return func(target *Table) { - if maxWidth < 0 { - return - } - target.config.Row.ColMaxWidths.Global = maxWidth - if target.logger != nil { - target.logger.Debugf("Option: WithRowMaxWidth applied to Table: %v", maxWidth) - } - } +// HeaderFilterBuilder configures header filtering +type HeaderFilterBuilder struct { + parent *HeaderConfigBuilder + config *tw.CellFilter + section string } -// WithStreaming applies a streaming configuration to the table by merging it with the existing configuration. -// Logs the change if debugging is enabled. -func WithStreaming(c tw.StreamConfig) Option { - return func(target *Table) { - target.config.Stream = mergeStreamConfig(target.config.Stream, c) - if target.logger != nil { - target.logger.Debug("Option: WithStreaming applied to Table.") - } - } +// Build returns the parent HeaderConfigBuilder +func (hf *HeaderFilterBuilder) Build() *HeaderConfigBuilder { + return hf.parent } -// WithStringer sets a custom stringer function for converting row data and clears the stringer cache. -// Logs the change if debugging is enabled. -func WithStringer(stringer interface{}) Option { - return func(t *Table) { - t.stringer = stringer - t.stringerCacheMu.Lock() - t.stringerCache = make(map[reflect.Type]reflect.Value) - t.stringerCacheMu.Unlock() - t.logger.Debug("Stringer updated, cache cleared") +// WithGlobal sets the global filter function for the header +func (hf *HeaderFilterBuilder) WithGlobal(filter func([]string) []string) *HeaderFilterBuilder { + if filter != nil { + hf.config.Global = filter } + return hf } -// WithStringerCache enables caching for the stringer function. -func WithStringerCache() Option { - return func(t *Table) { - t.stringerCacheEnabled = true +// WithPerColumn sets per-column filter functions for the header +func (hf *HeaderFilterBuilder) WithPerColumn(filters []func(string) string) *HeaderFilterBuilder { + if len(filters) > 0 { + hf.config.PerColumn = filters } + return hf } -// WithSymbols sets the symbols used for table drawing and updates the renderer's configuration. -// Logs the change if debugging is enabled. -func WithSymbols(symbols tw.Symbols) Option { - return func(target *Table) { - if target.renderer != nil { - cfg := target.renderer.Config() - cfg.Symbols = symbols - if target.logger != nil { - target.logger.Debug("Option: WithSymbols applied to Table.") - } - } +// AddColumnFilter adds a filter function for a specific column in the header +func (hf *HeaderFilterBuilder) AddColumnFilter(filter func(string) string) *HeaderFilterBuilder { + if filter != nil { + hf.config.PerColumn = append(hf.config.PerColumn, filter) } + return hf } -// WithTrimSpace sets whether leading and trailing spaces are automatically trimmed. -// Logs the change if debugging is enabled. -func WithTrimSpace(state tw.State) Option { - return func(target *Table) { - target.config.Behavior.TrimSpace = state - if target.logger != nil { - target.logger.Debugf("Option: WithTrimSpace applied to Table: %v", state) - } - } +// RowFilterBuilder configures row filtering +type RowFilterBuilder struct { + parent *RowConfigBuilder + config *tw.CellFilter + section string } -func WithHeaderAutoFormat(state tw.State) Option { - return func(target *Table) { - target.config.Header.Formatting.AutoFormat = state - } +// Build returns the parent RowConfigBuilder +func (rf *RowFilterBuilder) Build() *RowConfigBuilder { + return rf.parent } -// WithHeaderControl sets the control behavior for the table header. -// Logs the change if debugging is enabled. -func WithHeaderControl(control tw.Control) Option { - return func(target *Table) { - target.config.Behavior.Header = control - if target.logger != nil { - target.logger.Debugf("Option: WithHeaderControl applied to Table: %v", control) // Fixed 'state' to 'control' - } +// WithGlobal sets the global filter function for the rows +func (rf *RowFilterBuilder) WithGlobal(filter func([]string) []string) *RowFilterBuilder { + if filter != nil { + rf.config.Global = filter } + return rf } -// WithFooterControl sets the control behavior for the table footer. -// Logs the change if debugging is enabled. -func WithFooterControl(control tw.Control) Option { - return func(target *Table) { - target.config.Behavior.Footer = control - if target.logger != nil { - target.logger.Debugf("Option: WithFooterControl applied to Table: %v", control) // Fixed log message and 'state' to 'control' - } +// WithPerColumn sets per-column filter functions for the rows +func (rf *RowFilterBuilder) WithPerColumn(filters []func(string) string) *RowFilterBuilder { + if len(filters) > 0 { + rf.config.PerColumn = filters } + return rf } -// WithAlignment sets the default column alignment for the header, rows, and footer. -func WithAlignment(alignment tw.Alignment) Option { - return func(target *Table) { - target.config.Header.ColumnAligns = alignment - target.config.Row.ColumnAligns = alignment - target.config.Footer.ColumnAligns = alignment +// AddColumnFilter adds a filter function for a specific column in the rows +func (rf *RowFilterBuilder) AddColumnFilter(filter func(string) string) *RowFilterBuilder { + if filter != nil { + rf.config.PerColumn = append(rf.config.PerColumn, filter) } + return rf } -// WithPadding sets the global padding for the header, rows, and footer. -func WithPadding(padding tw.Padding) Option { - return func(target *Table) { - target.config.Header.Padding.Global = padding - target.config.Row.Padding.Global = padding - target.config.Footer.Padding.Global = padding - } +// FooterFilterBuilder configures footer filtering +type FooterFilterBuilder struct { + parent *FooterConfigBuilder + config *tw.CellFilter + section string } -// WithRendition allows updating the active renderer's rendition configuration -// by merging the provided rendition. -// If the renderer does not implement tw.Renditioning, a warning is logged. -func WithRendition(rendition tw.Rendition) Option { - return func(target *Table) { - if target.renderer == nil { - target.logger.Warn("Option: WithRendition: No renderer set on table.") - return - } - - if ru, ok := target.renderer.(tw.Renditioning); ok { - ru.Rendition(rendition) - target.logger.Debugf("Option: WithRendition: Applied to renderer via Renditioning.SetRendition(): %+v", rendition) - } else { - target.logger.Warnf("Option: WithRendition: Current renderer type %T does not implement tw.Renditioning. Rendition may not be applied as expected.", target.renderer) - } - } +// Build returns the parent FooterConfigBuilder +func (ff *FooterFilterBuilder) Build() *FooterConfigBuilder { + return ff.parent } -// defaultConfig returns a default Config with sensible settings for headers, rows, footers, and behavior. -func defaultConfig() Config { - defaultPadding := tw.Padding{Left: tw.Space, Right: tw.Space, Top: tw.Empty, Bottom: tw.Empty} - return Config{ - MaxWidth: 0, - Header: tw.CellConfig{ - Formatting: tw.CellFormatting{ - AutoWrap: tw.WrapTruncate, - Alignment: tw.AlignCenter, - AutoFormat: tw.On, - MergeMode: tw.MergeNone, - }, - Padding: tw.CellPadding{ - Global: defaultPadding, - }, - }, - Row: tw.CellConfig{ - Formatting: tw.CellFormatting{ - AutoWrap: tw.WrapNormal, - Alignment: tw.AlignLeft, - AutoFormat: tw.Off, - MergeMode: tw.MergeNone, - }, - Padding: tw.CellPadding{ - Global: defaultPadding, - }, - }, - Footer: tw.CellConfig{ - Formatting: tw.CellFormatting{ - AutoWrap: tw.WrapNormal, - Alignment: tw.AlignRight, - AutoFormat: tw.Off, - MergeMode: tw.MergeNone, - }, - Padding: tw.CellPadding{ - Global: defaultPadding, - }, - }, - Stream: tw.StreamConfig{}, - Debug: false, - Behavior: Behavior{ - AutoHide: tw.Off, - TrimSpace: tw.On, - }, +// WithGlobal sets the global filter function for the footer +func (ff *FooterFilterBuilder) WithGlobal(filter func([]string) []string) *FooterFilterBuilder { + if filter != nil { + ff.config.Global = filter } + return ff } -// mergeCellConfig merges a source CellConfig into a destination CellConfig, prioritizing non-default source values. -// It handles deep merging for complex fields like padding and callbacks. -func mergeCellConfig(dst, src tw.CellConfig) tw.CellConfig { - if src.Formatting.Alignment != tw.Empty { - dst.Formatting.Alignment = src.Formatting.Alignment +// WithPerColumn sets per-column filter functions for the footer +func (ff *FooterFilterBuilder) WithPerColumn(filters []func(string) string) *FooterFilterBuilder { + if len(filters) > 0 { + ff.config.PerColumn = filters } - if src.Formatting.AutoWrap != 0 { - dst.Formatting.AutoWrap = src.Formatting.AutoWrap - } - if src.ColMaxWidths.Global != 0 { - dst.ColMaxWidths.Global = src.ColMaxWidths.Global - } - if src.Formatting.MergeMode != 0 { - dst.Formatting.MergeMode = src.Formatting.MergeMode - } - - dst.Formatting.AutoFormat = src.Formatting.AutoFormat - - if src.Padding.Global != (tw.Padding{}) { - dst.Padding.Global = src.Padding.Global - } - if len(src.Padding.PerColumn) > 0 { - if dst.Padding.PerColumn == nil { - dst.Padding.PerColumn = make([]tw.Padding, len(src.Padding.PerColumn)) - } else if len(src.Padding.PerColumn) > len(dst.Padding.PerColumn) { - dst.Padding.PerColumn = append(dst.Padding.PerColumn, make([]tw.Padding, len(src.Padding.PerColumn)-len(dst.Padding.PerColumn))...) - } - for i, pad := range src.Padding.PerColumn { - if pad != (tw.Padding{}) { - dst.Padding.PerColumn[i] = pad - } - } - } - if src.Callbacks.Global != nil { - dst.Callbacks.Global = src.Callbacks.Global - } - if len(src.Callbacks.PerColumn) > 0 { - if dst.Callbacks.PerColumn == nil { - dst.Callbacks.PerColumn = make([]func(), len(src.Callbacks.PerColumn)) - } else if len(src.Callbacks.PerColumn) > len(dst.Callbacks.PerColumn) { - dst.Callbacks.PerColumn = append(dst.Callbacks.PerColumn, make([]func(), len(src.Callbacks.PerColumn)-len(dst.Callbacks.PerColumn))...) - } - for i, cb := range src.Callbacks.PerColumn { - if cb != nil { - dst.Callbacks.PerColumn[i] = cb - } - } - } - if src.Filter.Global != nil { - dst.Filter.Global = src.Filter.Global - } - if len(src.Filter.PerColumn) > 0 { - if dst.Filter.PerColumn == nil { - dst.Filter.PerColumn = make([]func(string) string, len(src.Filter.PerColumn)) - } else if len(src.Filter.PerColumn) > len(dst.Filter.PerColumn) { - dst.Filter.PerColumn = append(dst.Filter.PerColumn, make([]func(string) string, len(src.Filter.PerColumn)-len(dst.Filter.PerColumn))...) - } - for i, filter := range src.Filter.PerColumn { - if filter != nil { - dst.Filter.PerColumn[i] = filter - } - } - } - if len(src.ColumnAligns) > 0 { - if dst.ColumnAligns == nil { - dst.ColumnAligns = make([]tw.Align, len(src.ColumnAligns)) - } else if len(src.ColumnAligns) > len(dst.ColumnAligns) { - dst.ColumnAligns = append(dst.ColumnAligns, make([]tw.Align, len(src.ColumnAligns)-len(dst.ColumnAligns))...) - } - for i, align := range src.ColumnAligns { - if align != tw.Empty && align != tw.Skip { - dst.ColumnAligns[i] = align - } - } - } - if len(src.ColMaxWidths.PerColumn) > 0 { - if dst.ColMaxWidths.PerColumn == nil { - dst.ColMaxWidths.PerColumn = make(map[int]int) - } - for k, v := range src.ColMaxWidths.PerColumn { - if v != 0 { - dst.ColMaxWidths.PerColumn[k] = v - } - } - } - return dst + return ff } -// mergeConfig merges a source Config into a destination Config, prioritizing non-default source values. -// It performs deep merging for complex types like Header, Row, Footer, and Stream. -func mergeConfig(dst, src Config) Config { - if src.MaxWidth != 0 { - dst.MaxWidth = src.MaxWidth +// AddColumnFilter adds a filter function for a specific column in the footer +func (ff *FooterFilterBuilder) AddColumnFilter(filter func(string) string) *FooterFilterBuilder { + if filter != nil { + ff.config.PerColumn = append(ff.config.PerColumn, filter) } - dst.Debug = src.Debug || dst.Debug - dst.Behavior.AutoHide = src.Behavior.AutoHide - dst.Behavior.TrimSpace = src.Behavior.TrimSpace - dst.Header = mergeCellConfig(dst.Header, src.Header) - dst.Row = mergeCellConfig(dst.Row, src.Row) - dst.Footer = mergeCellConfig(dst.Footer, src.Footer) - dst.Stream = mergeStreamConfig(dst.Stream, src.Stream) - - return dst + return ff } -// mergeStreamConfig merges a source StreamConfig into a destination StreamConfig, prioritizing non-default source values. -func mergeStreamConfig(dst, src tw.StreamConfig) tw.StreamConfig { - if src.Enable { - dst.Enable = true - } - if src.Widths.Global != 0 { - dst.Widths.Global = src.Widths.Global - } - if len(src.Widths.PerColumn) > 0 { - if dst.Widths.PerColumn == nil { - dst.Widths.PerColumn = make(map[int]int) - } - for k, v := range src.Widths.PerColumn { - if v != 0 { - dst.Widths.PerColumn[k] = v - } - } - } - return dst +// HeaderCallbacksBuilder configures header callbacks +type HeaderCallbacksBuilder struct { + parent *HeaderConfigBuilder + config *tw.CellCallbacks + section string } -// padLine pads a line to the specified column count by appending empty strings as needed. -func padLine(line []string, numCols int) []string { - if len(line) >= numCols { - return line - } - padded := make([]string, numCols) - copy(padded, line) - for i := len(line); i < numCols; i++ { - padded[i] = tw.Empty - } - return padded +// Build returns the parent HeaderConfigBuilder +func (hc *HeaderCallbacksBuilder) Build() *HeaderConfigBuilder { + return hc.parent +} + +// WithGlobal sets the global callback function for the header +func (hc *HeaderCallbacksBuilder) WithGlobal(callback func()) *HeaderCallbacksBuilder { + if callback != nil { + hc.config.Global = callback + } + return hc +} + +// WithPerColumn sets per-column callback functions for the header +func (hc *HeaderCallbacksBuilder) WithPerColumn(callbacks []func()) *HeaderCallbacksBuilder { + if len(callbacks) > 0 { + hc.config.PerColumn = callbacks + } + return hc +} + +// AddColumnCallback adds a callback function for a specific column in the header +func (hc *HeaderCallbacksBuilder) AddColumnCallback(callback func()) *HeaderCallbacksBuilder { + if callback != nil { + hc.config.PerColumn = append(hc.config.PerColumn, callback) + } + return hc +} + +// RowCallbacksBuilder configures row callbacks +type RowCallbacksBuilder struct { + parent *RowConfigBuilder + config *tw.CellCallbacks + section string +} + +// Build returns the parent RowConfigBuilder +func (rc *RowCallbacksBuilder) Build() *RowConfigBuilder { + return rc.parent +} + +// WithGlobal sets the global callback function for the rows +func (rc *RowCallbacksBuilder) WithGlobal(callback func()) *RowCallbacksBuilder { + if callback != nil { + rc.config.Global = callback + } + return rc +} + +// WithPerColumn sets per-column callback functions for the rows +func (rc *RowCallbacksBuilder) WithPerColumn(callbacks []func()) *RowCallbacksBuilder { + if len(callbacks) > 0 { + rc.config.PerColumn = callbacks + } + return rc +} + +// AddColumnCallback adds a callback function for a specific column in the rows +func (rc *RowCallbacksBuilder) AddColumnCallback(callback func()) *RowCallbacksBuilder { + if callback != nil { + rc.config.PerColumn = append(rc.config.PerColumn, callback) + } + return rc +} + +// FooterCallbacksBuilder configures footer callbacks +type FooterCallbacksBuilder struct { + parent *FooterConfigBuilder + config *tw.CellCallbacks + section string +} + +// Build returns the parent FooterConfigBuilder +func (fc *FooterCallbacksBuilder) Build() *FooterConfigBuilder { + return fc.parent +} + +// WithGlobal sets the global callback function for the footer +func (fc *FooterCallbacksBuilder) WithGlobal(callback func()) *FooterCallbacksBuilder { + if callback != nil { + fc.config.Global = callback + } + return fc +} + +// WithPerColumn sets per-column callback functions for the footer +func (fc *FooterCallbacksBuilder) WithPerColumn(callbacks []func()) *FooterCallbacksBuilder { + if len(callbacks) > 0 { + fc.config.PerColumn = callbacks + } + return fc +} + +// AddColumnCallback adds a callback function for a specific column in the footer +func (fc *FooterCallbacksBuilder) AddColumnCallback(callback func()) *FooterCallbacksBuilder { + if callback != nil { + fc.config.PerColumn = append(fc.config.PerColumn, callback) + } + return fc } diff --git a/vendor/github.com/olekukonko/tablewriter/deprecated.go b/vendor/github.com/olekukonko/tablewriter/deprecated.go index 3958a25b3a..b61d507ac8 100644 --- a/vendor/github.com/olekukonko/tablewriter/deprecated.go +++ b/vendor/github.com/olekukonko/tablewriter/deprecated.go @@ -2,9 +2,27 @@ package tablewriter import "github.com/olekukonko/tablewriter/tw" -// Deprecated: WithBorders is no longer used. -// Border control has been moved to the renderer, which now manages its own borders. -// This Option has no effect on the Table and may be removed in future versions. +// WithBorders configures the table's border settings by updating the renderer's border configuration. +// This function is deprecated and will be removed in a future version. +// +// Deprecated: Use [WithRendition] to configure border settings for renderers that support +// [tw.Renditioning], or update the renderer's [tw.RenderConfig] directly via its Config() method. +// This function has no effect if no renderer is set on the table. +// +// Example migration: +// +// // Old (deprecated) +// table.Options(WithBorders(tw.Border{Top: true, Bottom: true})) +// // New (recommended) +// table.Options(WithRendition(tw.Rendition{Borders: tw.Border{Top: true, Bottom: true}})) +// +// Parameters: +// - borders: The [tw.Border] configuration to apply to the renderer's borders. +// +// Returns: +// +// An [Option] that updates the renderer's border settings if a renderer is set. +// Logs a debug message if debugging is enabled and a renderer is present. func WithBorders(borders tw.Border) Option { return func(target *Table) { if target.renderer != nil { @@ -17,16 +35,55 @@ func WithBorders(borders tw.Border) Option { } } -// Deprecated: WithBorders is no longer supported. -// Use [tw.Behavior] directly to configure border settings. +// Behavior is an alias for [tw.Behavior] to configure table behavior settings. +// This type is deprecated and will be removed in a future version. +// +// Deprecated: Use [tw.Behavior] directly to configure settings such as auto-hiding empty +// columns, trimming spaces, or controlling header/footer visibility. +// +// Example migration: +// +// // Old (deprecated) +// var b tablewriter.Behavior = tablewriter.Behavior{AutoHide: tw.On} +// // New (recommended) +// var b tw.Behavior = tw.Behavior{AutoHide: tw.On} type Behavior tw.Behavior -// Deprecated: WithRendererSettings i sno longer supported. +// Settings is an alias for [tw.Settings] to configure renderer settings. +// This type is deprecated and will be removed in a future version. +// +// Deprecated: Use [tw.Settings] directly to configure renderer settings, such as +// separators and line styles. +// +// Example migration: +// +// // Old (deprecated) +// var s tablewriter.Settings = tablewriter.Settings{Separator: "|"} +// // New (recommended) +// var s tw.Settings = tw.Settings{Separator: "|"} type Settings tw.Settings -// WithRendererSettings updates the renderer's settings (e.g., separators, lines). -// Render setting has move to renders directly -// you can also use WithRendition for renders that have rendition support +// WithRendererSettings updates the renderer's settings, such as separators and line styles. +// This function is deprecated and will be removed in a future version. +// +// Deprecated: Use [WithRendition] to update renderer settings for renderers that implement +// [tw.Renditioning], or configure the renderer's [tw.Settings] directly via its +// [tw.Renderer.Config] method. This function has no effect if no renderer is set. +// +// Example migration: +// +// // Old (deprecated) +// table.Options(WithRendererSettings(tw.Settings{Separator: "|"})) +// // New (recommended) +// table.Options(WithRendition(tw.Rendition{Settings: tw.Settings{Separator: "|"}})) +// +// Parameters: +// - settings: The [tw.Settings] configuration to apply to the renderer. +// +// Returns: +// +// An [Option] that updates the renderer's settings if a renderer is set. +// Logs a debug message if debugging is enabled and a renderer is present. func WithRendererSettings(settings tw.Settings) Option { return func(target *Table) { if target.renderer != nil { @@ -38,3 +95,124 @@ func WithRendererSettings(settings tw.Settings) Option { } } } + +// WithAlignment sets the text alignment for footer cells within the formatting configuration. +// This method is deprecated and will be removed in the next version. +// +// Deprecated: Use [FooterConfigBuilder.Alignment] with [AlignmentConfigBuilder.WithGlobal] +// or [AlignmentConfigBuilder.WithPerColumn] to configure footer alignments. +// Alternatively, apply a complete [tw.CellAlignment] configuration using +// [WithFooterAlignmentConfig]. +// +// Example migration: +// +// // Old (deprecated) +// builder.Footer().Formatting().WithAlignment(tw.AlignRight) +// // New (recommended) +// builder.Footer().Alignment().WithGlobal(tw.AlignRight) +// // Or +// table.Options(WithFooterAlignmentConfig(tw.CellAlignment{Global: tw.AlignRight})) +// +// Parameters: +// - align: The [tw.Align] value to set for footer cells. Valid values are +// [tw.AlignLeft], [tw.AlignRight], [tw.AlignCenter], and [tw.AlignNone]. +// Invalid alignments are ignored. +// +// Returns: +// +// The [FooterFormattingBuilder] instance for method chaining. +func (ff *FooterFormattingBuilder) WithAlignment(align tw.Align) *FooterFormattingBuilder { + if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { + return ff + } + ff.config.Alignment = align + return ff +} + +// WithAlignment sets the text alignment for header cells within the formatting configuration. +// This method is deprecated and will be removed in the next version. +// +// Deprecated: Use [HeaderConfigBuilder.Alignment] with [AlignmentConfigBuilder.WithGlobal] +// or [AlignmentConfigBuilder.WithPerColumn] to configure header alignments. +// Alternatively, apply a complete [tw.CellAlignment] configuration using +// [WithHeaderAlignmentConfig]. +// +// Example migration: +// +// // Old (deprecated) +// builder.Header().Formatting().WithAlignment(tw.AlignCenter) +// // New (recommended) +// builder.Header().Alignment().WithGlobal(tw.AlignCenter) +// // Or +// table.Options(WithHeaderAlignmentConfig(tw.CellAlignment{Global: tw.AlignCenter})) +// +// Parameters: +// - align: The [tw.Align] value to set for header cells. Valid values are +// [tw.AlignLeft], [tw.AlignRight], [tw.AlignCenter], and [tw.AlignNone]. +// Invalid alignments are ignored. +// +// Returns: +// +// The [HeaderFormattingBuilder] instance for method chaining. +func (hf *HeaderFormattingBuilder) WithAlignment(align tw.Align) *HeaderFormattingBuilder { + if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { + return hf + } + hf.config.Alignment = align + return hf +} + +// WithAlignment sets the text alignment for row cells within the formatting configuration. +// This method is deprecated and will be removed in the next version. +// +// Deprecated: Use [RowConfigBuilder.Alignment] with [AlignmentConfigBuilder.WithGlobal] +// or [AlignmentConfigBuilder.WithPerColumn] to configure row alignments. +// Alternatively, apply a complete [tw.CellAlignment] configuration using +// [WithRowAlignmentConfig]. +// +// Example migration: +// +// // Old (deprecated) +// builder.Row().Formatting().WithAlignment(tw.AlignLeft) +// // New (recommended) +// builder.Row().Alignment().WithGlobal(tw.AlignLeft) +// // Or +// table.Options(WithRowAlignmentConfig(tw.CellAlignment{Global: tw.AlignLeft})) +// +// Parameters: +// - align: The [tw.Align] value to set for row cells. Valid values are +// [tw.AlignLeft], [tw.AlignRight], [tw.AlignCenter], and [tw.AlignNone]. +// Invalid alignments are ignored. +// +// Returns: +// +// The [RowFormattingBuilder] instance for method chaining. +func (rf *RowFormattingBuilder) WithAlignment(align tw.Align) *RowFormattingBuilder { + if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { + return rf + } + rf.config.Alignment = align + return rf +} + +// WithTableMax sets the maximum width of the entire table in characters. +// Negative values are ignored, and the change is logged if debugging is enabled. +// The width constrains the table's rendering, potentially causing text wrapping or truncation +// based on the configuration's wrapping settings (e.g., tw.WrapTruncate). +// If debug logging is enabled via WithDebug(true), the applied width is logged. +// +// Deprecated: Use WithMaxWidth instead, which provides the same functionality with a clearer name +// and consistent naming across the package. For example: +// +// tablewriter.NewTable(os.Stdout, tablewriter.WithMaxWidth(80)) +func WithTableMax(width int) Option { + return func(target *Table) { + if width < 0 { + return + } + target.config.MaxWidth = width + if target.logger != nil { + target.logger.Debugf("Option: WithTableMax applied to Table: %v", width) + } + } +} diff --git a/vendor/github.com/olekukonko/tablewriter/option.go b/vendor/github.com/olekukonko/tablewriter/option.go new file mode 100644 index 0000000000..1302462cd2 --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/option.go @@ -0,0 +1,859 @@ +package tablewriter + +import ( + "github.com/olekukonko/ll" + "github.com/olekukonko/tablewriter/tw" + "reflect" +) + +// Option defines a function type for configuring a Table instance. +type Option func(target *Table) + +// WithAutoHide enables or disables automatic hiding of columns with empty data rows. +// Logs the change if debugging is enabled. +func WithAutoHide(state tw.State) Option { + return func(target *Table) { + target.config.Behavior.AutoHide = state + if target.logger != nil { + target.logger.Debugf("Option: WithAutoHide applied to Table: %v", state) + } + } +} + +// WithColumnMax sets a global maximum column width for the table in streaming mode. +// Negative values are ignored, and the change is logged if debugging is enabled. +func WithColumnMax(width int) Option { + return func(target *Table) { + if width < 0 { + return + } + target.config.Widths.Global = width + if target.logger != nil { + target.logger.Debugf("Option: WithColumnMax applied to Table: %v", width) + } + } +} + +// WithMaxWidth sets a global maximum table width for the table. +// Negative values are ignored, and the change is logged if debugging is enabled. +func WithMaxWidth(width int) Option { + return func(target *Table) { + if width < 0 { + return + } + target.config.MaxWidth = width + if target.logger != nil { + target.logger.Debugf("Option: WithTableMax applied to Table: %v", width) + } + } +} + +// WithWidths sets per-column widths for the table. +// Negative widths are removed, and the change is logged if debugging is enabled. +func WithWidths(width tw.CellWidth) Option { + return func(target *Table) { + target.config.Widths = width + if target.logger != nil { + target.logger.Debugf("Option: WithColumnWidths applied to Table: %v", width) + } + } +} + +// WithColumnWidths sets per-column widths for the table. +// Negative widths are removed, and the change is logged if debugging is enabled. +func WithColumnWidths(widths tw.Mapper[int, int]) Option { + return func(target *Table) { + for k, v := range widths { + if v < 0 { + delete(widths, k) + } + } + target.config.Widths.PerColumn = widths + if target.logger != nil { + target.logger.Debugf("Option: WithColumnWidths applied to Table: %v", widths) + } + } +} + +// WithConfig applies a custom configuration to the table by merging it with the default configuration. +func WithConfig(cfg Config) Option { + return func(target *Table) { + target.config = mergeConfig(defaultConfig(), cfg) + } +} + +// WithDebug enables or disables debug logging and adjusts the logger level accordingly. +// Logs the change if debugging is enabled. +func WithDebug(debug bool) Option { + return func(target *Table) { + target.config.Debug = debug + } +} + +// WithFooter sets the table footers by calling the Footer method. +func WithFooter(footers []string) Option { + return func(target *Table) { + target.Footer(footers) + } +} + +// WithFooterConfig applies a full footer configuration to the table. +// Logs the change if debugging is enabled. +func WithFooterConfig(config tw.CellConfig) Option { + return func(target *Table) { + target.config.Footer = config + if target.logger != nil { + target.logger.Debug("Option: WithFooterConfig applied to Table.") + } + } +} + +// WithFooterAlignmentConfig applies a footer alignment configuration to the table. +// Logs the change if debugging is enabled. +func WithFooterAlignmentConfig(alignment tw.CellAlignment) Option { + return func(target *Table) { + target.config.Footer.Alignment = alignment + if target.logger != nil { + target.logger.Debugf("Option: WithFooterAlignmentConfig applied to Table: %+v", alignment) + } + } +} + +// WithFooterMergeMode sets the merge mode for footer cells. +// Invalid merge modes are ignored, and the change is logged if debugging is enabled. +func WithFooterMergeMode(mergeMode int) Option { + return func(target *Table) { + if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { + return + } + target.config.Footer.Formatting.MergeMode = mergeMode + if target.logger != nil { + target.logger.Debugf("Option: WithFooterMergeMode applied to Table: %v", mergeMode) + } + } +} + +// WithFooterAutoWrap sets the wrapping behavior for footer cells. +// Invalid wrap modes are ignored, and the change is logged if debugging is enabled. +func WithFooterAutoWrap(wrap int) Option { + return func(target *Table) { + if wrap < tw.WrapNone || wrap > tw.WrapBreak { + return + } + target.config.Footer.Formatting.AutoWrap = wrap + if target.logger != nil { + target.logger.Debugf("Option: WithFooterAutoWrap applied to Table: %v", wrap) + } + } +} + +// WithFooterFilter sets the filter configuration for footer cells. +// Logs the change if debugging is enabled. +func WithFooterFilter(filter tw.CellFilter) Option { + return func(target *Table) { + target.config.Footer.Filter = filter + if target.logger != nil { + target.logger.Debug("Option: WithFooterFilter applied to Table.") + } + } +} + +// WithFooterCallbacks sets the callback configuration for footer cells. +// Logs the change if debugging is enabled. +func WithFooterCallbacks(callbacks tw.CellCallbacks) Option { + return func(target *Table) { + target.config.Footer.Callbacks = callbacks + if target.logger != nil { + target.logger.Debug("Option: WithFooterCallbacks applied to Table.") + } + } +} + +// WithFooterPaddingPerColumn sets per-column padding for footer cells. +// Logs the change if debugging is enabled. +func WithFooterPaddingPerColumn(padding []tw.Padding) Option { + return func(target *Table) { + target.config.Footer.Padding.PerColumn = padding + if target.logger != nil { + target.logger.Debugf("Option: WithFooterPaddingPerColumn applied to Table: %+v", padding) + } + } +} + +// WithFooterMaxWidth sets the maximum content width for footer cells. +// Negative values are ignored, and the change is logged if debugging is enabled. +func WithFooterMaxWidth(maxWidth int) Option { + return func(target *Table) { + if maxWidth < 0 { + return + } + target.config.Footer.ColMaxWidths.Global = maxWidth + if target.logger != nil { + target.logger.Debugf("Option: WithFooterMaxWidth applied to Table: %v", maxWidth) + } + } +} + +// WithHeader sets the table headers by calling the Header method. +func WithHeader(headers []string) Option { + return func(target *Table) { + target.Header(headers) + } +} + +// WithHeaderAlignment sets the text alignment for header cells. +// Invalid alignments are ignored, and the change is logged if debugging is enabled. +func WithHeaderAlignment(align tw.Align) Option { + return func(target *Table) { + if align != tw.AlignLeft && align != tw.AlignRight && align != tw.AlignCenter && align != tw.AlignNone { + return + } + target.config.Header.Alignment.Global = align + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderAlignment applied to Table: %v", align) + } + } +} + +// WithHeaderAutoWrap sets the wrapping behavior for header cells. +// Invalid wrap modes are ignored, and the change is logged if debugging is enabled. +func WithHeaderAutoWrap(wrap int) Option { + return func(target *Table) { + if wrap < tw.WrapNone || wrap > tw.WrapBreak { + return + } + target.config.Header.Formatting.AutoWrap = wrap + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderAutoWrap applied to Table: %v", wrap) + } + } +} + +// WithHeaderMergeMode sets the merge mode for header cells. +// Invalid merge modes are ignored, and the change is logged if debugging is enabled. +func WithHeaderMergeMode(mergeMode int) Option { + return func(target *Table) { + if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { + return + } + target.config.Header.Formatting.MergeMode = mergeMode + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderMergeMode applied to Table: %v", mergeMode) + } + } +} + +// WithHeaderFilter sets the filter configuration for header cells. +// Logs the change if debugging is enabled. +func WithHeaderFilter(filter tw.CellFilter) Option { + return func(target *Table) { + target.config.Header.Filter = filter + if target.logger != nil { + target.logger.Debug("Option: WithHeaderFilter applied to Table.") + } + } +} + +// WithHeaderCallbacks sets the callback configuration for header cells. +// Logs the change if debugging is enabled. +func WithHeaderCallbacks(callbacks tw.CellCallbacks) Option { + return func(target *Table) { + target.config.Header.Callbacks = callbacks + if target.logger != nil { + target.logger.Debug("Option: WithHeaderCallbacks applied to Table.") + } + } +} + +// WithHeaderPaddingPerColumn sets per-column padding for header cells. +// Logs the change if debugging is enabled. +func WithHeaderPaddingPerColumn(padding []tw.Padding) Option { + return func(target *Table) { + target.config.Header.Padding.PerColumn = padding + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderPaddingPerColumn applied to Table: %+v", padding) + } + } +} + +// WithHeaderMaxWidth sets the maximum content width for header cells. +// Negative values are ignored, and the change is logged if debugging is enabled. +func WithHeaderMaxWidth(maxWidth int) Option { + return func(target *Table) { + if maxWidth < 0 { + return + } + target.config.Header.ColMaxWidths.Global = maxWidth + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderMaxWidth applied to Table: %v", maxWidth) + } + } +} + +// WithRowAlignment sets the text alignment for row cells. +// Invalid alignments are ignored, and the change is logged if debugging is enabled. +func WithRowAlignment(align tw.Align) Option { + return func(target *Table) { + if err := align.Validate(); err != nil { + return + } + target.config.Row.Alignment.Global = align + if target.logger != nil { + target.logger.Debugf("Option: WithRowAlignment applied to Table: %v", align) + } + } +} + +// WithRowAutoWrap sets the wrapping behavior for row cells. +// Invalid wrap modes are ignored, and the change is logged if debugging is enabled. +func WithRowAutoWrap(wrap int) Option { + return func(target *Table) { + if wrap < tw.WrapNone || wrap > tw.WrapBreak { + return + } + target.config.Row.Formatting.AutoWrap = wrap + if target.logger != nil { + target.logger.Debugf("Option: WithRowAutoWrap applied to Table: %v", wrap) + } + } +} + +// WithRowMergeMode sets the merge mode for row cells. +// Invalid merge modes are ignored, and the change is logged if debugging is enabled. +func WithRowMergeMode(mergeMode int) Option { + return func(target *Table) { + if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { + return + } + target.config.Row.Formatting.MergeMode = mergeMode + if target.logger != nil { + target.logger.Debugf("Option: WithRowMergeMode applied to Table: %v", mergeMode) + } + } +} + +// WithRowFilter sets the filter configuration for row cells. +// Logs the change if debugging is enabled. +func WithRowFilter(filter tw.CellFilter) Option { + return func(target *Table) { + target.config.Row.Filter = filter + if target.logger != nil { + target.logger.Debug("Option: WithRowFilter applied to Table.") + } + } +} + +// WithRowCallbacks sets the callback configuration for row cells. +// Logs the change if debugging is enabled. +func WithRowCallbacks(callbacks tw.CellCallbacks) Option { + return func(target *Table) { + target.config.Row.Callbacks = callbacks + if target.logger != nil { + target.logger.Debug("Option: WithRowCallbacks applied to Table.") + } + } +} + +// WithRowPaddingPerColumn sets per-column padding for row cells. +// Logs the change if debugging is enabled. +func WithRowPaddingPerColumn(padding []tw.Padding) Option { + return func(target *Table) { + target.config.Row.Padding.PerColumn = padding + if target.logger != nil { + target.logger.Debugf("Option: WithRowPaddingPerColumn applied to Table: %+v", padding) + } + } +} + +// WithHeaderAlignmentConfig applies a header alignment configuration to the table. +// Logs the change if debugging is enabled. +func WithHeaderAlignmentConfig(alignment tw.CellAlignment) Option { + return func(target *Table) { + target.config.Header.Alignment = alignment + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderAlignmentConfig applied to Table: %+v", alignment) + } + } +} + +// WithHeaderConfig applies a full header configuration to the table. +// Logs the change if debugging is enabled. +func WithHeaderConfig(config tw.CellConfig) Option { + return func(target *Table) { + target.config.Header = config + if target.logger != nil { + target.logger.Debug("Option: WithHeaderConfig applied to Table.") + } + } +} + +// WithLogger sets a custom logger for the table and updates the renderer if present. +// Logs the change if debugging is enabled. +func WithLogger(logger *ll.Logger) Option { + return func(target *Table) { + target.logger = logger + if target.logger != nil { + target.logger.Debug("Option: WithLogger applied to Table.") + if target.renderer != nil { + target.renderer.Logger(target.logger) + } + } + } +} + +// WithRenderer sets a custom renderer for the table and attaches the logger if present. +// Logs the change if debugging is enabled. +func WithRenderer(f tw.Renderer) Option { + return func(target *Table) { + target.renderer = f + if target.logger != nil { + target.logger.Debugf("Option: WithRenderer applied to Table: %T", f) + f.Logger(target.logger) + } + } +} + +// WithRowConfig applies a full row configuration to the table. +// Logs the change if debugging is enabled. +func WithRowConfig(config tw.CellConfig) Option { + return func(target *Table) { + target.config.Row = config + if target.logger != nil { + target.logger.Debug("Option: WithRowConfig applied to Table.") + } + } +} + +// WithRowAlignmentConfig applies a row alignment configuration to the table. +// Logs the change if debugging is enabled. +func WithRowAlignmentConfig(alignment tw.CellAlignment) Option { + return func(target *Table) { + target.config.Row.Alignment = alignment + if target.logger != nil { + target.logger.Debugf("Option: WithRowAlignmentConfig applied to Table: %+v", alignment) + } + } +} + +// WithRowMaxWidth sets the maximum content width for row cells. +// Negative values are ignored, and the change is logged if debugging is enabled. +func WithRowMaxWidth(maxWidth int) Option { + return func(target *Table) { + if maxWidth < 0 { + return + } + target.config.Row.ColMaxWidths.Global = maxWidth + if target.logger != nil { + target.logger.Debugf("Option: WithRowMaxWidth applied to Table: %v", maxWidth) + } + } +} + +// WithStreaming applies a streaming configuration to the table by merging it with the existing configuration. +// Logs the change if debugging is enabled. +func WithStreaming(c tw.StreamConfig) Option { + return func(target *Table) { + target.config.Stream = mergeStreamConfig(target.config.Stream, c) + if target.logger != nil { + target.logger.Debug("Option: WithStreaming applied to Table.") + } + } +} + +// WithStringer sets a custom stringer function for converting row data and clears the stringer cache. +// Logs the change if debugging is enabled. +func WithStringer(stringer interface{}) Option { + return func(t *Table) { + t.stringer = stringer + t.stringerCacheMu.Lock() + t.stringerCache = make(map[reflect.Type]reflect.Value) + t.stringerCacheMu.Unlock() + if t.logger != nil { + t.logger.Debug("Stringer updated, cache cleared") + } + } +} + +// WithStringerCache enables caching for the stringer function. +// Logs the change if debugging is enabled. +func WithStringerCache() Option { + return func(t *Table) { + t.stringerCacheEnabled = true + if t.logger != nil { + t.logger.Debug("Option: WithStringerCache enabled") + } + } +} + +// WithTrimSpace sets whether leading and trailing spaces are automatically trimmed. +// Logs the change if debugging is enabled. +func WithTrimSpace(state tw.State) Option { + return func(target *Table) { + target.config.Behavior.TrimSpace = state + if target.logger != nil { + target.logger.Debugf("Option: WithTrimSpace applied to Table: %v", state) + } + } +} + +// WithHeaderAutoFormat enables or disables automatic formatting for header cells. +// Logs the change if debugging is enabled. +func WithHeaderAutoFormat(state tw.State) Option { + return func(target *Table) { + target.config.Header.Formatting.AutoFormat = state + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderAutoFormat applied to Table: %v", state) + } + } +} + +// WithFooterAutoFormat enables or disables automatic formatting for footer cells. +// Logs the change if debugging is enabled. +func WithFooterAutoFormat(state tw.State) Option { + return func(target *Table) { + target.config.Footer.Formatting.AutoFormat = state + if target.logger != nil { + target.logger.Debugf("Option: WithFooterAutoFormat applied to Table: %v", state) + } + } +} + +// WithRowAutoFormat enables or disables automatic formatting for row cells. +// Logs the change if debugging is enabled. +func WithRowAutoFormat(state tw.State) Option { + return func(target *Table) { + target.config.Row.Formatting.AutoFormat = state + if target.logger != nil { + target.logger.Debugf("Option: WithRowAutoFormat applied to Table: %v", state) + } + } +} + +// WithHeaderControl sets the control behavior for the table header. +// Logs the change if debugging is enabled. +func WithHeaderControl(control tw.Control) Option { + return func(target *Table) { + target.config.Behavior.Header = control + if target.logger != nil { + target.logger.Debugf("Option: WithHeaderControl applied to Table: %v", control) + } + } +} + +// WithFooterControl sets the control behavior for the table footer. +// Logs the change if debugging is enabled. +func WithFooterControl(control tw.Control) Option { + return func(target *Table) { + target.config.Behavior.Footer = control + if target.logger != nil { + target.logger.Debugf("Option: WithFooterControl applied to Table: %v", control) + } + } +} + +// WithAlignment sets the default column alignment for the header, rows, and footer. +// Logs the change if debugging is enabled. +func WithAlignment(alignment tw.Alignment) Option { + return func(target *Table) { + target.config.Header.Alignment.PerColumn = alignment + target.config.Row.Alignment.PerColumn = alignment + target.config.Footer.Alignment.PerColumn = alignment + if target.logger != nil { + target.logger.Debugf("Option: WithAlignment applied to Table: %+v", alignment) + } + } +} + +// WithBehavior applies a behavior configuration to the table. +// Logs the change if debugging is enabled. +func WithBehavior(behavior tw.Behavior) Option { + return func(target *Table) { + target.config.Behavior = behavior + if target.logger != nil { + target.logger.Debugf("Option: WithBehavior applied to Table: %+v", behavior) + } + } +} + +// WithPadding sets the global padding for the header, rows, and footer. +// Logs the change if debugging is enabled. +func WithPadding(padding tw.Padding) Option { + return func(target *Table) { + target.config.Header.Padding.Global = padding + target.config.Row.Padding.Global = padding + target.config.Footer.Padding.Global = padding + if target.logger != nil { + target.logger.Debugf("Option: WithPadding applied to Table: %+v", padding) + } + } +} + +// WithRendition allows updating the active renderer's rendition configuration +// by merging the provided rendition. +// If the renderer does not implement tw.Renditioning, a warning is logged. +// Logs the change if debugging is enabled. +func WithRendition(rendition tw.Rendition) Option { + return func(target *Table) { + if target.renderer == nil { + if target.logger != nil { + target.logger.Warn("Option: WithRendition: No renderer set on table.") + } + return + } + if ru, ok := target.renderer.(tw.Renditioning); ok { + ru.Rendition(rendition) + if target.logger != nil { + target.logger.Debugf("Option: WithRendition: Applied to renderer via Renditioning.SetRendition(): %+v", rendition) + } + } else { + if target.logger != nil { + target.logger.Warnf("Option: WithRendition: Current renderer type %T does not implement tw.Renditioning. Rendition may not be applied as expected.", target.renderer) + } + } + } +} + +// WithSymbols sets the symbols used for drawing table borders and separators. +// The symbols are applied to the table's renderer configuration, if a renderer is set. +// If no renderer is set (target.renderer is nil), this option has no effect. . +func WithSymbols(symbols tw.Symbols) Option { + return func(target *Table) { + if target.renderer != nil { + cfg := target.renderer.Config() + cfg.Symbols = symbols + + if ru, ok := target.renderer.(tw.Renditioning); ok { + ru.Rendition(cfg) + if target.logger != nil { + target.logger.Debugf("Option: WithRendition: Applied to renderer via Renditioning.SetRendition(): %+v", cfg) + } + } else { + if target.logger != nil { + target.logger.Warnf("Option: WithRendition: Current renderer type %T does not implement tw.Renditioning. Rendition may not be applied as expected.", target.renderer) + } + } + } + } +} + +// defaultConfig returns a default Config with sensible settings for headers, rows, footers, and behavior. +func defaultConfig() Config { + return Config{ + MaxWidth: 0, + Header: tw.CellConfig{ + Formatting: tw.CellFormatting{ + AutoWrap: tw.WrapTruncate, + AutoFormat: tw.On, + MergeMode: tw.MergeNone, + }, + Padding: tw.CellPadding{ + Global: tw.PaddingDefault, + }, + Alignment: tw.CellAlignment{ + Global: tw.AlignCenter, + PerColumn: []tw.Align{}, + }, + }, + Row: tw.CellConfig{ + Formatting: tw.CellFormatting{ + AutoWrap: tw.WrapNormal, + AutoFormat: tw.Off, + MergeMode: tw.MergeNone, + }, + Padding: tw.CellPadding{ + Global: tw.PaddingDefault, + }, + Alignment: tw.CellAlignment{ + Global: tw.AlignLeft, + PerColumn: []tw.Align{}, + }, + }, + Footer: tw.CellConfig{ + Formatting: tw.CellFormatting{ + AutoWrap: tw.WrapNormal, + AutoFormat: tw.Off, + MergeMode: tw.MergeNone, + }, + Padding: tw.CellPadding{ + Global: tw.PaddingDefault, + }, + Alignment: tw.CellAlignment{ + Global: tw.AlignRight, + PerColumn: []tw.Align{}, + }, + }, + Stream: tw.StreamConfig{}, + Debug: false, + Behavior: tw.Behavior{ + AutoHide: tw.Off, + TrimSpace: tw.On, + }, + } +} + +// mergeCellConfig merges a source CellConfig into a destination CellConfig, prioritizing non-default source values. +// It handles deep merging for complex fields like padding and callbacks. +func mergeCellConfig(dst, src tw.CellConfig) tw.CellConfig { + if src.Formatting.Alignment != tw.Empty { + dst.Formatting.Alignment = src.Formatting.Alignment + } + + if src.Formatting.AutoWrap != 0 { + dst.Formatting.AutoWrap = src.Formatting.AutoWrap + } + if src.ColMaxWidths.Global != 0 { + dst.ColMaxWidths.Global = src.ColMaxWidths.Global + } + if src.Formatting.MergeMode != 0 { + dst.Formatting.MergeMode = src.Formatting.MergeMode + } + + dst.Formatting.AutoFormat = src.Formatting.AutoFormat + + if src.Padding.Global.Paddable() { + dst.Padding.Global = src.Padding.Global + } + + if len(src.Padding.PerColumn) > 0 { + if dst.Padding.PerColumn == nil { + dst.Padding.PerColumn = make([]tw.Padding, len(src.Padding.PerColumn)) + } else if len(src.Padding.PerColumn) > len(dst.Padding.PerColumn) { + dst.Padding.PerColumn = append(dst.Padding.PerColumn, make([]tw.Padding, len(src.Padding.PerColumn)-len(dst.Padding.PerColumn))...) + } + for i, pad := range src.Padding.PerColumn { + if pad.Paddable() { + dst.Padding.PerColumn[i] = pad + } + } + } + if src.Callbacks.Global != nil { + dst.Callbacks.Global = src.Callbacks.Global + } + if len(src.Callbacks.PerColumn) > 0 { + if dst.Callbacks.PerColumn == nil { + dst.Callbacks.PerColumn = make([]func(), len(src.Callbacks.PerColumn)) + } else if len(src.Callbacks.PerColumn) > len(dst.Callbacks.PerColumn) { + dst.Callbacks.PerColumn = append(dst.Callbacks.PerColumn, make([]func(), len(src.Callbacks.PerColumn)-len(dst.Callbacks.PerColumn))...) + } + for i, cb := range src.Callbacks.PerColumn { + if cb != nil { + dst.Callbacks.PerColumn[i] = cb + } + } + } + if src.Filter.Global != nil { + dst.Filter.Global = src.Filter.Global + } + if len(src.Filter.PerColumn) > 0 { + if dst.Filter.PerColumn == nil { + dst.Filter.PerColumn = make([]func(string) string, len(src.Filter.PerColumn)) + } else if len(src.Filter.PerColumn) > len(dst.Filter.PerColumn) { + dst.Filter.PerColumn = append(dst.Filter.PerColumn, make([]func(string) string, len(src.Filter.PerColumn)-len(dst.Filter.PerColumn))...) + } + for i, filter := range src.Filter.PerColumn { + if filter != nil { + dst.Filter.PerColumn[i] = filter + } + } + } + + // Merge Alignment + if src.Alignment.Global != tw.Empty { + dst.Alignment.Global = src.Alignment.Global + } + + if len(src.Alignment.PerColumn) > 0 { + if dst.Alignment.PerColumn == nil { + dst.Alignment.PerColumn = make([]tw.Align, len(src.Alignment.PerColumn)) + } else if len(src.Alignment.PerColumn) > len(dst.Alignment.PerColumn) { + dst.Alignment.PerColumn = append(dst.Alignment.PerColumn, make([]tw.Align, len(src.Alignment.PerColumn)-len(dst.Alignment.PerColumn))...) + } + for i, align := range src.Alignment.PerColumn { + if align != tw.Skip { + dst.Alignment.PerColumn[i] = align + } + } + } + + if len(src.ColumnAligns) > 0 { + if dst.ColumnAligns == nil { + dst.ColumnAligns = make([]tw.Align, len(src.ColumnAligns)) + } else if len(src.ColumnAligns) > len(dst.ColumnAligns) { + dst.ColumnAligns = append(dst.ColumnAligns, make([]tw.Align, len(src.ColumnAligns)-len(dst.ColumnAligns))...) + } + for i, align := range src.ColumnAligns { + if align != tw.Skip { + dst.ColumnAligns[i] = align + } + } + } + + if len(src.ColMaxWidths.PerColumn) > 0 { + if dst.ColMaxWidths.PerColumn == nil { + dst.ColMaxWidths.PerColumn = make(map[int]int) + } + for k, v := range src.ColMaxWidths.PerColumn { + if v != 0 { + dst.ColMaxWidths.PerColumn[k] = v + } + } + } + return dst +} + +// mergeConfig merges a source Config into a destination Config, prioritizing non-default source values. +// It performs deep merging for complex types like Header, Row, Footer, and Stream. +func mergeConfig(dst, src Config) Config { + if src.MaxWidth != 0 { + dst.MaxWidth = src.MaxWidth + } + + dst.Debug = src.Debug || dst.Debug + dst.Behavior.AutoHide = src.Behavior.AutoHide + dst.Behavior.TrimSpace = src.Behavior.TrimSpace + dst.Behavior.Compact = src.Behavior.Compact + dst.Behavior.Header = src.Behavior.Header + dst.Behavior.Footer = src.Behavior.Footer + + if src.Widths.Global != 0 { + dst.Widths.Global = src.Widths.Global + } + if len(src.Widths.PerColumn) > 0 { + if dst.Widths.PerColumn == nil { + dst.Widths.PerColumn = make(map[int]int) + } + for k, v := range src.Widths.PerColumn { + if v != 0 { + dst.Widths.PerColumn[k] = v + } + } + } + + dst.Header = mergeCellConfig(dst.Header, src.Header) + dst.Row = mergeCellConfig(dst.Row, src.Row) + dst.Footer = mergeCellConfig(dst.Footer, src.Footer) + dst.Stream = mergeStreamConfig(dst.Stream, src.Stream) + + return dst +} + +// mergeStreamConfig merges a source StreamConfig into a destination StreamConfig, prioritizing non-default source values. +func mergeStreamConfig(dst, src tw.StreamConfig) tw.StreamConfig { + if src.Enable { + dst.Enable = true + } + return dst +} + +// padLine pads a line to the specified column count by appending empty strings as needed. +func padLine(line []string, numCols int) []string { + if len(line) >= numCols { + return line + } + padded := make([]string, numCols) + copy(padded, line) + for i := len(line); i < numCols; i++ { + padded[i] = tw.Empty + } + return padded +} diff --git a/vendor/github.com/olekukonko/tablewriter/renderer/markdown.go b/vendor/github.com/olekukonko/tablewriter/renderer/markdown.go index d9435f3500..525e633842 100644 --- a/vendor/github.com/olekukonko/tablewriter/renderer/markdown.go +++ b/vendor/github.com/olekukonko/tablewriter/renderer/markdown.go @@ -140,10 +140,10 @@ func (m *Markdown) resolveAlignment(ctx tw.Formatting) tw.Alignment { // build default alignment for i := 0; i < total; i++ { - m.alignment = append(m.alignment, tw.AlignLeft) + m.alignment = append(m.alignment, tw.AlignNone) // Default to AlignNone } - // add per colum alignment if it exits + // add per column alignment if it exists for i := 0; i < total; i++ { m.alignment[i] = ctx.Row.Current[i].Align } @@ -255,9 +255,10 @@ func (m *Markdown) formatSeparator(width int, align tw.Align) string { sb.WriteRune(':') sb.WriteString(strings.Repeat("-", targetWidth-2)) sb.WriteRune(':') + case tw.AlignNone: + sb.WriteString(strings.Repeat("-", targetWidth)) default: - sb.WriteRune(':') - sb.WriteString(strings.Repeat("-", targetWidth-1)) + sb.WriteString(strings.Repeat("-", targetWidth)) // Fallback } result := sb.String() @@ -321,12 +322,11 @@ func (m *Markdown) renderMarkdownLine(line []string, ctx tw.Formatting, isHeader defaultPadding := tw.Padding{Left: tw.Space, Right: tw.Space} if !ok { - cellCtx = tw.CellContext{ Data: tw.Empty, Align: align, Padding: defaultPadding, Width: ctx.Row.Widths.Get(colIndex), Merge: tw.MergeState{}, } - } else if cellCtx.Padding == (tw.Padding{}) { + } else if !cellCtx.Padding.Paddable() { cellCtx.Padding = defaultPadding } @@ -339,18 +339,6 @@ func (m *Markdown) renderMarkdownLine(line []string, ctx tw.Formatting, isHeader // Calculate width and span span := 1 - - if align == tw.AlignNone || align == tw.Empty { - if ctx.Row.Position == tw.Header && !isHeaderSep { - align = tw.AlignCenter - } else if ctx.Row.Position == tw.Footer { - align = tw.AlignRight - } else { - align = tw.AlignLeft - } - m.logger.Debugf("renderMarkdownLine: Col %d using default align '%s'", colIndex, align) - } - visualWidth := 0 isHMergeStart := ok && cellCtx.Merge.Horizontal.Present && cellCtx.Merge.Horizontal.Start if isHMergeStart { @@ -383,10 +371,11 @@ func (m *Markdown) renderMarkdownLine(line []string, ctx tw.Formatting, isHeader var formattedSegment string if isHeaderSep { // Use header's alignment from ctx.Row.Previous - headerAlign := tw.AlignCenter // Default for headers + headerAlign := align if headerCellCtx, headerOK := ctx.Row.Previous[colIndex]; headerOK { headerAlign = headerCellCtx.Align - if headerAlign == tw.AlignNone || headerAlign == tw.Empty { + // Preserve tw.AlignNone for separator + if headerAlign != tw.AlignNone && (headerAlign == tw.Empty || headerAlign == tw.Skip) { headerAlign = tw.AlignCenter } } @@ -403,6 +392,16 @@ func (m *Markdown) renderMarkdownLine(line []string, ctx tw.Formatting, isHeader rowAlign = headerCellCtx.Align } } + if rowAlign == tw.AlignNone || rowAlign == tw.Empty { + if ctx.Row.Position == tw.Header { + rowAlign = tw.AlignCenter + } else if ctx.Row.Position == tw.Footer { + rowAlign = tw.AlignRight + } else { + rowAlign = tw.AlignLeft + } + m.logger.Debugf("renderMarkdownLine: Col %d using default align '%s'", colIndex, rowAlign) + } formattedSegment = m.formatCell(content, visualWidth, rowAlign, cellCtx.Padding) } output.WriteString(formattedSegment) diff --git a/vendor/github.com/olekukonko/tablewriter/renderer/ocean.go b/vendor/github.com/olekukonko/tablewriter/renderer/ocean.go index 12f9d45c9f..58a6c9d6bb 100644 --- a/vendor/github.com/olekukonko/tablewriter/renderer/ocean.go +++ b/vendor/github.com/olekukonko/tablewriter/renderer/ocean.go @@ -340,7 +340,7 @@ func (o *Ocean) renderContentLine(ctx tw.Formatting, lineData []string) { if cellCtx.Align.Validate() == nil && cellCtx.Align != tw.AlignNone { align = cellCtx.Align } - if cellCtx.Padding != (tw.Padding{}) { + if cellCtx.Padding.Paddable() { padding = cellCtx.Padding } } else if colIdx < len(lineData) { diff --git a/vendor/github.com/olekukonko/tablewriter/stream.go b/vendor/github.com/olekukonko/tablewriter/stream.go index a990c6e09b..1b230d04de 100644 --- a/vendor/github.com/olekukonko/tablewriter/stream.go +++ b/vendor/github.com/olekukonko/tablewriter/stream.go @@ -113,10 +113,10 @@ func (t *Table) Start() error { // Calculate initial fixed widths if provided in StreamConfig.Widths // These widths will be used for all subsequent rendering in streaming mode. - if t.config.Stream.Widths.PerColumn != nil && t.config.Stream.Widths.PerColumn.Len() > 0 { + if t.config.Widths.PerColumn != nil && t.config.Widths.PerColumn.Len() > 0 { // Use per-column stream widths if set - t.logger.Debugf("Using per-column stream widths from StreamConfig: %v", t.config.Stream.Widths.PerColumn) - t.streamWidths = t.config.Stream.Widths.PerColumn.Clone() + t.logger.Debugf("Using per-column stream widths from StreamConfig: %v", t.config.Widths.PerColumn) + t.streamWidths = t.config.Widths.PerColumn.Clone() // Determine numCols from the highest index in PerColumn map maxColIdx := -1 t.streamWidths.Each(func(col int, width int) { @@ -139,14 +139,14 @@ func (t *Table) Start() error { t.logger.Debugf("PerColumn widths map is effectively empty or contains only negative values, streamNumCols = 0.") } - } else if t.config.Stream.Widths.Global > 0 { + } else if t.config.Widths.Global > 0 { // Global width is set, but we don't know the number of columns yet. // Defer applying global width until the first data (Header or first Row) arrives. // Store a placeholder or flag indicating global width should be used. // The simple way for now: Keep streamWidths empty, signal the global width preference. // The width calculation function called later will need to check StreamConfig.Widths.Global // if streamWidths is empty. - t.logger.Debugf("Global stream width %d set in StreamConfig. Will derive numCols from first data.", t.config.Stream.Widths.Global) + t.logger.Debugf("Global stream width %d set in StreamConfig. Will derive numCols from first data.", t.config.Widths.Global) t.streamWidths = tw.NewMapper[int, int]() // Initialize as empty, will be populated later // Note: No need to store Global width value here, it's available in t.config.Stream.Widths.Global @@ -451,26 +451,26 @@ func (t *Table) streamBuildCellContexts( // The paddingConfig should be the CellPadding config relevant to the sample data (Header/Row/Footer). // Returns the determined number of columns. // This function should only be called when t.streamWidths is currently empty. -func (t *Table) streamCalculateWidths(sampleDataLines []string, sectionConfigForSampleData tw.CellConfig) int { +func (t *Table) streamCalculateWidths(sampling []string, config tw.CellConfig) int { if t.streamWidths != nil && t.streamWidths.Len() > 0 { t.logger.Debug("streamCalculateWidths: Called when streaming widths are already set (%d columns). Reusing existing.", t.streamNumCols) return t.streamNumCols } - t.logger.Debug("streamCalculateWidths: Calculating streaming widths. Sample data cells: %d. Using section config: %+v", len(sampleDataLines), sectionConfigForSampleData.Formatting) + t.logger.Debug("streamCalculateWidths: Calculating streaming widths. Sample data cells: %d. Using section config: %+v", len(sampling), config.Formatting) determinedNumCols := 0 - if t.config.Stream.Widths.PerColumn != nil && t.config.Stream.Widths.PerColumn.Len() > 0 { + if t.config.Widths.PerColumn != nil && t.config.Widths.PerColumn.Len() > 0 { maxColIdx := -1 - t.config.Stream.Widths.PerColumn.Each(func(col int, width int) { + t.config.Widths.PerColumn.Each(func(col int, width int) { if col > maxColIdx { maxColIdx = col } }) determinedNumCols = maxColIdx + 1 t.logger.Debug("streamCalculateWidths: Determined numCols (%d) from StreamConfig.Widths.PerColumn", determinedNumCols) - } else if len(sampleDataLines) > 0 { - determinedNumCols = len(sampleDataLines) + } else if len(sampling) > 0 { + determinedNumCols = len(sampling) t.logger.Debug("streamCalculateWidths: Determined numCols (%d) from sample data length", determinedNumCols) } else { t.logger.Debug("streamCalculateWidths: Cannot determine numCols (no PerColumn config, no sample data)") @@ -482,14 +482,14 @@ func (t *Table) streamCalculateWidths(sampleDataLines []string, sectionConfigFor t.streamNumCols = determinedNumCols t.streamWidths = tw.NewMapper[int, int]() - // Use padding and autowrap from the provided sectionConfigForSampleData - paddingForWidthCalc := sectionConfigForSampleData.Padding - autoWrapForWidthCalc := sectionConfigForSampleData.Formatting.AutoWrap + // Use padding and autowrap from the provided config + paddingForWidthCalc := config.Padding + autoWrapForWidthCalc := config.Formatting.AutoWrap - if t.config.Stream.Widths.PerColumn != nil && t.config.Stream.Widths.PerColumn.Len() > 0 { + if t.config.Widths.PerColumn != nil && t.config.Widths.PerColumn.Len() > 0 { t.logger.Debug("streamCalculateWidths: Using widths from StreamConfig.Widths.PerColumn") for i := 0; i < t.streamNumCols; i++ { - width, ok := t.config.Stream.Widths.PerColumn.OK(i) + width, ok := t.config.Widths.PerColumn.OK(i) if !ok { width = 0 } @@ -501,12 +501,12 @@ func (t *Table) streamCalculateWidths(sampleDataLines []string, sectionConfigFor t.streamWidths.Set(i, width) } } else { - // No PerColumn config, derive from sampleDataLines intelligently + // No PerColumn config, derive from sampling intelligently t.logger.Debug("streamCalculateWidths: Intelligently deriving widths from sample data content and padding.") tempRequiredWidths := tw.NewMapper[int, int]() // Widths from updateWidths (content + padding) - if len(sampleDataLines) > 0 { + if len(sampling) > 0 { // updateWidths calculates: DisplayWidth(content) + padLeft + padRight - t.updateWidths(sampleDataLines, tempRequiredWidths, paddingForWidthCalc) + t.updateWidths(sampling, tempRequiredWidths, paddingForWidthCalc) } ellipsisWidthBuffer := 0 @@ -522,13 +522,13 @@ func (t *Table) streamCalculateWidths(sampleDataLines []string, sectionConfigFor // We need to deconstruct it to apply logic to content_width first. sampleContent := "" - if i < len(sampleDataLines) { - sampleContent = t.Trimmer(sampleDataLines[i]) + if i < len(sampling) { + sampleContent = t.Trimmer(sampling[i]) } sampleContentDisplayWidth := tw.DisplayWidth(sampleContent) colPad := paddingForWidthCalc.Global - if i < len(paddingForWidthCalc.PerColumn) && paddingForWidthCalc.PerColumn[i] != (tw.Padding{}) { + if i < len(paddingForWidthCalc.PerColumn) && paddingForWidthCalc.PerColumn[i].Paddable() { colPad = paddingForWidthCalc.PerColumn[i] } currentPadLWidth := tw.DisplayWidth(colPad.Left) @@ -584,8 +584,8 @@ func (t *Table) streamCalculateWidths(sampleDataLines []string, sectionConfigFor } // Apply Global Constraint (if t.config.Stream.Widths.Global > 0) - if t.config.Stream.Widths.Global > 0 && t.streamNumCols > 0 { - t.logger.Debug("streamCalculateWidths: Applying global stream width constraint %d", t.config.Stream.Widths.Global) + if t.config.Widths.Global > 0 && t.streamNumCols > 0 { + t.logger.Debug("streamCalculateWidths: Applying global stream width constraint %d", t.config.Widths.Global) currentTotalColumnWidthsSum := 0 t.streamWidths.Each(func(_ int, w int) { currentTotalColumnWidthsSum += w @@ -606,11 +606,11 @@ func (t *Table) streamCalculateWidths(sampleDataLines []string, sectionConfigFor totalWidthIncludingSeparators += (t.streamNumCols - 1) * separatorWidth } - if t.config.Stream.Widths.Global < totalWidthIncludingSeparators && totalWidthIncludingSeparators > 0 { // Added check for total > 0 - t.logger.Debug("streamCalculateWidths: Total calculated width (%d incl separators) exceeds global stream width (%d). Shrinking.", totalWidthIncludingSeparators, t.config.Stream.Widths.Global) + if t.config.Widths.Global < totalWidthIncludingSeparators && totalWidthIncludingSeparators > 0 { // Added check for total > 0 + t.logger.Debug("streamCalculateWidths: Total calculated width (%d incl separators) exceeds global stream width (%d). Shrinking.", totalWidthIncludingSeparators, t.config.Widths.Global) // Target sum for column widths only (global limit - total separator width) - targetSumForColumnWidths := t.config.Stream.Widths.Global + targetSumForColumnWidths := t.config.Widths.Global if t.streamNumCols > 1 { targetSumForColumnWidths -= (t.streamNumCols - 1) * separatorWidth } @@ -671,7 +671,7 @@ func (t *Table) streamCalculateWidths(sampleDataLines []string, sectionConfigFor } t.logger.Debug("streamCalculateWidths: Widths after scaling and distribution: %v", t.streamWidths) } else { - t.logger.Debug("streamCalculateWidths: Total calculated width (%d) fits global stream width (%d). No scaling needed.", totalWidthIncludingSeparators, t.config.Stream.Widths.Global) + t.logger.Debug("streamCalculateWidths: Total calculated width (%d) fits global stream width (%d). No scaling needed.", totalWidthIncludingSeparators, t.config.Widths.Global) } } diff --git a/vendor/github.com/olekukonko/tablewriter/tablewriter.go b/vendor/github.com/olekukonko/tablewriter/tablewriter.go index 16961d89a1..4eca55d7a5 100644 --- a/vendor/github.com/olekukonko/tablewriter/tablewriter.go +++ b/vendor/github.com/olekukonko/tablewriter/tablewriter.go @@ -133,6 +133,16 @@ func NewTable(w io.Writer, opts ...Option) *Table { return t } +// NewWriter creates a new table with default settings for backward compatibility. +// It logs the creation if debugging is enabled. +func NewWriter(w io.Writer) *Table { + t := NewTable(w) + if t.logger != nil { + t.logger.Debug("NewWriter created buffered Table") + } + return t +} + // Caption sets the table caption (legacy method). // Defaults to BottomCenter alignment, wrapping to table width. // Use SetCaptionOptions for more control. @@ -397,6 +407,11 @@ func (t *Table) Options(opts ...Option) *Table { t.logger.Suspend() } + // help resolve from deprecation + //if t.config.Stream.Enable { + // t.config.Widths = t.config.Stream.Widths + //} + // send logger to renderer // this will overwrite the default logger t.renderer.Logger(t.logger) @@ -508,19 +523,40 @@ func (t *Table) appendSingle(row interface{}) error { // Parameter config provides alignment settings for the section. // Returns a map of column indices to alignment settings. func (t *Table) buildAligns(config tw.CellConfig) map[int]tw.Align { - t.logger.Debugf("buildAligns INPUT: config.Formatting.Align=%s, config.ColumnAligns=%v", config.Formatting.Alignment, config.ColumnAligns) + // Start with global alignment, preferring deprecated Formatting.Alignment + effectiveGlobalAlign := config.Formatting.Alignment + if effectiveGlobalAlign == tw.Empty || effectiveGlobalAlign == tw.Skip { + effectiveGlobalAlign = config.Alignment.Global + if config.Formatting.Alignment != tw.Empty && config.Formatting.Alignment != tw.Skip { + t.logger.Warnf("Using deprecated CellFormatting.Alignment (%s). Migrate to CellConfig.Alignment.Global.", config.Formatting.Alignment) + } + } + + // Use per-column alignments, preferring deprecated ColumnAligns + effectivePerColumn := config.ColumnAligns + if len(effectivePerColumn) == 0 && len(config.Alignment.PerColumn) > 0 { + effectivePerColumn = make([]tw.Align, len(config.Alignment.PerColumn)) + copy(effectivePerColumn, config.Alignment.PerColumn) + if len(config.ColumnAligns) > 0 { + t.logger.Warnf("Using deprecated CellConfig.ColumnAligns (%v). Migrate to CellConfig.Alignment.PerColumn.", config.ColumnAligns) + } + } + + // Log input for debugging + t.logger.Debugf("buildAligns INPUT: deprecated Formatting.Alignment=%s, deprecated ColumnAligns=%v, config.Alignment.Global=%s, config.Alignment.PerColumn=%v", + config.Formatting.Alignment, config.ColumnAligns, config.Alignment.Global, config.Alignment.PerColumn) + numColsToUse := t.getNumColsToUse() colAlignsResult := make(map[int]tw.Align) for i := 0; i < numColsToUse; i++ { - currentAlign := config.Formatting.Alignment - if i < len(config.ColumnAligns) { - colSpecificAlign := config.ColumnAligns[i] - if colSpecificAlign != tw.Empty && colSpecificAlign != tw.Skip { - currentAlign = colSpecificAlign - } + currentAlign := effectiveGlobalAlign + if i < len(effectivePerColumn) && effectivePerColumn[i] != tw.Empty && effectivePerColumn[i] != tw.Skip { + currentAlign = effectivePerColumn[i] } + // Skip validation here; rely on rendering to handle invalid alignments colAlignsResult[i] = currentAlign } + t.logger.Debugf("Aligns built: %v (length %d)", colAlignsResult, len(colAlignsResult)) return colAlignsResult } @@ -532,7 +568,7 @@ func (t *Table) buildPadding(padding tw.CellPadding) map[int]tw.Padding { numColsToUse := t.getNumColsToUse() colPadding := make(map[int]tw.Padding) for i := 0; i < numColsToUse; i++ { - if i < len(padding.PerColumn) && padding.PerColumn[i] != (tw.Padding{}) { + if i < len(padding.PerColumn) && padding.PerColumn[i].Paddable() { colPadding[i] = padding.PerColumn[i] } else { colPadding[i] = padding.Global @@ -699,8 +735,12 @@ func (t *Table) maxColumns() int { return m } +// printTopBottomCaption prints the table's caption at the specified top or bottom position. +// It wraps the caption text to fit the table width or a user-defined width, aligns it according +// to the specified alignment, and writes it to the provided writer. If the caption text is empty +// or the spot is invalid, it logs the issue and returns without printing. The function handles +// wrapping errors by falling back to splitting on newlines or using the original text. func (t *Table) printTopBottomCaption(w io.Writer, actualTableWidth int) { - // Log the state of t.caption t.logger.Debugf("[printCaption Entry] Text=%q, Spot=%v (type %T), Align=%q, UserWidth=%d, ActualTableWidth=%d", t.caption.Text, t.caption.Spot, t.caption.Spot, t.caption.Align, t.caption.Width, actualTableWidth) @@ -711,12 +751,11 @@ func (t *Table) printTopBottomCaption(w io.Writer, actualTableWidth int) { return } - // Determine captionWrapWidth var captionWrapWidth int if t.caption.Width > 0 { captionWrapWidth = t.caption.Width t.logger.Debugf("[printCaption] Using user-defined caption.Width %d for wrapping.", captionWrapWidth) - } else if actualTableWidth <= 4 { // Empty or minimal table + } else if actualTableWidth <= 4 { captionWrapWidth = tw.DisplayWidth(t.caption.Text) t.logger.Debugf("[printCaption] Empty table, no user caption.Width: Using natural caption width %d.", captionWrapWidth) } else { @@ -724,14 +763,12 @@ func (t *Table) printTopBottomCaption(w io.Writer, actualTableWidth int) { t.logger.Debugf("[printCaption] Non-empty table, no user caption.Width: Using actualTableWidth %d for wrapping.", actualTableWidth) } - // Ensure captionWrapWidth is positive if captionWrapWidth <= 0 { - captionWrapWidth = 10 // Minimum sensible width + captionWrapWidth = 10 t.logger.Warnf("[printCaption] captionWrapWidth was %d (<=0). Setting to minimum %d.", captionWrapWidth, 10) } t.logger.Debugf("[printCaption] Final captionWrapWidth to be used by twwarp: %d", captionWrapWidth) - // Wrap the caption text wrappedCaptionLines, count := twwarp.WrapString(t.caption.Text, captionWrapWidth) if count == 0 { t.logger.Errorf("[printCaption] Error from twwarp.WrapString (width %d): %v. Text: %q", captionWrapWidth, count, t.caption.Text) @@ -754,7 +791,6 @@ func (t *Table) printTopBottomCaption(w io.Writer, actualTableWidth int) { t.logger.Debugf("[printCaption] Wrapped caption into %d lines: %v", len(wrappedCaptionLines), wrappedCaptionLines) } - // Determine padding target width paddingTargetWidth := actualTableWidth if t.caption.Width > 0 { paddingTargetWidth = t.caption.Width @@ -763,7 +799,6 @@ func (t *Table) printTopBottomCaption(w io.Writer, actualTableWidth int) { } t.logger.Debugf("[printCaption] Final paddingTargetWidth for tw.Pad: %d", paddingTargetWidth) - // Print each wrapped line for i, line := range wrappedCaptionLines { align := t.caption.Align if align == "" || align == tw.AlignDefault || align == tw.AlignNone { @@ -791,22 +826,11 @@ func (t *Table) printTopBottomCaption(w io.Writer, actualTableWidth int) { // Parameters include cells to process and config for formatting rules. // Returns a slice of string slices representing processed lines. func (t *Table) prepareContent(cells []string, config tw.CellConfig) [][]string { - // force max width - isStreaming := t.config.Stream.Enable && t.hasPrinted t.logger.Debugf("prepareContent: Processing cells=%v (streaming: %v)", cells, isStreaming) initialInputCellCount := len(cells) result := make([][]string, 0) - // ll.Dbg(t.config.MaxWidth) - // force max width - if t.config.MaxWidth > 0 { - // it has headers - if len(cells) > 0 { - config.ColMaxWidths.Global = int(math.Floor(float64(t.config.MaxWidth) / float64(len(cells)))) - } - } - effectiveNumCols := initialInputCellCount if isStreaming { if t.streamNumCols > 0 { @@ -830,6 +854,16 @@ func (t *Table) prepareContent(cells []string, config tw.CellConfig) [][]string } } + if t.config.MaxWidth > 0 && !t.config.Widths.Constrained() { + if effectiveNumCols > 0 { + derivedSectionGlobalMaxWidth := int(math.Floor(float64(t.config.MaxWidth) / float64(effectiveNumCols))) + config.ColMaxWidths.Global = derivedSectionGlobalMaxWidth + t.logger.Debugf("prepareContent: Table MaxWidth %d active and t.config.Widths not constrained. "+ + "Derived section ColMaxWidths.Global: %d for %d columns. This will be used by calculateContentMaxWidth if no higher priority constraints exist.", + t.config.MaxWidth, config.ColMaxWidths.Global, effectiveNumCols) + } + } + for i := 0; i < effectiveNumCols; i++ { cellContent := "" if i < len(cells) { @@ -841,7 +875,7 @@ func (t *Table) prepareContent(cells []string, config tw.CellConfig) [][]string cellContent = t.Trimmer(cellContent) colPad := config.Padding.Global - if i < len(config.Padding.PerColumn) && config.Padding.PerColumn[i] != (tw.Padding{}) { + if i < len(config.Padding.PerColumn) && config.Padding.PerColumn[i].Paddable() { colPad = config.Padding.PerColumn[i] } @@ -881,50 +915,45 @@ func (t *Table) prepareContent(cells []string, config tw.CellConfig) [][]string case tw.WrapBreak: wrapped := make([]string, 0) currentLine := line + breakCharWidth := tw.DisplayWidth(tw.CharBreak) for tw.DisplayWidth(currentLine) > effectiveContentMaxWidth { - breakPoint := tw.BreakPoint(currentLine, effectiveContentMaxWidth) - if breakPoint <= 0 { - t.logger.Warnf("prepareContent: WrapBreak - BreakPoint <= 0 for line '%s' at width %d. Attempting manual break.", currentLine, effectiveContentMaxWidth) - runes := []rune(currentLine) + targetWidth := effectiveContentMaxWidth - breakCharWidth + if targetWidth < 0 { + targetWidth = 0 + } + breakPoint := tw.BreakPoint(currentLine, targetWidth) + runes := []rune(currentLine) + if breakPoint <= 0 || breakPoint > len(runes) { + t.logger.Warnf("prepareContent: WrapBreak - Invalid BreakPoint %d for line '%s' at width %d. Attempting manual break.", breakPoint, currentLine, targetWidth) actualBreakRuneCount := 0 tempWidth := 0 - for charIdx, r := range currentLine { + for charIdx, r := range runes { runeStr := string(r) rw := tw.DisplayWidth(runeStr) - if tempWidth+rw > effectiveContentMaxWidth && charIdx > 0 { + if tempWidth+rw > targetWidth && charIdx > 0 { break } tempWidth += rw actualBreakRuneCount = charIdx + 1 - if tempWidth >= effectiveContentMaxWidth && charIdx == 0 { + if tempWidth >= targetWidth && charIdx == 0 { break } } if actualBreakRuneCount == 0 && len(runes) > 0 { actualBreakRuneCount = 1 } - if actualBreakRuneCount > 0 && actualBreakRuneCount <= len(runes) { wrapped = append(wrapped, string(runes[:actualBreakRuneCount])+tw.CharBreak) currentLine = string(runes[actualBreakRuneCount:]) } else { - if tw.DisplayWidth(currentLine) > 0 { - wrapped = append(wrapped, currentLine) - currentLine = "" - } - break - } - } else { - runes := []rune(currentLine) - if breakPoint <= len(runes) { - wrapped = append(wrapped, string(runes[:breakPoint])+tw.CharBreak) - currentLine = string(runes[breakPoint:]) - } else { - t.logger.Warnf("prepareContent: WrapBreak - BreakPoint (%d) out of bounds for line runes (%d). Adding full line.", breakPoint, len(runes)) + t.logger.Warnf("prepareContent: WrapBreak - Cannot break line '%s'. Adding as is.", currentLine) wrapped = append(wrapped, currentLine) currentLine = "" break } + } else { + wrapped = append(wrapped, string(runes[:breakPoint])+tw.CharBreak) + currentLine = string(runes[breakPoint:]) } } if tw.DisplayWidth(currentLine) > 0 { @@ -959,7 +988,8 @@ func (t *Table) prepareContent(cells []string, config tw.CellConfig) [][]string if i < len(result[j]) { result[j][i] = cellLineContent } else { - t.logger.Warnf("prepareContent: Column index %d out of bounds (%d) during result matrix population.", i, len(result[j])) + t.logger.Warnf("prepareContent: Column index %d out of bounds (%d) during result matrix population. EffectiveNumCols: %d. This indicates a logic error.", + i, len(result[j]), effectiveNumCols) } } } @@ -1304,6 +1334,7 @@ func (t *Table) prepareWithMerges(content [][]string, config tw.CellConfig, posi // No parameters are required. // Returns an error if rendering fails in any section. func (t *Table) render() error { + t.ensureInitialized() if t.config.Stream.Enable { @@ -1339,9 +1370,8 @@ func (t *Table) render() error { t.logger.Debugf("No caption detected. Rendering table core directly to writer.") } - //Render Table Core --- - t.writer = targetWriter // Set writer only when necessary - + //Render Table Core + t.writer = targetWriter ctx, mctx, err := t.prepareContexts() if err != nil { t.writer = originalWriter @@ -1387,7 +1417,6 @@ func (t *Table) render() error { if renderError { return firstRenderErr // Return error from core rendering if any } - //End Render Table Core --- //Caption Handling & Final Output --- if isTopOrBottomCaption { @@ -1877,17 +1906,54 @@ func (t *Table) renderHeader(ctx *renderContext, mctx *mergeContext) error { if cfg.Settings.Lines.ShowHeaderLine.Enabled() && (len(ctx.rowLines) > 0 || len(ctx.footerLines) > 0) { ctx.logger.Debug("Rendering header separator line") - hctx.rowIdx = 0 - hctx.lineIdx = len(ctx.headerLines) - 1 - hctx.line = padLine(ctx.headerLines[hctx.lineIdx], ctx.numCols) - hctx.location = tw.LocationMiddle resp := t.buildCellContexts(ctx, mctx, hctx, colAligns, colPadding) + + var nextSectionCells map[int]tw.CellContext + var nextSectionWidths tw.Mapper[int, int] + + if len(ctx.rowLines) > 0 { + nextSectionWidths = ctx.widths[tw.Row] + rowColAligns := t.buildAligns(t.config.Row) + rowColPadding := t.buildPadding(t.config.Row.Padding) + firstRowHctx := &helperContext{ + position: tw.Row, + rowIdx: 0, + lineIdx: 0, + } + if len(ctx.rowLines[0]) > 0 { + firstRowHctx.line = padLine(ctx.rowLines[0][0], ctx.numCols) + } else { + firstRowHctx.line = make([]string, ctx.numCols) + } + firstRowResp := t.buildCellContexts(ctx, mctx, firstRowHctx, rowColAligns, rowColPadding) + nextSectionCells = firstRowResp.cells + } else if len(ctx.footerLines) > 0 { + nextSectionWidths = ctx.widths[tw.Row] + footerColAligns := t.buildAligns(t.config.Footer) + footerColPadding := t.buildPadding(t.config.Footer.Padding) + firstFooterHctx := &helperContext{ + position: tw.Footer, + rowIdx: 0, + lineIdx: 0, + } + if len(ctx.footerLines) > 0 { + firstFooterHctx.line = padLine(ctx.footerLines[0], ctx.numCols) + } else { + firstFooterHctx.line = make([]string, ctx.numCols) + } + firstFooterResp := t.buildCellContexts(ctx, mctx, firstFooterHctx, footerColAligns, footerColPadding) + nextSectionCells = firstFooterResp.cells + } else { + nextSectionWidths = ctx.widths[tw.Header] + nextSectionCells = nil + } + f.Line(tw.Formatting{ Row: tw.RowContext{ - Widths: ctx.widths[tw.Header], + Widths: nextSectionWidths, Current: resp.cells, Previous: resp.prevCells, - Next: resp.nextCells, + Next: nextSectionCells, Position: tw.Header, Location: tw.LocationMiddle, }, diff --git a/vendor/github.com/olekukonko/tablewriter/tw/cell.go b/vendor/github.com/olekukonko/tablewriter/tw/cell.go index de2fa0057a..0547f01a4c 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/cell.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/cell.go @@ -2,13 +2,17 @@ package tw // CellFormatting holds formatting options for table cells. type CellFormatting struct { - Alignment Align // Text alignment within the cell (e.g., Left, Right, Center) - AutoWrap int // Wrapping behavior (e.g., WrapTruncate, WrapNormal) - MergeMode int // Bitmask for merge behavior (e.g., MergeHorizontal, MergeVertical) + AutoWrap int // Wrapping behavior (e.g., WrapTruncate, WrapNormal) + MergeMode int // Bitmask for merge behavior (e.g., MergeHorizontal, MergeVertical) // Changed form bool to State // See https://github.com/olekukonko/tablewriter/issues/261 AutoFormat State // Enables automatic formatting (e.g., title case for headers) + + // Deprecated: kept for compatibility + // will be removed soon + Alignment Align // Text alignment within the cell (e.g., Left, Right, Center) + } // CellPadding defines padding settings for table cells. @@ -30,17 +34,31 @@ type CellCallbacks struct { PerColumn []func() // Column-specific callbacks } +// CellAlignment defines alignment settings for table cells. +type CellAlignment struct { + Global Align // Default alignment applied to all cells + PerColumn []Align // Column-specific alignment overrides +} + // CellConfig combines formatting, padding, and callback settings for a table section. type CellConfig struct { Formatting CellFormatting // Cell formatting options Padding CellPadding // Padding configuration Callbacks CellCallbacks // Callback functions (unused) Filter CellFilter // Function to filter cell content (renamed from Filter Filter) - ColumnAligns []Align // Per-column alignment overrides + Alignment CellAlignment // Alignment configuration for cells ColMaxWidths CellWidth // Per-column maximum width overrides + + // Deprecated: use Alignment.PerColumn instead. Will be removed in a future version. + // will be removed soon + ColumnAligns []Align // Per-column alignment overrides } type CellWidth struct { Global int PerColumn Mapper[int, int] } + +func (c CellWidth) Constrained() bool { + return c.Global > 0 || c.PerColumn.Len() > 0 +} diff --git a/vendor/github.com/olekukonko/tablewriter/tw/fn.go b/vendor/github.com/olekukonko/tablewriter/tw/fn.go index 8183e3ea1d..9610b2734b 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/fn.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/fn.go @@ -245,7 +245,7 @@ func IsNumeric(s string) bool { return err == nil } -// SplitCamelCase splits a camelCase or PascalCase string into separate words. +// SplitCamelCase splits a camelCase or PascalCase or snake_case string into separate words. // It detects transitions between uppercase, lowercase, digits, and other characters. func SplitCamelCase(src string) (entries []string) { // Validate UTF-8 input; return as single entry if invalid @@ -284,10 +284,11 @@ func SplitCamelCase(src string) (entries []string) { runes[i] = runes[i][:len(runes[i])-1] } } - // Convert rune groups to strings, excluding empty or whitespace-only groups + // Convert rune groups to strings, excluding empty, underscore or whitespace-only groups for _, s := range runes { - if len(s) > 0 && strings.TrimSpace(string(s)) != "" { - entries = append(entries, string(s)) + str := string(s) + if len(s) > 0 && strings.TrimSpace(str) != "" && str != "_" { + entries = append(entries, str) } } return diff --git a/vendor/github.com/olekukonko/tablewriter/tw/preset.go b/vendor/github.com/olekukonko/tablewriter/tw/preset.go new file mode 100644 index 0000000000..acadc25cbe --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/tw/preset.go @@ -0,0 +1,18 @@ +package tw + +// BorderNone defines a border configuration with all sides disabled. +var ( + // PaddingNone represents explicitly empty padding (no spacing on any side) + // Equivalent to Padding{Overwrite: true} + PaddingNone = Padding{Left: Empty, Right: Empty, Top: Empty, Bottom: Empty, Overwrite: true} + BorderNone = Border{Left: Off, Right: Off, Top: Off, Bottom: Off} + LinesNone = Lines{ShowTop: Off, ShowBottom: Off, ShowHeaderLine: Off, ShowFooterLine: Off} + SeparatorsNone = Separators{ShowHeader: Off, ShowFooter: Off, BetweenRows: Off, BetweenColumns: Off} +) + +var ( + + // PaddingDefault represents standard single-space padding on left/right + // Equivalent to Padding{Left: " ", Right: " ", Overwrite: true} + PaddingDefault = Padding{Left: " ", Right: " ", Overwrite: true} +) diff --git a/vendor/github.com/olekukonko/tablewriter/tw/renderer.go b/vendor/github.com/olekukonko/tablewriter/tw/renderer.go index 7078a991cc..6caf05e4eb 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/renderer.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/renderer.go @@ -108,21 +108,18 @@ type Settings struct { // Border defines the visibility states of table borders. type Border struct { - Left State // Left border visibility - Right State // Right border visibility - Top State // Top border visibility - Bottom State // Bottom border visibility + Left State // Left border visibility + Right State // Right border visibility + Top State // Top border visibility + Bottom State // Bottom border visibility + Overwrite bool } -// BorderNone defines a border configuration with all sides disabled. -var ( - PaddingNone = Padding{Left: Empty, Right: Empty, Top: Empty, Bottom: Empty} - BorderNone = Border{Left: Off, Right: Off, Top: Off, Bottom: Off} - LinesNone = Lines{ShowTop: Off, ShowBottom: Off, ShowHeaderLine: Off, ShowFooterLine: Off} - SeparatorsNone = Separators{ShowHeader: Off, ShowFooter: Off, BetweenRows: Off, BetweenColumns: Off} -) - type StreamConfig struct { Enable bool - Widths CellWidth // Cell/column widths + + // Deprecated: Use top-level Config.Widths for streaming width control. + // This field will be removed in a future version. It will be respected if + // Config.Widths is not set and this field is. + Widths CellWidth } diff --git a/vendor/github.com/olekukonko/tablewriter/tw/tw.go b/vendor/github.com/olekukonko/tablewriter/tw/tw.go index afdfbe3a90..020de742c2 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/tw.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/tw.go @@ -15,6 +15,8 @@ const ( Skip = "" Space = " " NewLine = "\n" + Column = ":" + Dash = "-" ) // Feature State Constants diff --git a/vendor/github.com/olekukonko/tablewriter/tw/types.go b/vendor/github.com/olekukonko/tablewriter/tw/types.go index 1551c67422..29a1862c1d 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/types.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/types.go @@ -132,22 +132,68 @@ func (c Caption) WithWidth(width int) Caption { return c } -// Padding defines custom padding characters for a cell +type Control struct { + Hide State +} + +// Compact configures compact width optimization for merged cells. +type Compact struct { + Merge State // Merge enables compact width calculation during cell merging, optimizing space allocation. +} + +// Behavior defines settings that control table rendering behaviors, such as column visibility and content formatting. +type Behavior struct { + AutoHide State // AutoHide determines whether empty columns are hidden. Ignored in streaming mode. + TrimSpace State // TrimSpace enables trimming of leading and trailing spaces from cell content. + + Header Control // Header specifies control settings for the table header. + Footer Control // Footer specifies control settings for the table footer. + + // Compact enables optimized width calculation for merged cells, such as in horizontal merges, + // by systematically determining the most efficient width instead of scaling by the number of columns. + Compact Compact +} + +// Padding defines the spacing characters around cell content in all four directions. +// A zero-value Padding struct will use the table's default padding unless Overwrite is true. type Padding struct { Left string Right string Top string Bottom string + + // Overwrite forces tablewriter to use this padding configuration exactly as specified, + // even when empty. When false (default), empty Padding fields will inherit defaults. + // + // For explicit no-padding, use the PaddingNone constant instead of setting Overwrite. + Overwrite bool } -type Control struct { - Hide State +// Common padding configurations for convenience + +// Equals reports whether two Padding configurations are identical in all fields. +// This includes comparing the Overwrite flag as part of the equality check. +func (p Padding) Equals(padding Padding) bool { + return p.Left == padding.Left && + p.Right == padding.Right && + p.Top == padding.Top && + p.Bottom == padding.Bottom && + p.Overwrite == padding.Overwrite } -// Behavior defines table behavior settings that control features like auto-hiding columns and trimming spaces. -type Behavior struct { - AutoHide State // Controls whether empty columns are automatically hidden (ignored in streaming mode) - TrimSpace State // Controls whether leading/trailing spaces are trimmed from cell content - Header Control - Footer Control +// Empty reports whether all padding strings are empty (all fields == ""). +// Note that an Empty padding may still take effect if Overwrite is true. +func (p Padding) Empty() bool { + return p.Left == "" && p.Right == "" && p.Top == "" && p.Bottom == "" +} + +// Paddable reports whether this Padding configuration should override existing padding. +// Returns true if either: +// - Any padding string is non-empty (!p.Empty()) +// - Overwrite flag is true (even with all strings empty) +// +// This is used internally during configuration merging to determine whether to +// apply the padding settings. +func (p Padding) Paddable() bool { + return !p.Empty() || p.Overwrite } diff --git a/vendor/github.com/olekukonko/tablewriter/zoo.go b/vendor/github.com/olekukonko/tablewriter/zoo.go index a7f63d585d..04a0c15a19 100644 --- a/vendor/github.com/olekukonko/tablewriter/zoo.go +++ b/vendor/github.com/olekukonko/tablewriter/zoo.go @@ -6,6 +6,7 @@ import ( "github.com/olekukonko/errors" "github.com/olekukonko/tablewriter/tw" "io" + "math" "reflect" "strconv" "strings" @@ -576,26 +577,23 @@ func (t *Table) buildPaddingLineContents(padChar string, widths tw.Mapper[int, i // Parameter ctx holds rendering state with width maps. // Returns an error if width calculation fails. func (t *Table) calculateAndNormalizeWidths(ctx *renderContext) error { - ctx.logger.Debugf("calculateAndNormalizeWidths: Computing and normalizing widths for %d columns", ctx.numCols) + ctx.logger.Debugf("calculateAndNormalizeWidths: Computing and normalizing widths for %d columns. Compact: %v", + ctx.numCols, t.config.Behavior.Compact.Merge.Enabled()) // Initialize width maps - t.headerWidths = tw.NewMapper[int, int]() - t.rowWidths = tw.NewMapper[int, int]() - t.footerWidths = tw.NewMapper[int, int]() + //t.headerWidths = tw.NewMapper[int, int]() + //t.rowWidths = tw.NewMapper[int, int]() + //t.footerWidths = tw.NewMapper[int, int]() - // Compute header widths + // Compute content-based widths for each section for _, lines := range ctx.headerLines { t.updateWidths(lines, t.headerWidths, t.config.Header.Padding) } - ctx.logger.Debugf("Initial Header widths: %v", t.headerWidths) - - // Cache row widths to avoid re-iteration rowWidthCache := make([]tw.Mapper[int, int], len(ctx.rowLines)) for i, row := range ctx.rowLines { rowWidthCache[i] = tw.NewMapper[int, int]() for _, line := range row { t.updateWidths(line, rowWidthCache[i], t.config.Row.Padding) - // Aggregate into t.rowWidths for col, width := range rowWidthCache[i] { currentMax, _ := t.rowWidths.OK(col) if width > currentMax { @@ -604,41 +602,348 @@ func (t *Table) calculateAndNormalizeWidths(ctx *renderContext) error { } } } - ctx.logger.Debugf("Initial Row widths: %v", t.rowWidths) - - // Compute footer widths for _, lines := range ctx.footerLines { t.updateWidths(lines, t.footerWidths, t.config.Footer.Padding) } - ctx.logger.Debugf("Initial Footer widths: %v", t.footerWidths) + ctx.logger.Debugf("Content-based widths: header=%v, row=%v, footer=%v", t.headerWidths, t.rowWidths, t.footerWidths) - // Initialize width maps for normalization - ctx.widths[tw.Header] = tw.NewMapper[int, int]() - ctx.widths[tw.Row] = tw.NewMapper[int, int]() - ctx.widths[tw.Footer] = tw.NewMapper[int, int]() - - // Normalize widths by taking the maximum across sections - for i := 0; i < ctx.numCols; i++ { - maxWidth := 0 - for _, w := range []tw.Mapper[int, int]{t.headerWidths, t.rowWidths, t.footerWidths} { - if wd := w.Get(i); wd > maxWidth { - maxWidth = wd + // Analyze header merges for optimization + var headerMergeSpans map[int]int + if t.config.Header.Formatting.MergeMode&tw.MergeHorizontal != 0 && len(ctx.headerLines) > 0 { + headerMergeSpans = make(map[int]int) + visitedCols := make(map[int]bool) + firstHeaderLine := ctx.headerLines[0] + if len(firstHeaderLine) > 0 { + for i := 0; i < len(firstHeaderLine); { + if visitedCols[i] { + i++ + continue + } + var currentLogicalCellContentBuilder strings.Builder + for _, hLine := range ctx.headerLines { + if i < len(hLine) { + currentLogicalCellContentBuilder.WriteString(hLine[i]) + } + } + currentHeaderCellContent := t.Trimmer(currentLogicalCellContentBuilder.String()) + span := 1 + for j := i + 1; j < len(firstHeaderLine); j++ { + var nextLogicalCellContentBuilder strings.Builder + for _, hLine := range ctx.headerLines { + if j < len(hLine) { + nextLogicalCellContentBuilder.WriteString(hLine[j]) + } + } + nextHeaderCellContent := t.Trimmer(nextLogicalCellContentBuilder.String()) + if currentHeaderCellContent == nextHeaderCellContent && currentHeaderCellContent != "" && currentHeaderCellContent != "-" { + span++ + } else { + break + } + } + if span > 1 { + headerMergeSpans[i] = span + for k := 0; k < span; k++ { + visitedCols[i+k] = true + } + } + i += span } } - ctx.widths[tw.Header].Set(i, maxWidth) - ctx.widths[tw.Row].Set(i, maxWidth) - ctx.widths[tw.Footer].Set(i, maxWidth) + if len(headerMergeSpans) > 0 { + ctx.logger.Debugf("Header merge spans: %v", headerMergeSpans) + } } - ctx.logger.Debugf("Normalized widths: header=%v, row=%v, footer=%v", ctx.widths[tw.Header], ctx.widths[tw.Row], ctx.widths[tw.Footer]) + + // Determine natural column widths + naturalColumnWidths := tw.NewMapper[int, int]() + for i := 0; i < ctx.numCols; i++ { + width := 0 + if colWidth, ok := t.config.Widths.PerColumn.OK(i); ok && colWidth >= 0 { + width = colWidth + ctx.logger.Debugf("Col %d width from Config.Widths.PerColumn: %d", i, width) + } else { + maxRowFooterWidth := tw.Max(t.rowWidths.Get(i), t.footerWidths.Get(i)) + headerCellOriginalWidth := t.headerWidths.Get(i) + if t.config.Behavior.Compact.Merge.Enabled() && + t.config.Header.Formatting.MergeMode&tw.MergeHorizontal != 0 && + headerMergeSpans != nil { + isColInHeaderMerge := false + for startCol, span := range headerMergeSpans { + if i >= startCol && i < startCol+span { + isColInHeaderMerge = true + break + } + } + if isColInHeaderMerge { + width = maxRowFooterWidth + if width == 0 && headerCellOriginalWidth > 0 { + width = headerCellOriginalWidth + } + ctx.logger.Debugf("Col %d (in merge) width: %d (row/footer: %d, header: %d)", i, width, maxRowFooterWidth, headerCellOriginalWidth) + } else { + width = tw.Max(headerCellOriginalWidth, maxRowFooterWidth) + ctx.logger.Debugf("Col %d (not in merge) width: %d", i, width) + } + } else { + width = tw.Max(tw.Max(headerCellOriginalWidth, t.rowWidths.Get(i)), t.footerWidths.Get(i)) + ctx.logger.Debugf("Col %d width (no merge): %d", i, width) + } + if width == 0 && (headerCellOriginalWidth > 0 || t.rowWidths.Get(i) > 0 || t.footerWidths.Get(i) > 0) { + width = tw.Max(tw.Max(headerCellOriginalWidth, t.rowWidths.Get(i)), t.footerWidths.Get(i)) + } + if width == 0 { + width = 1 + } + } + naturalColumnWidths.Set(i, width) + } + ctx.logger.Debugf("Natural column widths: %v", naturalColumnWidths) + + // Expand columns for merged header content if needed + workingWidths := naturalColumnWidths.Clone() + if t.config.Header.Formatting.MergeMode&tw.MergeHorizontal != 0 && headerMergeSpans != nil { + if span, isOneBigMerge := headerMergeSpans[0]; isOneBigMerge && span == ctx.numCols && ctx.numCols > 0 { + var firstHeaderCellLogicalContentBuilder strings.Builder + for _, hLine := range ctx.headerLines { + if 0 < len(hLine) { + firstHeaderCellLogicalContentBuilder.WriteString(hLine[0]) + } + } + mergedContentString := t.Trimmer(firstHeaderCellLogicalContentBuilder.String()) + headerCellPadding := t.config.Header.Padding.Global + if 0 < len(t.config.Header.Padding.PerColumn) && t.config.Header.Padding.PerColumn[0].Paddable() { + headerCellPadding = t.config.Header.Padding.PerColumn[0] + } + actualMergedHeaderContentPhysicalWidth := tw.DisplayWidth(mergedContentString) + + tw.DisplayWidth(headerCellPadding.Left) + + tw.DisplayWidth(headerCellPadding.Right) + currentSumOfColumnWidths := 0 + workingWidths.Each(func(_ int, w int) { currentSumOfColumnWidths += w }) + numSeparatorsInFullSpan := 0 + if ctx.numCols > 1 { + if t.renderer != nil && t.renderer.Config().Settings.Separators.BetweenColumns.Enabled() { + numSeparatorsInFullSpan = (ctx.numCols - 1) * tw.DisplayWidth(t.renderer.Config().Symbols.Column()) + } + } + totalCurrentSpanPhysicalWidth := currentSumOfColumnWidths + numSeparatorsInFullSpan + if actualMergedHeaderContentPhysicalWidth > totalCurrentSpanPhysicalWidth { + ctx.logger.Debugf("Merged header content '%s' (width %d) exceeds total width %d. Expanding.", + mergedContentString, actualMergedHeaderContentPhysicalWidth, totalCurrentSpanPhysicalWidth) + shortfall := actualMergedHeaderContentPhysicalWidth - totalCurrentSpanPhysicalWidth + numNonZeroCols := 0 + workingWidths.Each(func(_ int, w int) { + if w > 0 { + numNonZeroCols++ + } + }) + if numNonZeroCols == 0 && ctx.numCols > 0 { + numNonZeroCols = ctx.numCols + } + if numNonZeroCols > 0 && shortfall > 0 { + extraPerColumn := int(math.Ceil(float64(shortfall) / float64(numNonZeroCols))) + finalSumAfterExpansion := 0 + workingWidths.Each(func(colIdx int, currentW int) { + if currentW > 0 || (numNonZeroCols == ctx.numCols && ctx.numCols > 0) { + newWidth := currentW + extraPerColumn + workingWidths.Set(colIdx, newWidth) + finalSumAfterExpansion += newWidth + ctx.logger.Debugf("Col %d expanded by %d to %d", colIdx, extraPerColumn, newWidth) + } else { + finalSumAfterExpansion += currentW + } + }) + overDistributed := (finalSumAfterExpansion + numSeparatorsInFullSpan) - actualMergedHeaderContentPhysicalWidth + if overDistributed > 0 { + ctx.logger.Debugf("Correcting over-distribution of %d", overDistributed) + // Sort columns for deterministic reduction + sortedCols := workingWidths.SortedKeys() + for i := 0; i < overDistributed; i++ { + // Reduce from highest-indexed column + for j := len(sortedCols) - 1; j >= 0; j-- { + col := sortedCols[j] + if workingWidths.Get(col) > 1 && naturalColumnWidths.Get(col) < workingWidths.Get(col) { + workingWidths.Set(col, workingWidths.Get(col)-1) + ctx.logger.Debugf("Reduced col %d by 1 to %d", col, workingWidths.Get(col)) + break + } + } + } + } + } + } + } + } + ctx.logger.Debugf("Widths after merged header expansion: %v", workingWidths) + + // Apply global width constraint + finalWidths := workingWidths.Clone() + if t.config.Widths.Global > 0 { + ctx.logger.Debugf("Applying global width constraint: %d", t.config.Widths.Global) + currentSumOfFinalColWidths := 0 + finalWidths.Each(func(_ int, w int) { currentSumOfFinalColWidths += w }) + numSeparators := 0 + if ctx.numCols > 1 && t.renderer != nil && t.renderer.Config().Settings.Separators.BetweenColumns.Enabled() { + numSeparators = (ctx.numCols - 1) * tw.DisplayWidth(t.renderer.Config().Symbols.Column()) + } + totalCurrentTablePhysicalWidth := currentSumOfFinalColWidths + numSeparators + if totalCurrentTablePhysicalWidth > t.config.Widths.Global { + ctx.logger.Debugf("Table width %d exceeds global limit %d. Shrinking.", totalCurrentTablePhysicalWidth, t.config.Widths.Global) + targetTotalColumnContentWidth := t.config.Widths.Global - numSeparators + if targetTotalColumnContentWidth < 0 { + targetTotalColumnContentWidth = 0 + } + if ctx.numCols > 0 && targetTotalColumnContentWidth < ctx.numCols { + targetTotalColumnContentWidth = ctx.numCols + } + hardMinimums := tw.NewMapper[int, int]() + sumOfHardMinimums := 0 + isHeaderContentHardToWrap := !(t.config.Header.Formatting.AutoWrap == tw.WrapNormal || t.config.Header.Formatting.AutoWrap == tw.WrapBreak) + for i := 0; i < ctx.numCols; i++ { + minW := 1 + if isHeaderContentHardToWrap && len(ctx.headerLines) > 0 { + headerColNaturalWidthWithPadding := t.headerWidths.Get(i) + if headerColNaturalWidthWithPadding > minW { + minW = headerColNaturalWidthWithPadding + } + } + hardMinimums.Set(i, minW) + sumOfHardMinimums += minW + } + ctx.logger.Debugf("Hard minimums: %v (sum: %d)", hardMinimums, sumOfHardMinimums) + if targetTotalColumnContentWidth < sumOfHardMinimums && sumOfHardMinimums > 0 { + ctx.logger.Warnf("Target width %d below minimums %d. Scaling.", targetTotalColumnContentWidth, sumOfHardMinimums) + scaleFactorMin := float64(targetTotalColumnContentWidth) / float64(sumOfHardMinimums) + if scaleFactorMin < 0 { + scaleFactorMin = 0 + } + tempSum := 0 + scaledHardMinimums := tw.NewMapper[int, int]() + hardMinimums.Each(func(colIdx int, currentMinW int) { + scaledMinW := int(math.Round(float64(currentMinW) * scaleFactorMin)) + if scaledMinW < 1 && targetTotalColumnContentWidth > 0 { + scaledMinW = 1 + } else if scaledMinW < 0 { + scaledMinW = 0 + } + scaledHardMinimums.Set(colIdx, scaledMinW) + tempSum += scaledMinW + }) + errorDiffMin := targetTotalColumnContentWidth - tempSum + if errorDiffMin != 0 && scaledHardMinimums.Len() > 0 { + sortedKeys := scaledHardMinimums.SortedKeys() + for i := 0; i < int(math.Abs(float64(errorDiffMin))); i++ { + keyToAdjust := sortedKeys[i%len(sortedKeys)] + val := scaledHardMinimums.Get(keyToAdjust) + adj := 1 + if errorDiffMin < 0 { + adj = -1 + } + if val+adj >= 1 || (val+adj == 0 && targetTotalColumnContentWidth == 0) { + scaledHardMinimums.Set(keyToAdjust, val+adj) + } else if adj > 0 { + scaledHardMinimums.Set(keyToAdjust, val+adj) + } + } + } + finalWidths = scaledHardMinimums.Clone() + ctx.logger.Debugf("Scaled minimums: %v", finalWidths) + } else { + finalWidths = hardMinimums.Clone() + widthAllocatedByMinimums := sumOfHardMinimums + remainingWidthToDistribute := targetTotalColumnContentWidth - widthAllocatedByMinimums + ctx.logger.Debugf("Target: %d, minimums: %d, remaining: %d", targetTotalColumnContentWidth, widthAllocatedByMinimums, remainingWidthToDistribute) + if remainingWidthToDistribute > 0 { + sumOfFlexiblePotentialBase := 0 + flexibleColsOriginalWidths := tw.NewMapper[int, int]() + for i := 0; i < ctx.numCols; i++ { + naturalW := workingWidths.Get(i) + minW := hardMinimums.Get(i) + if naturalW > minW { + sumOfFlexiblePotentialBase += (naturalW - minW) + flexibleColsOriginalWidths.Set(i, naturalW) + } + } + ctx.logger.Debugf("Flexible potential: %d, flexible widths: %v", sumOfFlexiblePotentialBase, flexibleColsOriginalWidths) + if sumOfFlexiblePotentialBase > 0 { + distributedExtraSum := 0 + sortedFlexKeys := flexibleColsOriginalWidths.SortedKeys() + for _, colIdx := range sortedFlexKeys { + naturalWOfCol := flexibleColsOriginalWidths.Get(colIdx) + hardMinOfCol := hardMinimums.Get(colIdx) + flexiblePartOfCol := naturalWOfCol - hardMinOfCol + proportion := 0.0 + if sumOfFlexiblePotentialBase > 0 { + proportion = float64(flexiblePartOfCol) / float64(sumOfFlexiblePotentialBase) + } else if len(sortedFlexKeys) > 0 { + proportion = 1.0 / float64(len(sortedFlexKeys)) + } + extraForThisCol := int(math.Round(float64(remainingWidthToDistribute) * proportion)) + currentAssignedW := finalWidths.Get(colIdx) + finalWidths.Set(colIdx, currentAssignedW+extraForThisCol) + distributedExtraSum += extraForThisCol + } + errorInDist := remainingWidthToDistribute - distributedExtraSum + ctx.logger.Debugf("Distributed %d, error: %d", distributedExtraSum, errorInDist) + if errorInDist != 0 && len(sortedFlexKeys) > 0 { + for i := 0; i < int(math.Abs(float64(errorInDist))); i++ { + colToAdjust := sortedFlexKeys[i%len(sortedFlexKeys)] + w := finalWidths.Get(colToAdjust) + adj := 1 + if errorInDist < 0 { + adj = -1 + } + if !(adj < 0 && w+adj < hardMinimums.Get(colToAdjust)) { + finalWidths.Set(colToAdjust, w+adj) + } else if adj > 0 { + finalWidths.Set(colToAdjust, w+adj) + } + } + } + } else { + if ctx.numCols > 0 { + extraPerCol := remainingWidthToDistribute / ctx.numCols + rem := remainingWidthToDistribute % ctx.numCols + for i := 0; i < ctx.numCols; i++ { + currentW := finalWidths.Get(i) + add := extraPerCol + if i < rem { + add++ + } + finalWidths.Set(i, currentW+add) + } + } + } + } + } + finalSumCheck := 0 + finalWidths.Each(func(idx int, w int) { + if w < 1 && targetTotalColumnContentWidth > 0 { + finalWidths.Set(idx, 1) + } else if w < 0 { + finalWidths.Set(idx, 0) + } + finalSumCheck += finalWidths.Get(idx) + }) + ctx.logger.Debugf("Final widths after scaling: %v (sum: %d, target: %d)", finalWidths, finalSumCheck, targetTotalColumnContentWidth) + } + } + + // Assign final widths to context + ctx.widths[tw.Header] = finalWidths.Clone() + ctx.widths[tw.Row] = finalWidths.Clone() + ctx.widths[tw.Footer] = finalWidths.Clone() + ctx.logger.Debugf("Final normalized widths: header=%v, row=%v, footer=%v", ctx.widths[tw.Header], ctx.widths[tw.Row], ctx.widths[tw.Footer]) return nil } // calculateContentMaxWidth computes the maximum content width for a column, accounting for padding and mode-specific constraints. // Returns the effective content width (after subtracting padding) for the given column index. func (t *Table) calculateContentMaxWidth(colIdx int, config tw.CellConfig, padLeftWidth, padRightWidth int, isStreaming bool) int { - var effectiveContentMaxWidth int + if isStreaming { + // Existing streaming logic remains unchanged totalColumnWidthFromStream := t.streamWidths.Get(colIdx) if totalColumnWidthFromStream < 0 { totalColumnWidthFromStream = 0 @@ -652,28 +957,57 @@ func (t *Table) calculateContentMaxWidth(colIdx int, config tw.CellConfig, padLe if totalColumnWidthFromStream == 0 { effectiveContentMaxWidth = 0 } - t.logger.Debugf("calculateContentMaxWidth: Streaming col %d, TotalColWd=%d, PadL=%d, PadR=%d -> ContentMaxWd=%d", - colIdx, totalColumnWidthFromStream, padLeftWidth, padRightWidth, effectiveContentMaxWidth) + t.logger.Debugf("calculateContentMaxWidth: Streaming col %d, TotalColWd=%d, PadL=%d, PadR=%d -> ContentMaxWd=%d", colIdx, totalColumnWidthFromStream, padLeftWidth, padRightWidth, effectiveContentMaxWidth) } else { - hasConstraint := false + // New priority-based width constraint checking constraintTotalCellWidth := 0 - if config.ColMaxWidths.PerColumn != nil { + hasConstraint := false + + // 1. Check new Widths.PerColumn (highest priority) + if t.config.Widths.Constrained() { + + if colWidth, ok := t.config.Widths.PerColumn.OK(colIdx); ok && colWidth > 0 { + constraintTotalCellWidth = colWidth + hasConstraint = true + t.logger.Debugf("calculateContentMaxWidth: Using Widths.PerColumn[%d] = %d", + colIdx, constraintTotalCellWidth) + } + + // 2. Check new Widths.Global + if !hasConstraint && t.config.Widths.Global > 0 { + constraintTotalCellWidth = t.config.Widths.Global + hasConstraint = true + t.logger.Debugf("calculateContentMaxWidth: Using Widths.Global = %d", constraintTotalCellWidth) + } + } + + // 3. Fall back to legacy ColMaxWidths.PerColumn (backward compatibility) + if !hasConstraint && config.ColMaxWidths.PerColumn != nil { if colMax, ok := config.ColMaxWidths.PerColumn.OK(colIdx); ok && colMax > 0 { constraintTotalCellWidth = colMax hasConstraint = true - t.logger.Debugf("calculateContentMaxWidth: Batch col %d using config.ColMaxWidths.PerColumn (as total cell width constraint): %d", colIdx, constraintTotalCellWidth) + t.logger.Debugf("calculateContentMaxWidth: Using legacy ColMaxWidths.PerColumn[%d] = %d", + colIdx, constraintTotalCellWidth) } } + + // 4. Fall back to legacy ColMaxWidths.Global if !hasConstraint && config.ColMaxWidths.Global > 0 { constraintTotalCellWidth = config.ColMaxWidths.Global hasConstraint = true - t.logger.Debugf("calculateContentMaxWidth: Batch col %d using config.Formatting.MaxWidth (as total cell width constraint): %d", colIdx, constraintTotalCellWidth) + t.logger.Debugf("calculateContentMaxWidth: Using legacy ColMaxWidths.Global = %d", + constraintTotalCellWidth) } + + // 5. Fall back to table MaxWidth if auto-wrapping if !hasConstraint && t.config.MaxWidth > 0 && config.Formatting.AutoWrap != tw.WrapNone { constraintTotalCellWidth = t.config.MaxWidth hasConstraint = true - t.logger.Debugf("calculateContentMaxWidth: Batch col %d using t.config.MaxWidth (as total cell width constraint, due to AutoWrap != WrapNone): %d", colIdx, constraintTotalCellWidth) + t.logger.Debugf("calculateContentMaxWidth: Using table MaxWidth = %d (AutoWrap enabled)", + constraintTotalCellWidth) } + + // Calculate effective width based on found constraint if hasConstraint { effectiveContentMaxWidth = constraintTotalCellWidth - padLeftWidth - padRightWidth if effectiveContentMaxWidth < 1 && constraintTotalCellWidth > (padLeftWidth+padRightWidth) { @@ -681,13 +1015,14 @@ func (t *Table) calculateContentMaxWidth(colIdx int, config tw.CellConfig, padLe } else if effectiveContentMaxWidth < 0 { effectiveContentMaxWidth = 0 } - t.logger.Debugf("calculateContentMaxWidth: Batch col %d, ConstraintTotalCellWidth=%d, PadL=%d, PadR=%d -> EffectiveContentMaxWidth=%d", - colIdx, constraintTotalCellWidth, padLeftWidth, padRightWidth, effectiveContentMaxWidth) + t.logger.Debugf("calculateContentMaxWidth: ConstraintTotalCellWidth=%d, PadL=%d, PadR=%d -> EffectiveContentMaxWidth=%d", + constraintTotalCellWidth, padLeftWidth, padRightWidth, effectiveContentMaxWidth) } else { effectiveContentMaxWidth = 0 - t.logger.Debugf("calculateContentMaxWidth: Batch col %d, No applicable MaxWidth constraint. EffectiveContentMaxWidth set to 0 (unlimited for this stage).", colIdx) + t.logger.Debugf("calculateContentMaxWidth: No width constraints found for column %d", colIdx) } } + return effectiveContentMaxWidth } @@ -698,6 +1033,8 @@ func (t *Table) convertToStringer(input interface{}) ([]string, error) { return nil, errors.New("internal error: convertToStringer called with nil t.stringer") } + t.logger.Debugf("convertToString attempt %v using %v", input, t.stringer) + inputType := reflect.TypeOf(input) stringerFuncVal := reflect.ValueOf(t.stringer) stringerFuncType := stringerFuncVal.Type() @@ -1310,7 +1647,8 @@ func (t *Table) updateWidths(row []string, widths tw.Mapper[int, int], padding t t.logger.Debugf("Updating widths for row: %v", row) for i, cell := range row { colPad := padding.Global - if i < len(padding.PerColumn) && padding.PerColumn[i] != (tw.Padding{}) { + + if i < len(padding.PerColumn) && padding.PerColumn[i].Paddable() { colPad = padding.PerColumn[i] t.logger.Debugf(" Col %d: Using per-column padding: L:'%s' R:'%s'", i, colPad.Left, colPad.Right) } else { diff --git a/vendor/modules.txt b/vendor/modules.txt index 34c553b32c..ef92749649 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -1034,12 +1034,12 @@ github.com/oklog/run # github.com/olekukonko/errors v0.0.0-20250405072817-4e6d85265da6 ## explicit; go 1.21 github.com/olekukonko/errors -# github.com/olekukonko/ll v0.0.8-0.20250516010636-22ea57d81985 +# github.com/olekukonko/ll v0.0.8 ## explicit; go 1.21 github.com/olekukonko/ll github.com/olekukonko/ll/lh github.com/olekukonko/ll/lx -# github.com/olekukonko/tablewriter v1.0.6 +# github.com/olekukonko/tablewriter v1.0.7 ## explicit; go 1.21 github.com/olekukonko/tablewriter github.com/olekukonko/tablewriter/pkg/twwarp