1package ast
2
3import (
4 "fmt"
5 "strings"
6
7 gast "github.com/yuin/goldmark/ast"
8)
9
10// Alignment is a text alignment of table cells.
11type Alignment int
12
13const (
14 // AlignLeft indicates text should be left justified.
15 AlignLeft Alignment = iota + 1
16
17 // AlignRight indicates text should be right justified.
18 AlignRight
19
20 // AlignCenter indicates text should be centered.
21 AlignCenter
22
23 // AlignNone indicates text should be aligned by default manner.
24 AlignNone
25)
26
27func (a Alignment) String() string {
28 switch a {
29 case AlignLeft:
30 return "left"
31 case AlignRight:
32 return "right"
33 case AlignCenter:
34 return "center"
35 case AlignNone:
36 return "none"
37 }
38 return ""
39}
40
41// A Table struct represents a table of Markdown(GFM) text.
42type Table struct {
43 gast.BaseBlock
44
45 // Alignments returns alignments of the columns.
46 Alignments []Alignment
47}
48
49// Dump implements Node.Dump.
50func (n *Table) Dump(source []byte, level int) {
51 gast.DumpHelper(n, source, level, nil, func(level int) {
52 indent := strings.Repeat(" ", level)
53 fmt.Printf("%sAlignments {\n", indent)
54 for i, alignment := range n.Alignments {
55 indent2 := strings.Repeat(" ", level+1)
56 fmt.Printf("%s%s", indent2, alignment.String())
57 if i != len(n.Alignments)-1 {
58 fmt.Println("")
59 }
60 }
61 fmt.Printf("\n%s}\n", indent)
62 })
63}
64
65// KindTable is a NodeKind of the Table node.
66var KindTable = gast.NewNodeKind("Table")
67
68// Kind implements Node.Kind.
69func (n *Table) Kind() gast.NodeKind {
70 return KindTable
71}
72
73// NewTable returns a new Table node.
74func NewTable() *Table {
75 return &Table{
76 Alignments: []Alignment{},
77 }
78}
79
80// A TableRow struct represents a table row of Markdown(GFM) text.
81type TableRow struct {
82 gast.BaseBlock
83 Alignments []Alignment
84}
85
86// Dump implements Node.Dump.
87func (n *TableRow) Dump(source []byte, level int) {
88 gast.DumpHelper(n, source, level, nil, nil)
89}
90
91// KindTableRow is a NodeKind of the TableRow node.
92var KindTableRow = gast.NewNodeKind("TableRow")
93
94// Kind implements Node.Kind.
95func (n *TableRow) Kind() gast.NodeKind {
96 return KindTableRow
97}
98
99// NewTableRow returns a new TableRow node.
100func NewTableRow(alignments []Alignment) *TableRow {
101 return &TableRow{Alignments: alignments}
102}
103
104// A TableHeader struct represents a table header of Markdown(GFM) text.
105type TableHeader struct {
106 gast.BaseBlock
107 Alignments []Alignment
108}
109
110// KindTableHeader is a NodeKind of the TableHeader node.
111var KindTableHeader = gast.NewNodeKind("TableHeader")
112
113// Kind implements Node.Kind.
114func (n *TableHeader) Kind() gast.NodeKind {
115 return KindTableHeader
116}
117
118// Dump implements Node.Dump.
119func (n *TableHeader) Dump(source []byte, level int) {
120 gast.DumpHelper(n, source, level, nil, nil)
121}
122
123// NewTableHeader returns a new TableHeader node.
124func NewTableHeader(row *TableRow) *TableHeader {
125 n := &TableHeader{}
126 for c := row.FirstChild(); c != nil; {
127 next := c.NextSibling()
128 n.AppendChild(n, c)
129 c = next
130 }
131 return n
132}
133
134// A TableCell struct represents a table cell of a Markdown(GFM) text.
135type TableCell struct {
136 gast.BaseBlock
137 Alignment Alignment
138}
139
140// Dump implements Node.Dump.
141func (n *TableCell) Dump(source []byte, level int) {
142 gast.DumpHelper(n, source, level, nil, nil)
143}
144
145// KindTableCell is a NodeKind of the TableCell node.
146var KindTableCell = gast.NewNodeKind("TableCell")
147
148// Kind implements Node.Kind.
149func (n *TableCell) Kind() gast.NodeKind {
150 return KindTableCell
151}
152
153// NewTableCell returns a new TableCell node.
154func NewTableCell() *TableCell {
155 return &TableCell{
156 Alignment: AlignNone,
157 }
158}