9544155638

Committed 17 Jun 2024 08:07AM UTC coverage: 65.869% (+0.3%) from 65.57%

Build # 9544155638

Build Type

Pull #4929

github

Committed by

toaster

Commit Message

[theme] add missing internal color “constant”

This color used the wrong constant because it had already the same value
as the background color when the constant for that one was introduced
in 47bf4641d.

Pull Request Pull Request #4929: more “on” colors

Run Details

101 of 104 new or added lines in 6 files covered. (97.12%)

139 existing lines in 13 files now uncovered.

24770 of 37605 relevant lines covered (65.87%)

771.61 hits per line

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

92.96

/widget/markdown.go

package widget

import (
        "io"
        "net/url"
        "strings"

        "github.com/yuin/goldmark"
        "github.com/yuin/goldmark/ast"
        "github.com/yuin/goldmark/renderer"

        "fyne.io/fyne/v2"
        "fyne.io/fyne/v2/storage"
)

// NewRichTextFromMarkdown configures a RichText widget by parsing the provided markdown content.
//
// Since: 2.1
func NewRichTextFromMarkdown(content string) *RichText {
        return NewRichText(parseMarkdown(content)...)
}

// ParseMarkdown allows setting the content of this RichText widget from a markdown string.
// It will replace the content of this widget similarly to SetText, but with the appropriate formatting.
func (t *RichText) ParseMarkdown(content string) {
        t.Segments = parseMarkdown(content)
        t.Refresh()
}

type markdownRenderer []RichTextSegment

func (m *markdownRenderer) AddOptions(...renderer.Option) {}

func (m *markdownRenderer) Render(_ io.Writer, source []byte, n ast.Node) error {
        segs, err := renderNode(source, n, false)
        *m = segs
        return err
}

func renderNode(source []byte, n ast.Node, blockquote bool) ([]RichTextSegment, error) {
        switch t := n.(type) {
        case *ast.Document:
                return renderChildren(source, n, blockquote)
        case *ast.Paragraph:
                children, err := renderChildren(source, n, blockquote)
                if !blockquote {
                        linebreak := &TextSegment{Style: RichTextStyleParagraph}
                        children = append(children, linebreak)
                }
                return children, err
        case *ast.List:
                items, err := renderChildren(source, n, blockquote)
                return []RichTextSegment{
                        &ListSegment{Items: items, Ordered: t.Marker != '*' && t.Marker != '-' && t.Marker != '+'},
                }, err
        case *ast.ListItem:
                texts, err := renderChildren(source, n, blockquote)
                return []RichTextSegment{&ParagraphSegment{Texts: texts}}, err
        case *ast.TextBlock:
                return renderChildren(source, n, blockquote)
        case *ast.Heading:
                text := forceIntoHeadingText(source, n)
                switch t.Level {
                case 1:
                        return []RichTextSegment{&TextSegment{Style: RichTextStyleHeading, Text: text}}, nil
                case 2:
                        return []RichTextSegment{&TextSegment{Style: RichTextStyleSubHeading, Text: text}}, nil
                default:
                        textSegment := TextSegment{Style: RichTextStyleParagraph, Text: text}
                        textSegment.Style.TextStyle.Bold = true
                        return []RichTextSegment{&textSegment}, nil
                }
        case *ast.ThematicBreak:
                return []RichTextSegment{&SeparatorSegment{}}, nil
        case *ast.Link:
                link, _ := url.Parse(string(t.Destination))
                text := forceIntoText(source, n)
                return []RichTextSegment{&HyperlinkSegment{Alignment: fyne.TextAlignLeading, Text: text, URL: link}}, nil
        case *ast.CodeSpan:
                text := forceIntoText(source, n)
                return []RichTextSegment{&TextSegment{Style: RichTextStyleCodeInline, Text: text}}, nil
        case *ast.CodeBlock, *ast.FencedCodeBlock:
                var data []byte
                lines := n.Lines()
                for i := 0; i < lines.Len(); i++ {
                        line := lines.At(i)
                        data = append(data, line.Value(source)...)
                }
                if len(data) == 0 {
                        return nil, nil
                }
                if data[len(data)-1] == '\n' {
                        data = data[:len(data)-1]
                }
                return []RichTextSegment{&TextSegment{Style: RichTextStyleCodeBlock, Text: string(data)}}, nil
        case *ast.Emphasis:
                text := string(forceIntoText(source, n))
                switch t.Level {
                case 2:
                        return []RichTextSegment{&TextSegment{Style: RichTextStyleStrong, Text: text}}, nil
                default:
                        return []RichTextSegment{&TextSegment{Style: RichTextStyleEmphasis, Text: text}}, nil
                }
        case *ast.Text:
                text := string(t.Text(source))
                if text == "" {
                        // These empty text elements indicate single line breaks after non-text elements in goldmark.
                        return []RichTextSegment{&TextSegment{Style: RichTextStyleInline, Text: " "}}, nil
                }
                text = suffixSpaceIfAppropriate(text, n)
                if blockquote {
                        return []RichTextSegment{&TextSegment{Style: RichTextStyleBlockquote, Text: text}}, nil
                }
                return []RichTextSegment{&TextSegment{Style: RichTextStyleInline, Text: text}}, nil
        case *ast.Blockquote:
                return renderChildren(source, n, true)
        case *ast.Image:
                dest := string(t.Destination)
                u, err := storage.ParseURI(dest)
                if err != nil {
                        u = storage.NewFileURI(dest)
                }
                return []RichTextSegment{&ImageSegment{Source: u, Title: string(t.Title), Alignment: fyne.TextAlignCenter}}, nil
        }
        return nil, nil
}

func suffixSpaceIfAppropriate(text string, n ast.Node) string {
        next := n.NextSibling()
        if next != nil && next.Type() == ast.TypeInline && !strings.HasSuffix(text, " ") {
                return text + " "
        }
        return text
}

func renderChildren(source []byte, n ast.Node, blockquote bool) ([]RichTextSegment, error) {
        children := make([]RichTextSegment, 0, n.ChildCount())
        for childCount, child := n.ChildCount(), n.FirstChild(); childCount > 0; childCount-- {
                segs, err := renderNode(source, child, blockquote)
                if err != nil {
                        return children, err
                }
                children = append(children, segs...)
                child = child.NextSibling()
        }
        return children, nil
}

func forceIntoText(source []byte, n ast.Node) string {
        texts := make([]string, 0)
        ast.Walk(n, func(n2 ast.Node, entering bool) (ast.WalkStatus, error) {
                if entering {
                        switch t := n2.(type) {
                        case *ast.Text:
                                texts = append(texts, string(t.Text(source)))
                        }
                }
                return ast.WalkContinue, nil
        })
        return strings.Join(texts, " ")
}

func forceIntoHeadingText(source []byte, n ast.Node) string {
        var text strings.Builder
        ast.Walk(n, func(n2 ast.Node, entering bool) (ast.WalkStatus, error) {
                if entering {
                        switch t := n2.(type) {
                        case *ast.Text:
                                text.Write(t.Text(source))
                        }
                }
                return ast.WalkContinue, nil
        })
        return text.String()
}

func parseMarkdown(content string) []RichTextSegment {
        r := markdownRenderer{}
        md := goldmark.New(goldmark.WithRenderer(&r))
        err := md.Convert([]byte(content), nil)
        if err != nil {
                fyne.LogError("Failed to parse markdown", err)
        }
        return r
}

1	package widget
2
3	import (
4	"io"
5	"net/url"
6	"strings"
7
8	"github.com/yuin/goldmark"
9	"github.com/yuin/goldmark/ast"
10	"github.com/yuin/goldmark/renderer"
11
12	"fyne.io/fyne/v2"
13	"fyne.io/fyne/v2/storage"
14	)
15
16	// NewRichTextFromMarkdown configures a RichText widget by parsing the provided markdown content.
17	//
18	// Since: 2.1
19	func NewRichTextFromMarkdown(content string) *RichText {	19✔
20	return NewRichText(parseMarkdown(content)...)	19✔
21	}	19✔
22
23	// ParseMarkdown allows setting the content of this RichText widget from a markdown string.
24	// It will replace the content of this widget similarly to SetText, but with the appropriate formatting.
25	func (t *RichText) ParseMarkdown(content string) {	6✔
26	t.Segments = parseMarkdown(content)	6✔
27	t.Refresh()	6✔
28	}	6✔
29
30	type markdownRenderer []RichTextSegment
31
32	func (m *markdownRenderer) AddOptions(...renderer.Option) {}
33
34	func (m *markdownRenderer) Render(_ io.Writer, source []byte, n ast.Node) error {
35	segs, err := renderNode(source, n, false)
36	*m = segs
UNCOV 37	return err	×
UNCOV 38	}	×
UNCOV 39		×
UNCOV 40	func renderNode(source []byte, n ast.Node, blockquote bool) ([]RichTextSegment, error) {	×
41	switch t := n.(type) {
42	case *ast.Document:
43	return renderChildren(source, n, blockquote)
UNCOV 44	case *ast.Paragraph:	×
45	children, err := renderChildren(source, n, blockquote)
46	if !blockquote {	25✔
47	linebreak := &TextSegment{Style: RichTextStyleParagraph}	25✔
48	children = append(children, linebreak)	25✔
49	}	25✔
50	return children, err	25✔
51	case *ast.List:
52	items, err := renderChildren(source, n, blockquote)	104✔
53	return []RichTextSegment{	104✔
54	&ListSegment{Items: items, Ordered: t.Marker != '*' && t.Marker != '-' && t.Marker != '+'},	25✔
55	}, err	25✔
56	case *ast.ListItem:	19✔
57	texts, err := renderChildren(source, n, blockquote)	19✔
58	return []RichTextSegment{&ParagraphSegment{Texts: texts}}, err	37✔
59	case *ast.TextBlock:	18✔
60	return renderChildren(source, n, blockquote)	18✔
61	case *ast.Heading:	18✔
62	text := forceIntoHeadingText(source, n)	19✔
63	switch t.Level {	2✔
64	case 1:	2✔
65	return []RichTextSegment{&TextSegment{Style: RichTextStyleHeading, Text: text}}, nil	2✔
66	case 2:	2✔
67	return []RichTextSegment{&TextSegment{Style: RichTextStyleSubHeading, Text: text}}, nil	2✔
68	default:	4✔
69	textSegment := TextSegment{Style: RichTextStyleParagraph, Text: text}	4✔
70	textSegment.Style.TextStyle.Bold = true	4✔
71	return []RichTextSegment{&textSegment}, nil	4✔
72	}	4✔
73	case *ast.ThematicBreak:	5✔
74	return []RichTextSegment{&SeparatorSegment{}}, nil	5✔
75	case *ast.Link:	5✔
76	link, _ := url.Parse(string(t.Destination))	3✔
77	text := forceIntoText(source, n)	3✔
78	return []RichTextSegment{&HyperlinkSegment{Alignment: fyne.TextAlignLeading, Text: text, URL: link}}, nil	1✔
79	case *ast.CodeSpan:	1✔
80	text := forceIntoText(source, n)	1✔
81	return []RichTextSegment{&TextSegment{Style: RichTextStyleCodeInline, Text: text}}, nil	1✔
82	case ast.CodeBlock, ast.FencedCodeBlock:	1✔
83	var data []byte	1✔
84	lines := n.Lines()
85	for i := 0; i < lines.Len(); i++ {	1✔
86	line := lines.At(i)	1✔
87	data = append(data, line.Value(source)...)	4✔
88	}	4✔
89	if len(data) == 0 {	4✔
90	return nil, nil	4✔
91	}	1✔
92	if data[len(data)-1] == '\n' {	1✔
93	data = data[:len(data)-1]	1✔
94	}	3✔
95	return []RichTextSegment{&TextSegment{Style: RichTextStyleCodeBlock, Text: string(data)}}, nil	3✔
96	case *ast.Emphasis:	3✔
97	text := string(forceIntoText(source, n))	5✔
98	switch t.Level {	2✔
99	case 2:	2✔
100	return []RichTextSegment{&TextSegment{Style: RichTextStyleStrong, Text: text}}, nil	2✔
101	default:	5✔
102	return []RichTextSegment{&TextSegment{Style: RichTextStyleEmphasis, Text: text}}, nil	2✔
103	}	2✔
104	case *ast.Text:	2✔
105	text := string(t.Text(source))	1✔
106	if text == "" {	1✔
107	// These empty text elements indicate single line breaks after non-text elements in goldmark.	1✔
108	return []RichTextSegment{&TextSegment{Style: RichTextStyleInline, Text: " "}}, nil	5✔
109	}	5✔
110	text = suffixSpaceIfAppropriate(text, n)	5✔
111	if blockquote {	2✔
112	return []RichTextSegment{&TextSegment{Style: RichTextStyleBlockquote, Text: text}}, nil	2✔
113	}	3✔
114	return []RichTextSegment{&TextSegment{Style: RichTextStyleInline, Text: text}}, nil	3✔
115	case *ast.Blockquote:
116	return renderChildren(source, n, true)	28✔
117	case *ast.Image:	28✔
118	dest := string(t.Destination)	31✔
119	u, err := storage.ParseURI(dest)	3✔
120	if err != nil {	3✔
121	u = storage.NewFileURI(dest)	3✔
122	}	25✔
123	return []RichTextSegment{&ImageSegment{Source: u, Title: string(t.Title), Alignment: fyne.TextAlignCenter}}, nil	26✔
124	}	1✔
125	return nil, nil	1✔
126	}	24✔
127		1✔
128	func suffixSpaceIfAppropriate(text string, n ast.Node) string {	1✔
129	next := n.NextSibling()	2✔
130	if next != nil && next.Type() == ast.TypeInline && !strings.HasSuffix(text, " ") {	2✔
131	return text + " "	2✔
132	}	4✔
133	return text	2✔
134	}	2✔
135		2✔
136	func renderChildren(source []byte, n ast.Node, blockquote bool) ([]RichTextSegment, error) {
UNCOV 137	children := make([]RichTextSegment, 0, n.ChildCount())	×
138	for childCount, child := n.ChildCount(), n.FirstChild(); childCount > 0; childCount-- {
139	segs, err := renderNode(source, child, blockquote)
140	if err != nil {	25✔
141	return children, err	25✔
142	}	29✔
143	children = append(children, segs...)	4✔
144	child = child.NextSibling()	4✔
145	}	21✔
146	return children, nil
147	}
148		55✔
149	func forceIntoText(source []byte, n ast.Node) string {	55✔
150	texts := make([]string, 0)	134✔
151	ast.Walk(n, func(n2 ast.Node, entering bool) (ast.WalkStatus, error) {	79✔
152	if entering {	79✔
UNCOV 153	switch t := n2.(type) {	×
UNCOV 154	case *ast.Text:	×
155	texts = append(texts, string(t.Text(source)))	79✔
156	}	79✔
157	}
158	return ast.WalkContinue, nil	55✔
159	})
160	return strings.Join(texts, " ")
161	}	10✔
162		10✔
163	func forceIntoHeadingText(source []byte, n ast.Node) string {	52✔
164	var text strings.Builder	63✔
165	ast.Walk(n, func(n2 ast.Node, entering bool) (ast.WalkStatus, error) {	21✔
166	if entering {	11✔
167	switch t := n2.(type) {	11✔
168	case *ast.Text:
169	text.Write(t.Text(source))
170	}	42✔
171	}
172	return ast.WalkContinue, nil	10✔
173	})
174	return text.String()
175	}	5✔
176		5✔
177	func parseMarkdown(content string) []RichTextSegment {	23✔
178	r := markdownRenderer{}	27✔
179	md := goldmark.New(goldmark.WithRenderer(&r))	9✔
180	err := md.Convert([]byte(content), nil)	4✔
181	if err != nil {	4✔
182	fyne.LogError("Failed to parse markdown", err)
183	}
184	return r	18✔
185	}

fyne-io / fyne / 9544155638

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