mirror of
https://codeberg.org/scip/esctl.git
synced 2026-08-24 12:44:18 +02:00
307 lines
6.8 KiB
Go
307 lines
6.8 KiB
Go
/*
|
|
Copyright © 2026 Thomas von Dein
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package printer
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"codeberg.org/scip/esctl/pkg/cfg"
|
|
"github.com/olekukonko/tablewriter"
|
|
"github.com/olekukonko/tablewriter/renderer"
|
|
"github.com/olekukonko/tablewriter/tw"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type Table struct {
|
|
Mode string // table, markdown, json
|
|
Headers []string
|
|
Entries [][]string
|
|
|
|
lenHeaders []int
|
|
}
|
|
|
|
func NewTable(conf *cfg.Config, columns, rows int) *Table {
|
|
table := Table{Mode: conf.Output}
|
|
|
|
table.Headers = make([]string, columns)
|
|
table.Entries = make([][]string, rows)
|
|
table.lenHeaders = make([]int, columns)
|
|
|
|
return &table
|
|
}
|
|
|
|
func (data *Table) Print() error {
|
|
switch data.Mode {
|
|
case "markdown", "md":
|
|
return data.PrintMarkdown()
|
|
case "json":
|
|
return data.PrintJSON()
|
|
case "yaml":
|
|
return data.PrintYAML()
|
|
default:
|
|
return data.PrintTSV()
|
|
}
|
|
}
|
|
|
|
var (
|
|
ansiCtrlSeq = regexp.MustCompile(`\033.[0-9;]+m`)
|
|
)
|
|
|
|
// needed for json and yaml output
|
|
func (data *Table) toMap() []map[string]string {
|
|
raw := make([]map[string]string, len(data.Entries))
|
|
|
|
for idx, entries := range data.Entries {
|
|
raw[idx] = make(map[string]string, len(data.Headers))
|
|
for eidx, entry := range entries {
|
|
raw[idx][data.Headers[eidx]] = entry
|
|
}
|
|
}
|
|
|
|
return raw
|
|
}
|
|
|
|
func (data *Table) PrintYAML() error {
|
|
raw := data.toMap()
|
|
|
|
body, err := yaml.Marshal(raw)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to produce YAML output: %s", err)
|
|
}
|
|
|
|
fmt.Println(string(body))
|
|
|
|
return nil
|
|
}
|
|
|
|
func (data *Table) PrintJSON() error {
|
|
raw := data.toMap()
|
|
|
|
body, err := json.MarshalIndent(raw, "", " ")
|
|
if err != nil {
|
|
return fmt.Errorf("failed to produce JSON output: %s", err)
|
|
}
|
|
|
|
fmt.Println(string(body))
|
|
|
|
return nil
|
|
}
|
|
|
|
// Well. tablewriter should be able to print in TSV mode, but it
|
|
// doesn't work because of the various ansic color escapes we're
|
|
// using. Therefore we do it the hard way and use our own TSV printer.
|
|
func (data *Table) PrintTSV() error {
|
|
// determine lenght's
|
|
for idx, head := range data.Headers {
|
|
data.lenHeaders[idx] = visibleLen(head)
|
|
}
|
|
|
|
for _, entries := range data.Entries {
|
|
for idx, entry := range entries {
|
|
length := visibleLen(entry)
|
|
if data.lenHeaders[idx] < length {
|
|
data.lenHeaders[idx] = length
|
|
}
|
|
}
|
|
}
|
|
|
|
// output
|
|
for idx, header := range data.Headers {
|
|
fmt.Print(header, strings.Repeat(" ", data.lenHeaders[idx]-visibleLen(header)))
|
|
if idx < len(data.Headers)-1 {
|
|
fmt.Print(" ")
|
|
}
|
|
}
|
|
fmt.Println()
|
|
|
|
for _, entries := range data.Entries {
|
|
for idx, entry := range entries {
|
|
length := visibleLen(entry)
|
|
|
|
if isInt(entry) {
|
|
// align right
|
|
fmt.Print(strings.Repeat(" ", data.lenHeaders[idx]-length), entry)
|
|
} else {
|
|
fmt.Print(entry, strings.Repeat(" ", data.lenHeaders[idx]-length))
|
|
}
|
|
|
|
if idx < len(data.Headers)-1 {
|
|
fmt.Print(" ")
|
|
}
|
|
}
|
|
fmt.Println()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (data *Table) PrintTabularFail() error {
|
|
OFS := " "
|
|
|
|
tableString := &strings.Builder{}
|
|
|
|
styleTSV := tw.NewSymbolCustom("space").WithColumn("\t")
|
|
|
|
table := tablewriter.NewTable(tableString,
|
|
tablewriter.WithRenderer(
|
|
renderer.NewBlueprint(tw.Rendition{
|
|
Borders: tw.BorderNone,
|
|
Symbols: styleTSV,
|
|
Settings: tw.Settings{
|
|
Separators: tw.SeparatorsNone,
|
|
Lines: tw.LinesNone,
|
|
},
|
|
})),
|
|
tablewriter.WithConfig(tablewriter.Config{
|
|
Header: tw.CellConfig{
|
|
Formatting: tw.CellFormatting{
|
|
AutoFormat: tw.Off,
|
|
},
|
|
Padding: tw.CellPadding{Global: tw.Padding{Left: "", Right: OFS}},
|
|
},
|
|
Row: tw.CellConfig{
|
|
Formatting: tw.CellFormatting{
|
|
AutoWrap: tw.WrapNone,
|
|
Alignment: tw.AlignLeft,
|
|
},
|
|
Padding: tw.CellPadding{Global: tw.Padding{Right: OFS}},
|
|
},
|
|
|
|
Debug: true,
|
|
}),
|
|
)
|
|
|
|
table.Header(data.Headers)
|
|
|
|
if err := table.Bulk(data.Entries); err != nil {
|
|
return fmt.Errorf("failed to add data to table renderer: %s", err)
|
|
}
|
|
|
|
if err := table.Render(); err != nil {
|
|
return fmt.Errorf("failed to render table: %s", err)
|
|
}
|
|
|
|
// we need to trim our output here, because tablewriter appends
|
|
// excess whitespace to our rows.
|
|
cleanedString := &strings.Builder{}
|
|
|
|
for _, row := range strings.Split(strings.TrimSpace(tableString.String()), "\n") {
|
|
cleanedString.WriteString(strings.TrimSpace(row))
|
|
cleanedString.WriteString("\n")
|
|
}
|
|
|
|
fmt.Println(cleanedString.String())
|
|
|
|
return nil
|
|
}
|
|
|
|
func (data *Table) PrintMarkdown() error {
|
|
tableString := &strings.Builder{}
|
|
|
|
table := tablewriter.NewTable(tableString,
|
|
tablewriter.WithRenderer(
|
|
renderer.NewBlueprint(
|
|
tw.Rendition{
|
|
Borders: tw.Border{
|
|
Left: tw.On,
|
|
Right: tw.On,
|
|
Top: tw.Off,
|
|
Bottom: tw.Off,
|
|
},
|
|
Settings: tw.Settings{
|
|
Separators: tw.Separators{
|
|
ShowHeader: tw.On,
|
|
ShowFooter: tw.Off,
|
|
BetweenRows: tw.Off,
|
|
BetweenColumns: 0,
|
|
},
|
|
},
|
|
Symbols: tw.NewSymbols(tw.StyleMarkdown),
|
|
})),
|
|
|
|
tablewriter.WithConfig(
|
|
tablewriter.Config{
|
|
Header: tw.CellConfig{
|
|
Formatting: tw.CellFormatting{
|
|
Alignment: tw.AlignLeft,
|
|
AutoFormat: tw.Off,
|
|
},
|
|
},
|
|
Row: tw.CellConfig{
|
|
Formatting: tw.CellFormatting{
|
|
Alignment: tw.AlignLeft,
|
|
},
|
|
},
|
|
},
|
|
),
|
|
)
|
|
|
|
table.Header(data.Headers)
|
|
|
|
if err := table.Bulk(data.Entries); err != nil {
|
|
return fmt.Errorf("failed to add data to table renderer: %s", err)
|
|
}
|
|
|
|
if err := table.Render(); err != nil {
|
|
return fmt.Errorf("failed to render table: %s", err)
|
|
}
|
|
|
|
fmt.Println(tableString.String())
|
|
|
|
return nil
|
|
}
|
|
|
|
func (data *Table) Sort() {
|
|
// sanity checks
|
|
if len(data.Entries) == 0 {
|
|
return
|
|
}
|
|
|
|
sort.Slice(data.Entries, func(i, j int) bool {
|
|
return data.Entries[i][0] < data.Entries[j][0]
|
|
})
|
|
}
|
|
|
|
func (data *Table) Addheaders(headers ...string) {
|
|
for idx, header := range headers {
|
|
switch data.Mode {
|
|
case "json", "yaml":
|
|
data.Headers[idx] = strings.ReplaceAll(strings.ToLower(header), " ", "_")
|
|
default:
|
|
data.Headers[idx] = bold(strings.ReplaceAll(strings.ToUpper(header), " ", "-"))
|
|
}
|
|
}
|
|
}
|
|
|
|
// return the length of a string but only visible chars, w/o ansi color escapes
|
|
func visibleLen(word string) int {
|
|
return len(ansiCtrlSeq.ReplaceAllLiteralString(word, ""))
|
|
}
|
|
|
|
func isInt(num string) bool {
|
|
if _, err := strconv.Atoi(num); err == nil {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|