mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-12-15 14:08:21 +00:00
d1353e1f7c
* update code.gitea.io/sdk/gitea v0.13.1 -> v0.13.2 * update github.com/go-swagger/go-swagger v0.25.0 -> v0.26.0 * update github.com/google/uuid v1.1.2 -> v1.2.0 * update github.com/klauspost/compress v1.11.3 -> v1.11.7 * update github.com/lib/pq 083382b7e6fc -> v1.9.0 * update github.com/markbates/goth v1.65.0 -> v1.66.1 * update github.com/mattn/go-sqlite3 v1.14.4 -> v1.14.6 * update github.com/mgechev/revive 246eac737dc7 -> v1.0.3 * update github.com/minio/minio-go/v7 v7.0.6 -> v7.0.7 * update github.com/niklasfasching/go-org v1.3.2 -> v1.4.0 * update github.com/olivere/elastic/v7 v7.0.21 -> v7.0.22 * update github.com/pquerna/otp v1.2.0 -> v1.3.0 * update github.com/xanzy/go-gitlab v0.39.0 -> v0.42.0 * update github.com/yuin/goldmark v1.2.1 -> v1.3.1
496 lines
11 KiB
Go
Vendored
496 lines
11 KiB
Go
Vendored
package ast
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
textm "github.com/yuin/goldmark/text"
|
|
)
|
|
|
|
// A BaseBlock struct implements the Node interface partialliy.
|
|
type BaseBlock struct {
|
|
BaseNode
|
|
blankPreviousLines bool
|
|
lines *textm.Segments
|
|
}
|
|
|
|
// Type implements Node.Type
|
|
func (b *BaseBlock) Type() NodeType {
|
|
return TypeBlock
|
|
}
|
|
|
|
// IsRaw implements Node.IsRaw
|
|
func (b *BaseBlock) IsRaw() bool {
|
|
return false
|
|
}
|
|
|
|
// HasBlankPreviousLines implements Node.HasBlankPreviousLines.
|
|
func (b *BaseBlock) HasBlankPreviousLines() bool {
|
|
return b.blankPreviousLines
|
|
}
|
|
|
|
// SetBlankPreviousLines implements Node.SetBlankPreviousLines.
|
|
func (b *BaseBlock) SetBlankPreviousLines(v bool) {
|
|
b.blankPreviousLines = v
|
|
}
|
|
|
|
// Lines implements Node.Lines
|
|
func (b *BaseBlock) Lines() *textm.Segments {
|
|
if b.lines == nil {
|
|
b.lines = textm.NewSegments()
|
|
}
|
|
return b.lines
|
|
}
|
|
|
|
// SetLines implements Node.SetLines
|
|
func (b *BaseBlock) SetLines(v *textm.Segments) {
|
|
b.lines = v
|
|
}
|
|
|
|
// A Document struct is a root node of Markdown text.
|
|
type Document struct {
|
|
BaseBlock
|
|
|
|
meta map[string]interface{}
|
|
}
|
|
|
|
// KindDocument is a NodeKind of the Document node.
|
|
var KindDocument = NewNodeKind("Document")
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *Document) Dump(source []byte, level int) {
|
|
DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// Type implements Node.Type .
|
|
func (n *Document) Type() NodeType {
|
|
return TypeDocument
|
|
}
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Document) Kind() NodeKind {
|
|
return KindDocument
|
|
}
|
|
|
|
// OwnerDocument implements Node.OwnerDocument
|
|
func (n *Document) OwnerDocument() *Document {
|
|
return n
|
|
}
|
|
|
|
// Meta returns metadata of this document.
|
|
func (n *Document) Meta() map[string]interface{} {
|
|
if n.meta == nil {
|
|
n.meta = map[string]interface{}{}
|
|
}
|
|
return n.meta
|
|
}
|
|
|
|
// SetMeta sets given metadata to this document.
|
|
func (n *Document) SetMeta(meta map[string]interface{}) {
|
|
n.meta = meta
|
|
}
|
|
|
|
// NewDocument returns a new Document node.
|
|
func NewDocument() *Document {
|
|
return &Document{
|
|
BaseBlock: BaseBlock{},
|
|
meta: nil,
|
|
}
|
|
}
|
|
|
|
// A TextBlock struct is a node whose lines
|
|
// should be rendered without any containers.
|
|
type TextBlock struct {
|
|
BaseBlock
|
|
}
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *TextBlock) Dump(source []byte, level int) {
|
|
DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindTextBlock is a NodeKind of the TextBlock node.
|
|
var KindTextBlock = NewNodeKind("TextBlock")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *TextBlock) Kind() NodeKind {
|
|
return KindTextBlock
|
|
}
|
|
|
|
// NewTextBlock returns a new TextBlock node.
|
|
func NewTextBlock() *TextBlock {
|
|
return &TextBlock{
|
|
BaseBlock: BaseBlock{},
|
|
}
|
|
}
|
|
|
|
// A Paragraph struct represents a paragraph of Markdown text.
|
|
type Paragraph struct {
|
|
BaseBlock
|
|
}
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *Paragraph) Dump(source []byte, level int) {
|
|
DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindParagraph is a NodeKind of the Paragraph node.
|
|
var KindParagraph = NewNodeKind("Paragraph")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Paragraph) Kind() NodeKind {
|
|
return KindParagraph
|
|
}
|
|
|
|
// NewParagraph returns a new Paragraph node.
|
|
func NewParagraph() *Paragraph {
|
|
return &Paragraph{
|
|
BaseBlock: BaseBlock{},
|
|
}
|
|
}
|
|
|
|
// IsParagraph returns true if the given node implements the Paragraph interface,
|
|
// otherwise false.
|
|
func IsParagraph(node Node) bool {
|
|
_, ok := node.(*Paragraph)
|
|
return ok
|
|
}
|
|
|
|
// A Heading struct represents headings like SetextHeading and ATXHeading.
|
|
type Heading struct {
|
|
BaseBlock
|
|
// Level returns a level of this heading.
|
|
// This value is between 1 and 6.
|
|
Level int
|
|
}
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *Heading) Dump(source []byte, level int) {
|
|
m := map[string]string{
|
|
"Level": fmt.Sprintf("%d", n.Level),
|
|
}
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindHeading is a NodeKind of the Heading node.
|
|
var KindHeading = NewNodeKind("Heading")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Heading) Kind() NodeKind {
|
|
return KindHeading
|
|
}
|
|
|
|
// NewHeading returns a new Heading node.
|
|
func NewHeading(level int) *Heading {
|
|
return &Heading{
|
|
BaseBlock: BaseBlock{},
|
|
Level: level,
|
|
}
|
|
}
|
|
|
|
// A ThematicBreak struct represents a thematic break of Markdown text.
|
|
type ThematicBreak struct {
|
|
BaseBlock
|
|
}
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *ThematicBreak) Dump(source []byte, level int) {
|
|
DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindThematicBreak is a NodeKind of the ThematicBreak node.
|
|
var KindThematicBreak = NewNodeKind("ThematicBreak")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *ThematicBreak) Kind() NodeKind {
|
|
return KindThematicBreak
|
|
}
|
|
|
|
// NewThematicBreak returns a new ThematicBreak node.
|
|
func NewThematicBreak() *ThematicBreak {
|
|
return &ThematicBreak{
|
|
BaseBlock: BaseBlock{},
|
|
}
|
|
}
|
|
|
|
// A CodeBlock interface represents an indented code block of Markdown text.
|
|
type CodeBlock struct {
|
|
BaseBlock
|
|
}
|
|
|
|
// IsRaw implements Node.IsRaw.
|
|
func (n *CodeBlock) IsRaw() bool {
|
|
return true
|
|
}
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *CodeBlock) Dump(source []byte, level int) {
|
|
DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindCodeBlock is a NodeKind of the CodeBlock node.
|
|
var KindCodeBlock = NewNodeKind("CodeBlock")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *CodeBlock) Kind() NodeKind {
|
|
return KindCodeBlock
|
|
}
|
|
|
|
// NewCodeBlock returns a new CodeBlock node.
|
|
func NewCodeBlock() *CodeBlock {
|
|
return &CodeBlock{
|
|
BaseBlock: BaseBlock{},
|
|
}
|
|
}
|
|
|
|
// A FencedCodeBlock struct represents a fenced code block of Markdown text.
|
|
type FencedCodeBlock struct {
|
|
BaseBlock
|
|
// Info returns a info text of this fenced code block.
|
|
Info *Text
|
|
|
|
language []byte
|
|
}
|
|
|
|
// Language returns an language in an info string.
|
|
// Language returns nil if this node does not have an info string.
|
|
func (n *FencedCodeBlock) Language(source []byte) []byte {
|
|
if n.language == nil && n.Info != nil {
|
|
segment := n.Info.Segment
|
|
info := segment.Value(source)
|
|
i := 0
|
|
for ; i < len(info); i++ {
|
|
if info[i] == ' ' {
|
|
break
|
|
}
|
|
}
|
|
n.language = info[:i]
|
|
}
|
|
return n.language
|
|
}
|
|
|
|
// IsRaw implements Node.IsRaw.
|
|
func (n *FencedCodeBlock) IsRaw() bool {
|
|
return true
|
|
}
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *FencedCodeBlock) Dump(source []byte, level int) {
|
|
m := map[string]string{}
|
|
if n.Info != nil {
|
|
m["Info"] = fmt.Sprintf("\"%s\"", n.Info.Text(source))
|
|
}
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindFencedCodeBlock is a NodeKind of the FencedCodeBlock node.
|
|
var KindFencedCodeBlock = NewNodeKind("FencedCodeBlock")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *FencedCodeBlock) Kind() NodeKind {
|
|
return KindFencedCodeBlock
|
|
}
|
|
|
|
// NewFencedCodeBlock return a new FencedCodeBlock node.
|
|
func NewFencedCodeBlock(info *Text) *FencedCodeBlock {
|
|
return &FencedCodeBlock{
|
|
BaseBlock: BaseBlock{},
|
|
Info: info,
|
|
}
|
|
}
|
|
|
|
// A Blockquote struct represents an blockquote block of Markdown text.
|
|
type Blockquote struct {
|
|
BaseBlock
|
|
}
|
|
|
|
// Dump implements Node.Dump .
|
|
func (n *Blockquote) Dump(source []byte, level int) {
|
|
DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindBlockquote is a NodeKind of the Blockquote node.
|
|
var KindBlockquote = NewNodeKind("Blockquote")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Blockquote) Kind() NodeKind {
|
|
return KindBlockquote
|
|
}
|
|
|
|
// NewBlockquote returns a new Blockquote node.
|
|
func NewBlockquote() *Blockquote {
|
|
return &Blockquote{
|
|
BaseBlock: BaseBlock{},
|
|
}
|
|
}
|
|
|
|
// A List struct represents a list of Markdown text.
|
|
type List struct {
|
|
BaseBlock
|
|
|
|
// Marker is a marker character like '-', '+', ')' and '.'.
|
|
Marker byte
|
|
|
|
// IsTight is a true if this list is a 'tight' list.
|
|
// See https://spec.commonmark.org/0.29/#loose for details.
|
|
IsTight bool
|
|
|
|
// Start is an initial number of this ordered list.
|
|
// If this list is not an ordered list, Start is 0.
|
|
Start int
|
|
}
|
|
|
|
// IsOrdered returns true if this list is an ordered list, otherwise false.
|
|
func (l *List) IsOrdered() bool {
|
|
return l.Marker == '.' || l.Marker == ')'
|
|
}
|
|
|
|
// CanContinue returns true if this list can continue with
|
|
// the given mark and a list type, otherwise false.
|
|
func (l *List) CanContinue(marker byte, isOrdered bool) bool {
|
|
return marker == l.Marker && isOrdered == l.IsOrdered()
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (l *List) Dump(source []byte, level int) {
|
|
m := map[string]string{
|
|
"Ordered": fmt.Sprintf("%v", l.IsOrdered()),
|
|
"Marker": fmt.Sprintf("%c", l.Marker),
|
|
"Tight": fmt.Sprintf("%v", l.IsTight),
|
|
}
|
|
if l.IsOrdered() {
|
|
m["Start"] = fmt.Sprintf("%d", l.Start)
|
|
}
|
|
DumpHelper(l, source, level, m, nil)
|
|
}
|
|
|
|
// KindList is a NodeKind of the List node.
|
|
var KindList = NewNodeKind("List")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (l *List) Kind() NodeKind {
|
|
return KindList
|
|
}
|
|
|
|
// NewList returns a new List node.
|
|
func NewList(marker byte) *List {
|
|
return &List{
|
|
BaseBlock: BaseBlock{},
|
|
Marker: marker,
|
|
IsTight: true,
|
|
}
|
|
}
|
|
|
|
// A ListItem struct represents a list item of Markdown text.
|
|
type ListItem struct {
|
|
BaseBlock
|
|
|
|
// Offset is an offset position of this item.
|
|
Offset int
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *ListItem) Dump(source []byte, level int) {
|
|
m := map[string]string{
|
|
"Offset": fmt.Sprintf("%d", n.Offset),
|
|
}
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindListItem is a NodeKind of the ListItem node.
|
|
var KindListItem = NewNodeKind("ListItem")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *ListItem) Kind() NodeKind {
|
|
return KindListItem
|
|
}
|
|
|
|
// NewListItem returns a new ListItem node.
|
|
func NewListItem(offset int) *ListItem {
|
|
return &ListItem{
|
|
BaseBlock: BaseBlock{},
|
|
Offset: offset,
|
|
}
|
|
}
|
|
|
|
// HTMLBlockType represents kinds of an html blocks.
|
|
// See https://spec.commonmark.org/0.29/#html-blocks
|
|
type HTMLBlockType int
|
|
|
|
const (
|
|
// HTMLBlockType1 represents type 1 html blocks
|
|
HTMLBlockType1 HTMLBlockType = iota + 1
|
|
// HTMLBlockType2 represents type 2 html blocks
|
|
HTMLBlockType2
|
|
// HTMLBlockType3 represents type 3 html blocks
|
|
HTMLBlockType3
|
|
// HTMLBlockType4 represents type 4 html blocks
|
|
HTMLBlockType4
|
|
// HTMLBlockType5 represents type 5 html blocks
|
|
HTMLBlockType5
|
|
// HTMLBlockType6 represents type 6 html blocks
|
|
HTMLBlockType6
|
|
// HTMLBlockType7 represents type 7 html blocks
|
|
HTMLBlockType7
|
|
)
|
|
|
|
// An HTMLBlock struct represents an html block of Markdown text.
|
|
type HTMLBlock struct {
|
|
BaseBlock
|
|
|
|
// Type is a type of this html block.
|
|
HTMLBlockType HTMLBlockType
|
|
|
|
// ClosureLine is a line that closes this html block.
|
|
ClosureLine textm.Segment
|
|
}
|
|
|
|
// IsRaw implements Node.IsRaw.
|
|
func (n *HTMLBlock) IsRaw() bool {
|
|
return true
|
|
}
|
|
|
|
// HasClosure returns true if this html block has a closure line,
|
|
// otherwise false.
|
|
func (n *HTMLBlock) HasClosure() bool {
|
|
return n.ClosureLine.Start >= 0
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *HTMLBlock) Dump(source []byte, level int) {
|
|
indent := strings.Repeat(" ", level)
|
|
fmt.Printf("%s%s {\n", indent, "HTMLBlock")
|
|
indent2 := strings.Repeat(" ", level+1)
|
|
fmt.Printf("%sRawText: \"", indent2)
|
|
for i := 0; i < n.Lines().Len(); i++ {
|
|
s := n.Lines().At(i)
|
|
fmt.Print(string(source[s.Start:s.Stop]))
|
|
}
|
|
fmt.Printf("\"\n")
|
|
for c := n.FirstChild(); c != nil; c = c.NextSibling() {
|
|
c.Dump(source, level+1)
|
|
}
|
|
if n.HasClosure() {
|
|
cl := n.ClosureLine
|
|
fmt.Printf("%sClosure: \"%s\"\n", indent2, string(cl.Value(source)))
|
|
}
|
|
fmt.Printf("%s}\n", indent)
|
|
}
|
|
|
|
// KindHTMLBlock is a NodeKind of the HTMLBlock node.
|
|
var KindHTMLBlock = NewNodeKind("HTMLBlock")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *HTMLBlock) Kind() NodeKind {
|
|
return KindHTMLBlock
|
|
}
|
|
|
|
// NewHTMLBlock returns a new HTMLBlock node.
|
|
func NewHTMLBlock(typ HTMLBlockType) *HTMLBlock {
|
|
return &HTMLBlock{
|
|
BaseBlock: BaseBlock{},
|
|
HTMLBlockType: typ,
|
|
ClosureLine: textm.NewSegment(-1, -1),
|
|
}
|
|
}
|