Added rudimentary text table output

Author: djthorpe

go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/djthorpe/go-errors v1.0.3
 	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.8.4
+	golang.org/x/exp v0.0.0-20231127185646-65229373498e
 	golang.org/x/term v0.15.0
 )
 

go.sum

@@ -8,6 +8,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+golang.org/x/exp v0.0.0-20231127185646-65229373498e h1:Gvh4YaCaXNs6dKTlfgismwWZKyjVZXwOPfIyUaqU3No=
+golang.org/x/exp v0.0.0-20231127185646-65229373498e/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI=
 golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
 golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4=

pkg/writer/iterator.go

@@ -58,6 +58,11 @@ func (i *iterator) String() string {
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
+// Return the number of elements
+func (i *iterator) Reset() {
+	i.index = 0
+}
+
 // Return the number of elements
 func (i *iterator) Len() int {
 	return i.slice.Len()

pkg/writer/table.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	// Packages
+	"golang.org/x/exp/slices"
 
 	// Namespace imports
 	. "github.com/djthorpe/go-errors"
@@ -35,17 +36,14 @@ type TableMeta struct {
 }
 
 type ColumnMeta struct {
-	Key     string     // the unique key of the field
-	Name    string     // the name of the field
-	Index   []int      // the index of the field
-	Tuples  []string   // the tuples from the tag
-	NonZero bool       // true if there is a non-zero value in this column
-	Width   int        // the maximum we column
-	Flags   FormatFlag // the formatting for the column
+	Key     string   // the unique key of the field
+	Name    string   // the name of the field
+	Index   []int    // the index of the field
+	Tuples  []string // the tuples from the tag
+	NonZero bool     // true if there is a non-zero value in this column
+	Width   int      // the maximum we column
 }
 
-type FormatFlag uint
-
 ///////////////////////////////////////////////////////////////////////////////
 // GLBOALS
 
@@ -54,10 +52,7 @@ const (
 	tagWriter        = "writer"
 	nilValue         = "<nil>"
 	defaultTextWidth = 70
-)
-
-const (
-	FormatAlignLeft FormatFlag = 1 << iota
+	tagAlignRight    = "alignright"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -144,13 +139,9 @@ func (t *TableMeta) Header() []string {
 	return names
 }
 
-// Returns a header for Text output
-func (t *TableMeta) HeaderAny() []any {
-	names := make([]any, len(t.Columns))
-	for i, col := range t.Columns {
-		names[i] = col.Name
-	}
-	return names
+// Reset the iterator
+func (t *TableMeta) Reset() {
+	t.Iterator.Reset()
 }
 
 // Returns the next row of values, or nil if there are no more rows
@@ -174,6 +165,10 @@ func (t *TableMeta) NextRow() []any {
 	return t.row
 }
 
+func (m ColumnMeta) IsAlignRight() bool {
+	return slices.Contains(m.Tuples, tagAlignRight)
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 

pkg/writer/text.go

@@ -4,46 +4,93 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"unicode/utf8"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
 type TextWriter struct {
-	format string
+	row  []any
+	meta []ColumnMeta
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CONSTRUCTOR
 
 // Write outputs the table to a writer
-func NewTextWriter(columns []ColumnMeta, delim rune) *TextWriter {
+func NewTextWriter(columns []ColumnMeta) *TextWriter {
 	self := new(TextWriter)
+	self.row = make([]any, len(columns))
+	self.meta = make([]ColumnMeta, len(columns))
+	copy(self.meta, columns)
 
+	// Return success
+	return self
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Create a format string for the writer
+func (self *TextWriter) Formatln(delim rune) string {
 	// Create the format from the column metadata
 	f := new(strings.Builder)
 	f.WriteRune(delim)
-	for _, column := range columns {
+	for _, column := range self.meta {
 		f.WriteRune('%')
-		if column.Flags&FormatAlignLeft != 0 {
+		if !column.IsAlignRight() {
 			f.WriteRune('-')
 		}
 		if column.Width > 0 {
 			f.WriteString(fmt.Sprint(column.Width))
+		} else if column.Width < 0 {
+			f.WriteString(fmt.Sprint(-column.Width))
 		}
 		f.WriteRune('s')
 		f.WriteRune(delim)
 	}
-	self.format = f.String()
-	return self
+	fmt.Println(f.String())
+	return f.String()
 }
 
-func (self *TextWriter) Writeln(w io.Writer, elems []any) error {
-	if _, err := fmt.Fprintf(w, self.format, elems...); err != nil {
+// Determine the maximum width of each column
+func (self *TextWriter) Sizeln(elems []string) {
+	for i, elem := range elems {
+		w, _ := textSize(elem)
+		if self.meta[i].Width == 0 {
+			self.meta[i].Width = w
+		} else if w > 0 && w > -self.meta[i].Width {
+			self.meta[i].Width = -w
+		}
+	}
+}
+
+// Write a row to the writer
+func (self *TextWriter) Writeln(w io.Writer, format string, elems []string) error {
+	for i, elem := range elems {
+		self.row[i] = elem
+	}
+	if _, err := fmt.Fprintf(w, format, self.row...); err != nil {
 		return err
 	}
 	if _, err := fmt.Fprintln(w); err != nil {
 		return err
 	}
 	return nil
 }
+
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+// Returns the maximum width of a line in runes, and the height
+func textSize(elem string) (int, int) {
+	lines := strings.Split(elem, "\n")
+	max := 0
+	for _, line := range lines {
+		if runes := utf8.RuneCountInString(line); runes > max {
+			max = runes
+		}
+	}
+	return max, len(lines)
+}

pkg/writer/writer.go

@@ -38,18 +38,6 @@ func (meta *TableMeta) toString(elems []any, quote bool) ([]string, error) {
 	return meta.rowstr, nil
 }
 
-// Create an array of strings representing the row
-func (meta *TableMeta) toStringAny(elems []any, quote bool) ([]any, error) {
-	for i, elem := range elems {
-		if bytes, err := Marshal(elem, quote); err != nil {
-			return nil, err
-		} else {
-			meta.row[i] = string(bytes)
-		}
-	}
-	return meta.row, nil
-}
-
 func (self *TableWriter) writeCSV(meta *TableMeta, w io.Writer) error {
 	csv := csv.NewWriter(w)
 	csv.Comma = meta.delim
@@ -78,27 +66,36 @@ func (self *TableWriter) writeCSV(meta *TableMeta, w io.Writer) error {
 }
 
 func (self *TableWriter) writeText(meta *TableMeta, w io.Writer) error {
-	text := NewTextWriter(meta.Columns, meta.delim)
+	text := NewTextWriter(meta.Columns)
 
+	var format string
 	for pass := int(0); pass < 2; pass++ {
+		// Set the format string
+		if pass > 0 {
+			format = text.Formatln('|')
+		}
 		// Write header
 		if meta.header {
+			header := meta.Header()
 			if pass == 0 {
-				// TODO: Adjust the column widths
-			} else if err := text.Writeln(w, meta.HeaderAny()); err != nil {
+				// Set maximal widths
+				text.Sizeln(header)
+			} else if err := text.Writeln(w, format, header); err != nil {
 				return err
 			}
 		}
 
 		// Write rows
+		meta.Reset()
 		for elems := meta.NextRow(); elems != nil; elems = meta.NextRow() {
-			row, err := meta.toStringAny(elems, false)
+			row, err := meta.toString(elems, false)
 			if err != nil {
 				return err
 			}
 			if pass == 0 {
-				// TODO: Adjust the column widths
-			} else if err := text.Writeln(w, row); err != nil {
+				// Set maximal widths
+				text.Sizeln(row)
+			} else if err := text.Writeln(w, format, row); err != nil {
 				return err
 			}
 		}