mirror of
https://github.com/go-gitea/gitea.git
synced 2024-12-06 02:29:37 +08:00
27757714d0
* Move to goldmark Markdown rendering moved from blackfriday to the goldmark. Multiple subtle changes required to the goldmark extensions to keep current rendering and defaults. Can go further with goldmark linkify and have this work within markdown rendering making the link processor unnecessary. Need to think about how to go about allowing extensions - at present it seems that these would be hard to do without recompilation. * linter fixes Co-authored-by: Lauris BH <lauris@nix.lv>
158 lines
3.4 KiB
Go
158 lines
3.4 KiB
Go
package ast
|
|
|
|
import (
|
|
"fmt"
|
|
gast "github.com/yuin/goldmark/ast"
|
|
"strings"
|
|
)
|
|
|
|
// Alignment is a text alignment of table cells.
|
|
type Alignment int
|
|
|
|
const (
|
|
// AlignLeft indicates text should be left justified.
|
|
AlignLeft Alignment = iota + 1
|
|
|
|
// AlignRight indicates text should be right justified.
|
|
AlignRight
|
|
|
|
// AlignCenter indicates text should be centered.
|
|
AlignCenter
|
|
|
|
// AlignNone indicates text should be aligned by default manner.
|
|
AlignNone
|
|
)
|
|
|
|
func (a Alignment) String() string {
|
|
switch a {
|
|
case AlignLeft:
|
|
return "left"
|
|
case AlignRight:
|
|
return "right"
|
|
case AlignCenter:
|
|
return "center"
|
|
case AlignNone:
|
|
return "none"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// A Table struct represents a table of Markdown(GFM) text.
|
|
type Table struct {
|
|
gast.BaseBlock
|
|
|
|
// Alignments returns alignments of the columns.
|
|
Alignments []Alignment
|
|
}
|
|
|
|
// Dump implements Node.Dump
|
|
func (n *Table) Dump(source []byte, level int) {
|
|
gast.DumpHelper(n, source, level, nil, func(level int) {
|
|
indent := strings.Repeat(" ", level)
|
|
fmt.Printf("%sAlignments {\n", indent)
|
|
for i, alignment := range n.Alignments {
|
|
indent2 := strings.Repeat(" ", level+1)
|
|
fmt.Printf("%s%s", indent2, alignment.String())
|
|
if i != len(n.Alignments)-1 {
|
|
fmt.Println("")
|
|
}
|
|
}
|
|
fmt.Printf("\n%s}\n", indent)
|
|
})
|
|
}
|
|
|
|
// KindTable is a NodeKind of the Table node.
|
|
var KindTable = gast.NewNodeKind("Table")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Table) Kind() gast.NodeKind {
|
|
return KindTable
|
|
}
|
|
|
|
// NewTable returns a new Table node.
|
|
func NewTable() *Table {
|
|
return &Table{
|
|
Alignments: []Alignment{},
|
|
}
|
|
}
|
|
|
|
// A TableRow struct represents a table row of Markdown(GFM) text.
|
|
type TableRow struct {
|
|
gast.BaseBlock
|
|
Alignments []Alignment
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *TableRow) Dump(source []byte, level int) {
|
|
gast.DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindTableRow is a NodeKind of the TableRow node.
|
|
var KindTableRow = gast.NewNodeKind("TableRow")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *TableRow) Kind() gast.NodeKind {
|
|
return KindTableRow
|
|
}
|
|
|
|
// NewTableRow returns a new TableRow node.
|
|
func NewTableRow(alignments []Alignment) *TableRow {
|
|
return &TableRow{}
|
|
}
|
|
|
|
// A TableHeader struct represents a table header of Markdown(GFM) text.
|
|
type TableHeader struct {
|
|
gast.BaseBlock
|
|
Alignments []Alignment
|
|
}
|
|
|
|
// KindTableHeader is a NodeKind of the TableHeader node.
|
|
var KindTableHeader = gast.NewNodeKind("TableHeader")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *TableHeader) Kind() gast.NodeKind {
|
|
return KindTableHeader
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *TableHeader) Dump(source []byte, level int) {
|
|
gast.DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// NewTableHeader returns a new TableHeader node.
|
|
func NewTableHeader(row *TableRow) *TableHeader {
|
|
n := &TableHeader{}
|
|
for c := row.FirstChild(); c != nil; {
|
|
next := c.NextSibling()
|
|
n.AppendChild(n, c)
|
|
c = next
|
|
}
|
|
return n
|
|
}
|
|
|
|
// A TableCell struct represents a table cell of a Markdown(GFM) text.
|
|
type TableCell struct {
|
|
gast.BaseBlock
|
|
Alignment Alignment
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *TableCell) Dump(source []byte, level int) {
|
|
gast.DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindTableCell is a NodeKind of the TableCell node.
|
|
var KindTableCell = gast.NewNodeKind("TableCell")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *TableCell) Kind() gast.NodeKind {
|
|
return KindTableCell
|
|
}
|
|
|
|
// NewTableCell returns a new TableCell node.
|
|
func NewTableCell() *TableCell {
|
|
return &TableCell{
|
|
Alignment: AlignNone,
|
|
}
|
|
}
|