mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-19 19:13:25 +02:00
* 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>
549 lines
12 KiB
Go
549 lines
12 KiB
Go
package ast
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
textm "github.com/yuin/goldmark/text"
|
|
"github.com/yuin/goldmark/util"
|
|
)
|
|
|
|
// A BaseInline struct implements the Node interface.
|
|
type BaseInline struct {
|
|
BaseNode
|
|
}
|
|
|
|
// Type implements Node.Type
|
|
func (b *BaseInline) Type() NodeType {
|
|
return TypeInline
|
|
}
|
|
|
|
// IsRaw implements Node.IsRaw
|
|
func (b *BaseInline) IsRaw() bool {
|
|
return false
|
|
}
|
|
|
|
// HasBlankPreviousLines implements Node.HasBlankPreviousLines.
|
|
func (b *BaseInline) HasBlankPreviousLines() bool {
|
|
panic("can not call with inline nodes.")
|
|
}
|
|
|
|
// SetBlankPreviousLines implements Node.SetBlankPreviousLines.
|
|
func (b *BaseInline) SetBlankPreviousLines(v bool) {
|
|
panic("can not call with inline nodes.")
|
|
}
|
|
|
|
// Lines implements Node.Lines
|
|
func (b *BaseInline) Lines() *textm.Segments {
|
|
panic("can not call with inline nodes.")
|
|
}
|
|
|
|
// SetLines implements Node.SetLines
|
|
func (b *BaseInline) SetLines(v *textm.Segments) {
|
|
panic("can not call with inline nodes.")
|
|
}
|
|
|
|
// A Text struct represents a textual content of the Markdown text.
|
|
type Text struct {
|
|
BaseInline
|
|
// Segment is a position in a source text.
|
|
Segment textm.Segment
|
|
|
|
flags uint8
|
|
}
|
|
|
|
const (
|
|
textSoftLineBreak = 1 << iota
|
|
textHardLineBreak
|
|
textRaw
|
|
textCode
|
|
)
|
|
|
|
func textFlagsString(flags uint8) string {
|
|
buf := []string{}
|
|
if flags&textSoftLineBreak != 0 {
|
|
buf = append(buf, "SoftLineBreak")
|
|
}
|
|
if flags&textHardLineBreak != 0 {
|
|
buf = append(buf, "HardLineBreak")
|
|
}
|
|
if flags&textRaw != 0 {
|
|
buf = append(buf, "Raw")
|
|
}
|
|
if flags&textCode != 0 {
|
|
buf = append(buf, "Code")
|
|
}
|
|
return strings.Join(buf, ", ")
|
|
}
|
|
|
|
// Inline implements Inline.Inline.
|
|
func (n *Text) Inline() {
|
|
}
|
|
|
|
// SoftLineBreak returns true if this node ends with a new line,
|
|
// otherwise false.
|
|
func (n *Text) SoftLineBreak() bool {
|
|
return n.flags&textSoftLineBreak != 0
|
|
}
|
|
|
|
// SetSoftLineBreak sets whether this node ends with a new line.
|
|
func (n *Text) SetSoftLineBreak(v bool) {
|
|
if v {
|
|
n.flags |= textSoftLineBreak
|
|
} else {
|
|
n.flags = n.flags &^ textHardLineBreak
|
|
}
|
|
}
|
|
|
|
// IsRaw returns true if this text should be rendered without unescaping
|
|
// back slash escapes and resolving references.
|
|
func (n *Text) IsRaw() bool {
|
|
return n.flags&textRaw != 0
|
|
}
|
|
|
|
// SetRaw sets whether this text should be rendered as raw contents.
|
|
func (n *Text) SetRaw(v bool) {
|
|
if v {
|
|
n.flags |= textRaw
|
|
} else {
|
|
n.flags = n.flags &^ textRaw
|
|
}
|
|
}
|
|
|
|
// HardLineBreak returns true if this node ends with a hard line break.
|
|
// See https://spec.commonmark.org/0.29/#hard-line-breaks for details.
|
|
func (n *Text) HardLineBreak() bool {
|
|
return n.flags&textHardLineBreak != 0
|
|
}
|
|
|
|
// SetHardLineBreak sets whether this node ends with a hard line break.
|
|
func (n *Text) SetHardLineBreak(v bool) {
|
|
if v {
|
|
n.flags |= textHardLineBreak
|
|
} else {
|
|
n.flags = n.flags &^ textHardLineBreak
|
|
}
|
|
}
|
|
|
|
// Merge merges a Node n into this node.
|
|
// Merge returns true if the given node has been merged, otherwise false.
|
|
func (n *Text) Merge(node Node, source []byte) bool {
|
|
t, ok := node.(*Text)
|
|
if !ok {
|
|
return false
|
|
}
|
|
if n.Segment.Stop != t.Segment.Start || t.Segment.Padding != 0 || source[n.Segment.Stop-1] == '\n' || t.IsRaw() != n.IsRaw() {
|
|
return false
|
|
}
|
|
n.Segment.Stop = t.Segment.Stop
|
|
n.SetSoftLineBreak(t.SoftLineBreak())
|
|
n.SetHardLineBreak(t.HardLineBreak())
|
|
return true
|
|
}
|
|
|
|
// Text implements Node.Text.
|
|
func (n *Text) Text(source []byte) []byte {
|
|
return n.Segment.Value(source)
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *Text) Dump(source []byte, level int) {
|
|
fs := textFlagsString(n.flags)
|
|
if len(fs) != 0 {
|
|
fs = "(" + fs + ")"
|
|
}
|
|
fmt.Printf("%sText%s: \"%s\"\n", strings.Repeat(" ", level), fs, strings.TrimRight(string(n.Text(source)), "\n"))
|
|
}
|
|
|
|
// KindText is a NodeKind of the Text node.
|
|
var KindText = NewNodeKind("Text")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Text) Kind() NodeKind {
|
|
return KindText
|
|
}
|
|
|
|
// NewText returns a new Text node.
|
|
func NewText() *Text {
|
|
return &Text{
|
|
BaseInline: BaseInline{},
|
|
}
|
|
}
|
|
|
|
// NewTextSegment returns a new Text node with the given source potision.
|
|
func NewTextSegment(v textm.Segment) *Text {
|
|
return &Text{
|
|
BaseInline: BaseInline{},
|
|
Segment: v,
|
|
}
|
|
}
|
|
|
|
// NewRawTextSegment returns a new Text node with the given source position.
|
|
// The new node should be rendered as raw contents.
|
|
func NewRawTextSegment(v textm.Segment) *Text {
|
|
t := &Text{
|
|
BaseInline: BaseInline{},
|
|
Segment: v,
|
|
}
|
|
t.SetRaw(true)
|
|
return t
|
|
}
|
|
|
|
// MergeOrAppendTextSegment merges a given s into the last child of the parent if
|
|
// it can be merged, otherwise creates a new Text node and appends it to after current
|
|
// last child.
|
|
func MergeOrAppendTextSegment(parent Node, s textm.Segment) {
|
|
last := parent.LastChild()
|
|
t, ok := last.(*Text)
|
|
if ok && t.Segment.Stop == s.Start && !t.SoftLineBreak() {
|
|
t.Segment = t.Segment.WithStop(s.Stop)
|
|
} else {
|
|
parent.AppendChild(parent, NewTextSegment(s))
|
|
}
|
|
}
|
|
|
|
// MergeOrReplaceTextSegment merges a given s into a previous sibling of the node n
|
|
// if a previous sibling of the node n is *Text, otherwise replaces Node n with s.
|
|
func MergeOrReplaceTextSegment(parent Node, n Node, s textm.Segment) {
|
|
prev := n.PreviousSibling()
|
|
if t, ok := prev.(*Text); ok && t.Segment.Stop == s.Start && !t.SoftLineBreak() {
|
|
t.Segment = t.Segment.WithStop(s.Stop)
|
|
parent.RemoveChild(parent, n)
|
|
} else {
|
|
parent.ReplaceChild(parent, n, NewTextSegment(s))
|
|
}
|
|
}
|
|
|
|
// A String struct is a textual content that has a concrete value
|
|
type String struct {
|
|
BaseInline
|
|
|
|
Value []byte
|
|
flags uint8
|
|
}
|
|
|
|
// Inline implements Inline.Inline.
|
|
func (n *String) Inline() {
|
|
}
|
|
|
|
// IsRaw returns true if this text should be rendered without unescaping
|
|
// back slash escapes and resolving references.
|
|
func (n *String) IsRaw() bool {
|
|
return n.flags&textRaw != 0
|
|
}
|
|
|
|
// SetRaw sets whether this text should be rendered as raw contents.
|
|
func (n *String) SetRaw(v bool) {
|
|
if v {
|
|
n.flags |= textRaw
|
|
} else {
|
|
n.flags = n.flags &^ textRaw
|
|
}
|
|
}
|
|
|
|
// IsCode returns true if this text should be rendered without any
|
|
// modifications.
|
|
func (n *String) IsCode() bool {
|
|
return n.flags&textCode != 0
|
|
}
|
|
|
|
// SetCode sets whether this text should be rendered without any modifications.
|
|
func (n *String) SetCode(v bool) {
|
|
if v {
|
|
n.flags |= textCode
|
|
} else {
|
|
n.flags = n.flags &^ textCode
|
|
}
|
|
}
|
|
|
|
// Text implements Node.Text.
|
|
func (n *String) Text(source []byte) []byte {
|
|
return n.Value
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *String) Dump(source []byte, level int) {
|
|
fs := textFlagsString(n.flags)
|
|
if len(fs) != 0 {
|
|
fs = "(" + fs + ")"
|
|
}
|
|
fmt.Printf("%sString%s: \"%s\"\n", strings.Repeat(" ", level), fs, strings.TrimRight(string(n.Value), "\n"))
|
|
}
|
|
|
|
// KindString is a NodeKind of the String node.
|
|
var KindString = NewNodeKind("String")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *String) Kind() NodeKind {
|
|
return KindString
|
|
}
|
|
|
|
// NewString returns a new String node.
|
|
func NewString(v []byte) *String {
|
|
return &String{
|
|
Value: v,
|
|
}
|
|
}
|
|
|
|
// A CodeSpan struct represents a code span of Markdown text.
|
|
type CodeSpan struct {
|
|
BaseInline
|
|
}
|
|
|
|
// Inline implements Inline.Inline .
|
|
func (n *CodeSpan) Inline() {
|
|
}
|
|
|
|
// IsBlank returns true if this node consists of spaces, otherwise false.
|
|
func (n *CodeSpan) IsBlank(source []byte) bool {
|
|
for c := n.FirstChild(); c != nil; c = c.NextSibling() {
|
|
text := c.(*Text).Segment
|
|
if !util.IsBlank(text.Value(source)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Dump implements Node.Dump
|
|
func (n *CodeSpan) Dump(source []byte, level int) {
|
|
DumpHelper(n, source, level, nil, nil)
|
|
}
|
|
|
|
// KindCodeSpan is a NodeKind of the CodeSpan node.
|
|
var KindCodeSpan = NewNodeKind("CodeSpan")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *CodeSpan) Kind() NodeKind {
|
|
return KindCodeSpan
|
|
}
|
|
|
|
// NewCodeSpan returns a new CodeSpan node.
|
|
func NewCodeSpan() *CodeSpan {
|
|
return &CodeSpan{
|
|
BaseInline: BaseInline{},
|
|
}
|
|
}
|
|
|
|
// An Emphasis struct represents an emphasis of Markdown text.
|
|
type Emphasis struct {
|
|
BaseInline
|
|
|
|
// Level is a level of the emphasis.
|
|
Level int
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *Emphasis) Dump(source []byte, level int) {
|
|
m := map[string]string{
|
|
"Level": fmt.Sprintf("%v", n.Level),
|
|
}
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindEmphasis is a NodeKind of the Emphasis node.
|
|
var KindEmphasis = NewNodeKind("Emphasis")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Emphasis) Kind() NodeKind {
|
|
return KindEmphasis
|
|
}
|
|
|
|
// NewEmphasis returns a new Emphasis node with the given level.
|
|
func NewEmphasis(level int) *Emphasis {
|
|
return &Emphasis{
|
|
BaseInline: BaseInline{},
|
|
Level: level,
|
|
}
|
|
}
|
|
|
|
type baseLink struct {
|
|
BaseInline
|
|
|
|
// Destination is a destination(URL) of this link.
|
|
Destination []byte
|
|
|
|
// Title is a title of this link.
|
|
Title []byte
|
|
}
|
|
|
|
// Inline implements Inline.Inline.
|
|
func (n *baseLink) Inline() {
|
|
}
|
|
|
|
// A Link struct represents a link of the Markdown text.
|
|
type Link struct {
|
|
baseLink
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *Link) Dump(source []byte, level int) {
|
|
m := map[string]string{}
|
|
m["Destination"] = string(n.Destination)
|
|
m["Title"] = string(n.Title)
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindLink is a NodeKind of the Link node.
|
|
var KindLink = NewNodeKind("Link")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Link) Kind() NodeKind {
|
|
return KindLink
|
|
}
|
|
|
|
// NewLink returns a new Link node.
|
|
func NewLink() *Link {
|
|
c := &Link{
|
|
baseLink: baseLink{
|
|
BaseInline: BaseInline{},
|
|
},
|
|
}
|
|
return c
|
|
}
|
|
|
|
// An Image struct represents an image of the Markdown text.
|
|
type Image struct {
|
|
baseLink
|
|
}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *Image) Dump(source []byte, level int) {
|
|
m := map[string]string{}
|
|
m["Destination"] = string(n.Destination)
|
|
m["Title"] = string(n.Title)
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindImage is a NodeKind of the Image node.
|
|
var KindImage = NewNodeKind("Image")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *Image) Kind() NodeKind {
|
|
return KindImage
|
|
}
|
|
|
|
// NewImage returns a new Image node.
|
|
func NewImage(link *Link) *Image {
|
|
c := &Image{
|
|
baseLink: baseLink{
|
|
BaseInline: BaseInline{},
|
|
},
|
|
}
|
|
c.Destination = link.Destination
|
|
c.Title = link.Title
|
|
for n := link.FirstChild(); n != nil; {
|
|
next := n.NextSibling()
|
|
link.RemoveChild(link, n)
|
|
c.AppendChild(c, n)
|
|
n = next
|
|
}
|
|
|
|
return c
|
|
}
|
|
|
|
// AutoLinkType defines kind of auto links.
|
|
type AutoLinkType int
|
|
|
|
const (
|
|
// AutoLinkEmail indicates that an autolink is an email address.
|
|
AutoLinkEmail AutoLinkType = iota + 1
|
|
// AutoLinkURL indicates that an autolink is a generic URL.
|
|
AutoLinkURL
|
|
)
|
|
|
|
// An AutoLink struct represents an autolink of the Markdown text.
|
|
type AutoLink struct {
|
|
BaseInline
|
|
// Type is a type of this autolink.
|
|
AutoLinkType AutoLinkType
|
|
|
|
// Protocol specified a protocol of the link.
|
|
Protocol []byte
|
|
|
|
value *Text
|
|
}
|
|
|
|
// Inline implements Inline.Inline.
|
|
func (n *AutoLink) Inline() {}
|
|
|
|
// Dump implenets Node.Dump
|
|
func (n *AutoLink) Dump(source []byte, level int) {
|
|
segment := n.value.Segment
|
|
m := map[string]string{
|
|
"Value": string(segment.Value(source)),
|
|
}
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindAutoLink is a NodeKind of the AutoLink node.
|
|
var KindAutoLink = NewNodeKind("AutoLink")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *AutoLink) Kind() NodeKind {
|
|
return KindAutoLink
|
|
}
|
|
|
|
// URL returns an url of this node.
|
|
func (n *AutoLink) URL(source []byte) []byte {
|
|
if n.Protocol != nil {
|
|
s := n.value.Segment
|
|
ret := make([]byte, 0, len(n.Protocol)+s.Len()+3)
|
|
ret = append(ret, n.Protocol...)
|
|
ret = append(ret, ':', '/', '/')
|
|
ret = append(ret, n.value.Text(source)...)
|
|
return ret
|
|
}
|
|
return n.value.Text(source)
|
|
}
|
|
|
|
// Label returns a label of this node.
|
|
func (n *AutoLink) Label(source []byte) []byte {
|
|
return n.value.Text(source)
|
|
}
|
|
|
|
// NewAutoLink returns a new AutoLink node.
|
|
func NewAutoLink(typ AutoLinkType, value *Text) *AutoLink {
|
|
return &AutoLink{
|
|
BaseInline: BaseInline{},
|
|
value: value,
|
|
AutoLinkType: typ,
|
|
}
|
|
}
|
|
|
|
// A RawHTML struct represents an inline raw HTML of the Markdown text.
|
|
type RawHTML struct {
|
|
BaseInline
|
|
Segments *textm.Segments
|
|
}
|
|
|
|
// Inline implements Inline.Inline.
|
|
func (n *RawHTML) Inline() {}
|
|
|
|
// Dump implements Node.Dump.
|
|
func (n *RawHTML) Dump(source []byte, level int) {
|
|
m := map[string]string{}
|
|
t := []string{}
|
|
for i := 0; i < n.Segments.Len(); i++ {
|
|
segment := n.Segments.At(i)
|
|
t = append(t, string(segment.Value(source)))
|
|
}
|
|
m["RawText"] = strings.Join(t, "")
|
|
DumpHelper(n, source, level, m, nil)
|
|
}
|
|
|
|
// KindRawHTML is a NodeKind of the RawHTML node.
|
|
var KindRawHTML = NewNodeKind("RawHTML")
|
|
|
|
// Kind implements Node.Kind.
|
|
func (n *RawHTML) Kind() NodeKind {
|
|
return KindRawHTML
|
|
}
|
|
|
|
// NewRawHTML returns a new RawHTML node.
|
|
func NewRawHTML() *RawHTML {
|
|
return &RawHTML{
|
|
Segments: textm.NewSegments(),
|
|
}
|
|
}
|