tab/tab.go at main · tiptok/tab · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package tab

import (
	"fmt"
	"io"
	"path/filepath"
	"strings"
)

func NewTabulator(optionsFunc ...optionFunc) *Tabulator {
	op := newOptions(optionsFunc...)
	reader := makeReaderByReadFrom(op.ReadFrom)
	if op.FileName != "" {
		reader = makeReaderByFileExt(op.FileName)
	}
	if op.Reader != nil {
		reader = op.Reader
	}

	return &Tabulator{
		reader:  reader,
		options: op,
	}
}

func makeReaderByReadFrom(from source) Reader {
	var reader Reader
	switch from {
	case XLSX:
		reader = &XLXSReader{}
	case XLS:
		reader = &XLSReader{}
	case CSV:
		reader = &CSVReader{}
	case HtmlTable:
		reader = &HtmlTableReader{}
	}
	return reader
}

func makeReaderByFileExt(filename string) Reader {
	var reader Reader
	ext := filepath.Ext(filename)
	switch ext {
	case ".xlsx":
		reader = &XLXSReader{}
	case ".xls":
		reader = &XLSReader{}
	case ".csv":
		reader = &CSVReader{}
	case ".html":
	}
	return reader
}

func newOptions(optionsFunc ...optionFunc) *options {
	op := &options{ReadFrom: XLSX, Sheet: "Sheet1", RowBegin: 1, ColBegin: 1}
	for i := range optionsFunc {
		optionsFunc[i](op)
	}
	return op
}

func makeWriterByWriteTo(to source, table *Table) Writer {
	var w Writer
	switch to {
	case XLSX:
		w = &XLXSWriterTo{data: table.Rows, title: table.HeaderInfo.Columns}
	case CSV:
		w = &CSVWriterTo{data: table.Rows, title: table.HeaderInfo.Columns}
	default:
		w = &XLXSWriterTo{data: table.Rows, title: table.HeaderInfo.Columns}
	}
	return w
}

type Tabulator struct {
	reader  Reader
	options *options
	Table   *Table
}

func (tab *Tabulator) Open(r File) (*Table, error) {
	rows, err := tab.Reader().Read(tab.options, r)
	if err != nil {
		return nil, err
	}
	header := tab.Reader().Header()
	tab.Table = &Table{
		HeaderInfo: header,
		Rows:       rows,
	}
	return tab.Table, nil
}

func (tab *Tabulator) Write(to source, path string) error {
	wt := makeWriterByWriteTo(to, tab.Table)
	return wt.Save(path)
}

func (tab *Tabulator) WriteTo(to source, w io.Writer) (n int64, err error) {
	wt := makeWriterByWriteTo(to, tab.Table)
	return wt.WriteTo(w)
}

func (tab *Tabulator) Reader() Reader {
	return tab.reader
}

type Table struct {
	HeaderInfo HeaderInfo
	Rows       [][]string
}

func (table *Table) Len() int {
	return len(table.Rows)
}

func (table *Table) String() string {
	return fmt.Sprintf("Table[%s] (%d rows)", strings.Join(table.HeaderInfo.Columns, ", "), len(table.Rows))
}