table.go

Documentation: github.com/yuin/goldmark/extension/ast

     1  package ast
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  
     7  	gast "github.com/yuin/goldmark/ast"
     8  )
     9  
    10  // Alignment is a text alignment of table cells.
    11  type Alignment int
    12  
    13  const (
    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  
    27  func (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.
    42  type Table struct {
    43  	gast.BaseBlock
    44  
    45  	// Alignments returns alignments of the columns.
    46  	Alignments []Alignment
    47  }
    48  
    49  // Dump implements Node.Dump.
    50  func (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.
    66  var KindTable = gast.NewNodeKind("Table")
    67  
    68  // Kind implements Node.Kind.
    69  func (n *Table) Kind() gast.NodeKind {
    70  	return KindTable
    71  }
    72  
    73  // NewTable returns a new Table node.
    74  func NewTable() *Table {
    75  	return &Table{
    76  		Alignments: []Alignment{},
    77  	}
    78  }
    79  
    80  // A TableRow struct represents a table row of Markdown(GFM) text.
    81  type TableRow struct {
    82  	gast.BaseBlock
    83  	Alignments []Alignment
    84  }
    85  
    86  // Dump implements Node.Dump.
    87  func (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.
    92  var KindTableRow = gast.NewNodeKind("TableRow")
    93  
    94  // Kind implements Node.Kind.
    95  func (n *TableRow) Kind() gast.NodeKind {
    96  	return KindTableRow
    97  }
    98  
    99  // NewTableRow returns a new TableRow node.
   100  func NewTableRow(alignments []Alignment) *TableRow {
   101  	return &TableRow{Alignments: alignments}
   102  }
   103  
   104  // A TableHeader struct represents a table header of Markdown(GFM) text.
   105  type TableHeader struct {
   106  	gast.BaseBlock
   107  	Alignments []Alignment
   108  }
   109  
   110  // KindTableHeader is a NodeKind of the TableHeader node.
   111  var KindTableHeader = gast.NewNodeKind("TableHeader")
   112  
   113  // Kind implements Node.Kind.
   114  func (n *TableHeader) Kind() gast.NodeKind {
   115  	return KindTableHeader
   116  }
   117  
   118  // Dump implements Node.Dump.
   119  func (n *TableHeader) Dump(source []byte, level int) {
   120  	gast.DumpHelper(n, source, level, nil, nil)
   121  }
   122  
   123  // NewTableHeader returns a new TableHeader node.
   124  func 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.
   135  type TableCell struct {
   136  	gast.BaseBlock
   137  	Alignment Alignment
   138  }
   139  
   140  // Dump implements Node.Dump.
   141  func (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.
   146  var KindTableCell = gast.NewNodeKind("TableCell")
   147  
   148  // Kind implements Node.Kind.
   149  func (n *TableCell) Kind() gast.NodeKind {
   150  	return KindTableCell
   151  }
   152  
   153  // NewTableCell returns a new TableCell node.
   154  func NewTableCell() *TableCell {
   155  	return &TableCell{
   156  		Alignment: AlignNone,
   157  	}
   158  }
   159
View as plain text