Fix markdown preview $$ support

Author: charles7668

modules/markup/markdown/markdown_test.go

@@ -555,6 +555,14 @@ func TestMathBlock(t *testing.T) {
 			"$a$ ($b$) [$c$] {$d$}",
 			`<p><code class="language-math is-loading">a</code> (<code class="language-math is-loading">b</code>) [$c$] {$d$}</p>` + nl,
 		},
+		{
+			"$$a$$ test",
+			`<p></p><pre class="code-block is-loading"><code class="chroma language-math display">a</code></pre> test<p></p>` + nl,
+		},
+		{
+			"test $$a$$",
+			`<p>test </p><pre class="code-block is-loading"><code class="chroma language-math display">a</code></pre><p></p>` + nl,
+		},
 	}
 
 	for _, test := range testcases {

modules/markup/markdown/math/block_parser.go

@@ -53,6 +53,12 @@ func (b *blockParser) Open(parent ast.Node, reader text.Reader, pc parser.Contex
 	}
 	idx := bytes.Index(line[pos+2:], endBytes)
 	if idx >= 0 {
+		// for case $$ ... $$ any other text
+		for i := pos + idx + 4; i < len(line); i++ {
+			if line[i] != ' ' && line[i] != '\n' {
+				return nil, parser.NoChildren
+			}
+		}
 		segment.Stop = segment.Start + idx + 2
 		reader.Advance(segment.Len() - 1)
 		segment.Start += 2

modules/markup/markdown/math/inline_block_node.go

@@ -0,0 +1,48 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package math
+
+import (
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/util"
+)
+
+// InlineBlock represents inline math e.g. $$...$$
+type InlineBlock struct {
+	ast.BaseInline
+}
+
+// InlineBlock implements InlineBlock.
+func (n *InlineBlock) InlineBlock() {}
+
+// IsBlank returns if this inline block node is empty
+func (n *InlineBlock) IsBlank(source []byte) bool {
+	for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+		text := c.(*ast.Text).Segment
+		if !util.IsBlank(text.Value(source)) {
+			return false
+		}
+	}
+	return true
+}
+
+// Dump renders this inline block math as debug
+func (n *InlineBlock) Dump(source []byte, level int) {
+	ast.DumpHelper(n, source, level, nil, nil)
+}
+
+// KindInlineBlock is the kind for math inline block
+var KindInlineBlock = ast.NewNodeKind("MathInlineBlock")
+
+// Kind returns KindInlineBlock
+func (n *InlineBlock) Kind() ast.NodeKind {
+	return KindInlineBlock
+}
+
+// NewInlineBlock creates a new ast math inline block node
+func NewInlineBlock() *InlineBlock {
+	return &InlineBlock{
+		BaseInline: ast.BaseInline{},
+	}
+}

modules/markup/markdown/math/inline_block_parser.go

@@ -0,0 +1,109 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package math
+
+import (
+	"bytes"
+
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/parser"
+	"github.com/yuin/goldmark/text"
+)
+
+type inlineBlockParser struct {
+	start []byte
+	end   []byte
+}
+
+var defaultInlineDualDollarParser = &inlineBlockParser{
+	start: []byte{'$', '$'},
+	end:   []byte{'$', '$'},
+}
+
+// NewInlineDualDollarParser returns a new inline block parser
+func NewInlineDualDollarParser() parser.InlineParser {
+	return defaultInlineDualDollarParser
+}
+
+// Trigger triggers this parser on $$
+func (parser *inlineBlockParser) Trigger() []byte {
+	return parser.start[0:2]
+}
+
+// Parse parses the current line and returns a result of parsing.
+func (parser *inlineBlockParser) Parse(parent ast.Node, block text.Reader, pc parser.Context) ast.Node {
+	line, _ := block.PeekLine()
+
+	if !bytes.HasPrefix(line, parser.start) {
+		// We'll catch this one on the next time round
+		return nil
+	}
+
+	precedingCharacter := block.PrecendingCharacter()
+	if precedingCharacter < 256 && (isAlphanumeric(byte(precedingCharacter)) || isPunctuation(byte(precedingCharacter))) {
+		// need to exclude things like `a$$` from being considered a start
+		return nil
+	}
+
+	// move the opener marker point at the start of the text
+	opener := len(parser.start)
+
+	// Now look for an ending line
+	ender := opener
+	for {
+		pos := bytes.Index(line[ender:], parser.end)
+		if pos < 0 {
+			return nil
+		}
+
+		ender += pos
+
+		// Now we want to check the character at the end of our parser section
+		// that is ender + len(parser.end) and check if char before ender is '\'
+		pos = ender + len(parser.end)
+		if len(line) <= pos {
+			break
+		}
+		suceedingCharacter := line[pos]
+		if !isPunctuation(suceedingCharacter) && !(suceedingCharacter == ' ') && !isBracket(suceedingCharacter) {
+			return nil
+		}
+		if line[ender-1] != '\\' {
+			break
+		}
+
+		// move the pointer onwards
+		ender += len(parser.end)
+	}
+
+	block.Advance(opener)
+	_, pos := block.Position()
+	node := NewInlineBlock()
+	segment := pos.WithStop(pos.Start + ender - opener)
+	node.AppendChild(node, ast.NewRawTextSegment(segment))
+	block.Advance(ender - opener + len(parser.end))
+
+	trimInlineBlock(node, block)
+	return node
+}
+
+func trimInlineBlock(node *InlineBlock, block text.Reader) {
+	if node.IsBlank(block.Source()) {
+		return
+	}
+
+	// trim first space and last space
+	first := node.FirstChild().(*ast.Text)
+	if !(!first.Segment.IsEmpty() && block.Source()[first.Segment.Start] == ' ') {
+		return
+	}
+
+	last := node.LastChild().(*ast.Text)
+	if !(!last.Segment.IsEmpty() && block.Source()[last.Segment.Stop-1] == ' ') {
+		return
+	}
+
+	first.Segment = first.Segment.WithStart(first.Segment.Start + 1)
+	last.Segment = last.Segment.WithStop(last.Segment.Stop - 1)
+}

modules/markup/markdown/math/inline_block_renderer.go

@@ -0,0 +1,46 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package math
+
+import (
+	"bytes"
+
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/util"
+)
+
+// InlineBlockRenderer is an inline renderer
+type InlineBlockRenderer struct{}
+
+// NewInlineBlockRenderer returns a new renderer for inline math
+func NewInlineBlockRenderer() renderer.NodeRenderer {
+	return &InlineBlockRenderer{}
+}
+
+func (r *InlineBlockRenderer) renderInlineBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		_, _ = w.WriteString(`<pre class="code-block is-loading"><code class="chroma language-math display">`)
+		for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+			segment := c.(*ast.Text).Segment
+			value := util.EscapeHTML(segment.Value(source))
+			if bytes.HasSuffix(value, []byte("\n")) {
+				_, _ = w.Write(value[:len(value)-1])
+				if c != n.LastChild() {
+					_, _ = w.Write([]byte(" "))
+				}
+			} else {
+				_, _ = w.Write(value)
+			}
+		}
+		return ast.WalkSkipChildren, nil
+	}
+	_, _ = w.WriteString(`</code></pre>`)
+	return ast.WalkContinue, nil
+}
+
+// RegisterFuncs registers the renderer for inline math nodes
+func (r *InlineBlockRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	reg.Register(KindInlineBlock, r.renderInlineBlock)
+}

modules/markup/markdown/math/math.go

@@ -96,12 +96,14 @@ func (e *Extension) Extend(m goldmark.Markdown) {
 		util.Prioritized(NewInlineBracketParser(), 501),
 	}
 	if e.parseDollarInline {
-		inlines = append(inlines, util.Prioritized(NewInlineDollarParser(), 501))
+		inlines = append(inlines, util.Prioritized(NewInlineDualDollarParser(), 501),
+			util.Prioritized(NewInlineDollarParser(), 502))
 	}
 	m.Parser().AddOptions(parser.WithInlineParsers(inlines...))
 
 	m.Renderer().AddOptions(renderer.WithNodeRenderers(
 		util.Prioritized(NewBlockRenderer(), 501),
 		util.Prioritized(NewInlineRenderer(), 502),
+		util.Prioritized(NewInlineBlockRenderer(), 503),
 	))
 }