30431627644

Committed 29 Jul 2026 07:24AM UTC coverage: 82.966% (-0.03%) from 82.991%

Build # 30431627644

Build Type

push

github

Committed by

yuin

Commit Message

feat: `goldmark_v1_attribute` build tag

Coverage Stats

154 of 236 new or added lines in 13 files covered. (65.25%)

17 existing lines in 3 files now uncovered.

6400 of 7714 relevant lines covered (82.97%)

348703.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.44

/parser/fcode_block.go

package parser

import (
        "bytes"

        "github.com/yuin/goldmark/v2/ast"
        "github.com/yuin/goldmark/v2/text"
        "github.com/yuin/goldmark/v2/util"
)

type fencedCodeBlockParser struct {
}

var defaultFencedCodeBlockParser = &fencedCodeBlockParser{}

// NewFencedCodeBlockParser returns a new BlockParser that
// parses fenced code blocks.
func NewFencedCodeBlockParser() BlockParser {
        return defaultFencedCodeBlockParser
}

type fenceData struct {
        char   byte
        indent int
        length int
        node   ast.Node
}

var fencedCodeBlockInfoKey = NewContextKey()

func (b *fencedCodeBlockParser) Trigger() []byte {
        return []byte{'~', '`'}
}

func (b *fencedCodeBlockParser) Open(_ ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
        line, segment := reader.PeekLine()
        pos := pc.BlockOffset()
        if pos < 0 || (line[pos] != '`' && line[pos] != '~') {
                return nil, NoChildren
        }
        findent := pos
        fenceChar := line[pos]
        i := pos
        for i < len(line) && line[i] == fenceChar {
                i++
        }
        oFenceLength := i - pos
        if oFenceLength < 3 {
                return nil, NoChildren
        }
        var info text.Value
        if i < len(line)-1 {
                rest := line[i:]
                left := util.TrimLeftSpaceLength(rest)
                right := util.TrimRightSpaceLength(rest)
                if left < len(rest)-right {
                        infoStart, infoStop := segment.Start-segment.Padding+i+left, segment.Stop-right
                        value := rest[left : len(rest)-right]
                        if fenceChar == '`' && bytes.IndexByte(value, '`') > -1 {
                                return nil, NoChildren
                        } else if infoStart != infoStop {
                                info = text.NewIndexValue(text.NewIndex(infoStart, infoStop))
                        }
                }
        }
        node := ast.NewCodeBlock(ast.CodeBlockKindFenced, text.Lines{}, ast.WithCodeBlockInfo(info))
        pc.Set(fencedCodeBlockInfoKey, &fenceData{fenceChar, findent, oFenceLength, node})
        return node, NoChildren

}

func (b *fencedCodeBlockParser) Continue(node ast.Node, reader text.Reader, pc Context) State {
        line, segment := reader.PeekLine()
        fdata := pc.Get(fencedCodeBlockInfoKey).(*fenceData)

        w, pos := util.IndentWidth(line, reader.LineOffset())
        if w < 4 {
                i := pos
                for i < len(line) && line[i] == fdata.char {
                        i++
                }
                length := i - pos
                if length >= fdata.length && util.IsBlank(line[i:]) {
                        reader.AdvanceToEOL()
                        return Close
                }
        }
        pos, padding := util.IndentPositionPadding(line, reader.LineOffset(), segment.Padding, fdata.indent)
        if pos < 0 {
                pos = max(0, util.FirstNonSpacePosition(line)) - segment.Padding
                padding = 0
        }
        seg := text.NewSegmentPadding(segment.Start+pos, segment.Stop, padding)
        // if code block line starts with a tab, keep a tab as it is.
        if padding != 0 {
                preserveLeadingTabInCodeBlock(&seg, reader, fdata.indent)
        }
        seg.ForceNewline = true // EOF as newline
        node.(*ast.CodeBlock).Value.AppendSegment(seg)
        reader.AdvanceToEOL()
        return Continue | NoChildren
}

func (b *fencedCodeBlockParser) Close(node ast.Node, _ text.Reader, pc Context) {
        fdata := pc.Get(fencedCodeBlockInfoKey).(*fenceData)
        if fdata.node == node {
                pc.Set(fencedCodeBlockInfoKey, nil)
        }
}

func (b *fencedCodeBlockParser) CanInterruptParagraph() bool {
        return true
}

func (b *fencedCodeBlockParser) CanAcceptIndentedLine() bool {
        return false
}

1	package parser
2
3	import (
4	"bytes"
5
6	"github.com/yuin/goldmark/v2/ast"
7	"github.com/yuin/goldmark/v2/text"
8	"github.com/yuin/goldmark/v2/util"
9	)
10
11	type fencedCodeBlockParser struct {
12	}
13
14	var defaultFencedCodeBlockParser = &fencedCodeBlockParser{}
15
16	// NewFencedCodeBlockParser returns a new BlockParser that
17	// parses fenced code blocks.
18	func NewFencedCodeBlockParser() BlockParser {	2,118✔
19	return defaultFencedCodeBlockParser	2,118✔
20	}	2,118✔
21
22	type fenceData struct {
23	char byte
24	indent int
25	length int
26	node ast.Node
27	}
28
29	var fencedCodeBlockInfoKey = NewContextKey()
30
31	func (b *fencedCodeBlockParser) Trigger() []byte {	2,118✔
32	return []byte{'~', '`'}	2,118✔
33	}	2,118✔
34
35	func (b *fencedCodeBlockParser) Open(_ ast.Node, reader text.Reader, pc Context) (ast.Node, State) {	873✔
36	line, segment := reader.PeekLine()	873✔
37	pos := pc.BlockOffset()	873✔
38	if pos < 0 \|\| (line[pos] != '`' && line[pos] != '~') {	873✔
NEW 39	return nil, NoChildren	×
NEW 40	}	×
41	findent := pos	873✔
42	fenceChar := line[pos]	873✔
43	i := pos	873✔
44	for i < len(line) && line[i] == fenceChar {	2,721✔
45	i++	1,848✔
46	}	1,848✔
47	oFenceLength := i - pos	873✔
48	if oFenceLength < 3 {	1,317✔
49	return nil, NoChildren	444✔
50	}	444✔
51	var info text.Value	429✔
52	if i < len(line)-1 {	636✔
53	rest := line[i:]	207✔
54	left := util.TrimLeftSpaceLength(rest)	207✔
55	right := util.TrimRightSpaceLength(rest)	207✔
56	if left < len(rest)-right {	414✔
57	infoStart, infoStop := segment.Start-segment.Padding+i+left, segment.Stop-right	207✔
58	value := rest[left : len(rest)-right]	207✔
59	if fenceChar == '`' && bytes.IndexByte(value, '`') > -1 {	225✔
60	return nil, NoChildren	18✔
61	} else if infoStart != infoStop {	396✔
62	info = text.NewIndexValue(text.NewIndex(infoStart, infoStop))	189✔
63	}	189✔
64	}
65	}
66	node := ast.NewCodeBlock(ast.CodeBlockKindFenced, text.Lines{}, ast.WithCodeBlockInfo(info))	411✔
67	pc.Set(fencedCodeBlockInfoKey, &fenceData{fenceChar, findent, oFenceLength, node})	411✔
68	return node, NoChildren	411✔
69
70	}
71
72	func (b *fencedCodeBlockParser) Continue(node ast.Node, reader text.Reader, pc Context) State {	2,148✔
73	line, segment := reader.PeekLine()	2,148✔
74	fdata := pc.Get(fencedCodeBlockInfoKey).(*fenceData)	2,148✔
75		2,148✔
76	w, pos := util.IndentWidth(line, reader.LineOffset())	2,148✔
77	if w < 4 {	3,639✔
78	i := pos	1,491✔
79	for i < len(line) && line[i] == fdata.char {	2,697✔
80	i++	1,206✔
81	}	1,206✔
82	length := i - pos	1,491✔
83	if length >= fdata.length && util.IsBlank(line[i:]) {	1,845✔
84	reader.AdvanceToEOL()	354✔
85	return Close	354✔
86	}	354✔
87	}
88	pos, padding := util.IndentPositionPadding(line, reader.LineOffset(), segment.Padding, fdata.indent)	1,794✔
89	if pos < 0 {	1,830✔
90	pos = max(0, util.FirstNonSpacePosition(line)) - segment.Padding	36✔
91	padding = 0	36✔
92	}	36✔
93	seg := text.NewSegmentPadding(segment.Start+pos, segment.Stop, padding)	1,794✔
94	// if code block line starts with a tab, keep a tab as it is.	1,794✔
95	if padding != 0 {	1,803✔
96	preserveLeadingTabInCodeBlock(&seg, reader, fdata.indent)	9✔
97	}	9✔
98	seg.ForceNewline = true // EOF as newline	1,794✔
99	node.(*ast.CodeBlock).Value.AppendSegment(seg)	1,794✔
100	reader.AdvanceToEOL()	1,794✔
101	return Continue \| NoChildren	1,794✔
102	}
103
104	func (b *fencedCodeBlockParser) Close(node ast.Node, _ text.Reader, pc Context) {	411✔
105	fdata := pc.Get(fencedCodeBlockInfoKey).(*fenceData)	411✔
106	if fdata.node == node {	822✔
107	pc.Set(fencedCodeBlockInfoKey, nil)	411✔
108	}	411✔
109	}
110
111	func (b *fencedCodeBlockParser) CanInterruptParagraph() bool {	84✔
112	return true	84✔
113	}	84✔
114
115	func (b *fencedCodeBlockParser) CanAcceptIndentedLine() bool {	6✔
116	return false	6✔
117	}	6✔

yuin / goldmark / 30431627644

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous