Tables without headers.

Author: markkurossi

data.go

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2020 Markku Rossi
+// Copyright (c) 2020-2021 Markku Rossi
 //
 // All rights reserved.
 //
@@ -14,7 +14,7 @@ import (
 var (
 	_ = Data((&Value{}))
 	_ = Data((&Lines{}))
-	_ = Data((&Array{}))
+	_ = Data((&Slice{}))
 )
 
 // Data contains table cell data.
@@ -117,27 +117,27 @@ func (lines *Lines) String() string {
 	return strings.Join(lines.Lines, "\n")
 }
 
-// NewArray creates a new Array Data type with the specified maximum
+// NewSlice creates a new Slice Data type with the specified maximum
 // rendering width.
-func NewArray(maxWidth int) *Array {
-	return &Array{
+func NewSlice(maxWidth int) *Slice {
+	return &Slice{
 		maxWidth: maxWidth,
 	}
 }
 
-// Array implements the Data interface for an array of Data elements.
-type Array struct {
+// Slice implements the Data interface for an array of Data elements.
+type Slice struct {
 	maxWidth int
 	height   int
 	content  []Data
 	lines    []string
 }
 
-func (arr *Array) addLine(line string) {
+func (arr *Slice) addLine(line string) {
 	arr.lines = append(arr.lines, line)
 }
 
-func (arr *Array) layout() {
+func (arr *Slice) layout() {
 	if len(arr.lines) > 0 {
 		return
 	}
@@ -174,12 +174,12 @@ func (arr *Array) layout() {
 }
 
 // Append adds data to the array.
-func (arr *Array) Append(data Data) {
+func (arr *Slice) Append(data Data) {
 	arr.content = append(arr.content, data)
 }
 
 // Width implements the Data.Width().
-func (arr *Array) Width(m Measure) int {
+func (arr *Slice) Width(m Measure) int {
 	arr.layout()
 
 	var max int
@@ -193,20 +193,20 @@ func (arr *Array) Width(m Measure) int {
 }
 
 // Height implements the Data.Height().
-func (arr *Array) Height() int {
+func (arr *Slice) Height() int {
 	arr.layout()
 	return len(arr.lines)
 }
 
 // Content implements the Data.Content().
-func (arr *Array) Content(row int) string {
+func (arr *Slice) Content(row int) string {
 	if row < len(arr.lines) {
 		return arr.lines[row]
 	}
 	return ""
 }
 
-func (arr *Array) String() string {
+func (arr *Slice) String() string {
 	result := "["
 	for idx, c := range arr.content {
 		if idx > 0 {

example_test.go

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2020 Markku Rossi
+// Copyright (c) 2020-2021 Markku Rossi
 //
 // All rights reserved.
 //
@@ -122,7 +122,7 @@ func ExampleReflect() {
 	tab := New(ASCII)
 	tab.Header("Key").SetAlign(ML)
 	tab.Header("Value")
-	err := Reflect(tab, 0, nil, &Book{
+	err := Reflect(tab, InheritHeaders, nil, &Book{
 		Title: "Structure and Interpretation of Computer Programs",
 		Author: []Person{
 			{
@@ -166,6 +166,47 @@ func ExampleReflect() {
 	// +-----------+---------------------------------------------------+
 }
 
+func ExampleArray() {
+	tab, err := Array(New(ASCII), [][]interface{}{
+		{"a", "b", "c"},
+		{"1", "2", "3"},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+	tab.Print(os.Stdout)
+	// Output: +---+---+---+
+	// | a | b | c |
+	// +---+---+---+
+	// | 1 | 2 | 3 |
+	// +---+---+---+
+}
+
+func ExampleArray_second() {
+	tab, err := Array(New(Unicode), [][]interface{}{
+		{"int", "float", "struct"},
+		{42, 3.14, struct {
+			ival   int
+			strval string
+		}{
+			ival:   42,
+			strval: "Hello, world!",
+		}},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+	tab.Print(os.Stdout)
+	// Output: ┏━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+	// ┃ int ┃ float ┃ struct                     ┃
+	// ┡━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+	// │ 42  │ 3.14  │ ┌────────┬───────────────┐ │
+	// │     │       │ │ ival   │ 42            │ │
+	// │     │       │ │ strval │ Hello, world! │ │
+	// │     │       │ └────────┴───────────────┘ │
+	// └─────┴───────┴────────────────────────────┘
+}
+
 func ExampleTabulate_MarshalJSON() {
 	tab := New(Unicode)
 	tab.Header("Key").SetAlign(MR)

json.go

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2020 Markku Rossi
+// Copyright (c) 2020-2021 Markku Rossi
 //
 // All rights reserved.
 //
@@ -60,7 +60,7 @@ func (v *Value) marshalJSON() (interface{}, error) {
 	return v.value, nil
 }
 
-func (arr *Array) marshalJSON() (interface{}, error) {
+func (arr *Slice) marshalJSON() (interface{}, error) {
 	var content []interface{}
 
 	for _, data := range arr.content {

reflect.go

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2020 Markku Rossi
+// Copyright (c) 2020-2021 Markku Rossi
 //
 // All rights reserved.
 //
@@ -21,6 +21,7 @@ type Flags int
 // Flag values for reflection tabulation.
 const (
 	OmitEmpty Flags = 1 << iota
+	InheritHeaders
 )
 
 const nilLabel = "<nil>"
@@ -63,6 +64,39 @@ func Reflect(tab *Tabulate, flags Flags, tags []string, v interface{}) error {
 	return nil
 }
 
+// Array tabulates the argument v into rows and columns. If the tab
+// defines header columns, those will be used. Otherwise the first row
+// of v defines the header columns.
+func Array(tab *Tabulate, v [][]interface{}) (*Tabulate, error) {
+	flags := OmitEmpty
+	tags := make(map[string]bool)
+
+	if len(tab.Headers) == 0 {
+		if len(v) == 0 {
+			return tab, nil
+		}
+		for _, c := range v[0] {
+			data, err := reflectValue(tab, flags, tags, reflect.ValueOf(c))
+			if err != nil {
+				return nil, err
+			}
+			tab.HeaderData(data)
+		}
+		v = v[1:]
+	}
+	for _, r := range v {
+		row := tab.Row()
+		for _, c := range r {
+			data, err := reflectValue(tab, flags, tags, reflect.ValueOf(c))
+			if err != nil {
+				return nil, err
+			}
+			row.ColumnData(data)
+		}
+	}
+	return tab, nil
+}
+
 func reflectValue(tab *Tabulate, flags Flags, tags map[string]bool,
 	value reflect.Value) (Data, error) {
 
@@ -115,6 +149,9 @@ func reflectValue(tab *Tabulate, flags Flags, tags map[string]bool,
 	case reflect.Map:
 		if value.Len() > 0 || flags&OmitEmpty == 0 {
 			sub := tab.Clone()
+			if flags&InheritHeaders == 0 {
+				sub.Headers = nil
+			}
 			err := reflectMap(sub, flags, tags, value)
 			if err != nil {
 				return nil, err
@@ -143,6 +180,9 @@ func reflectValue(tab *Tabulate, flags Flags, tags map[string]bool,
 
 	case reflect.Struct:
 		sub := tab.Clone()
+		if flags&InheritHeaders == 0 {
+			sub.Headers = nil
+		}
 		err := reflectStruct(sub, flags, tags, value)
 		if err != nil {
 			return nil, err
@@ -182,7 +222,7 @@ func reflectByteSliceValue(tab *Tabulate, flags Flags, tags map[string]bool,
 func reflectSliceValue(tab *Tabulate, flags Flags, tags map[string]bool,
 	width int, value reflect.Value) (Data, error) {
 
-	data := NewArray(width)
+	data := NewSlice(width)
 loop:
 	for i := 0; i < value.Len(); i++ {
 		v := value.Index(i)
@@ -199,6 +239,9 @@ loop:
 		switch v.Type().Kind() {
 		case reflect.Struct:
 			sub := tab.Clone()
+			if flags&InheritHeaders == 0 {
+				sub.Headers = nil
+			}
 			err := reflectStruct(sub, flags, tags, v)
 			if err != nil {
 				return nil, err

reflect_test.go

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2020 Markku Rossi
+// Copyright (c) 2020-2021 Markku Rossi
 //
 // All rights reserved.
 //
@@ -185,3 +185,15 @@ func TestReflectTextMarshaler(t *testing.T) {
 		t.Fatalf("Reflect failed: %s", err)
 	}
 }
+
+func TestReflectArray(t *testing.T) {
+	fmt.Printf("TestReflectArray\n")
+	tab, err := Array(New(ASCII), [][]interface{}{
+		{"a", "b", "c"},
+		{"1", "2", "3"},
+	})
+	if err != nil {
+		t.Fatalf("Array failed: %s", err)
+	}
+	tab.Print(os.Stdout)
+}