xonecas.io
8356
Wx

www-xonecas-io / files

www-xonecas-io / internal / site / readme.go

3.7 KB
1package site
2
3import (
4	"bytes"
5	"html"
6	"html/template"
7	"path"
8	"regexp"
9	"strings"
10
11	"github.com/alecthomas/chroma/v2/lexers"
12	"github.com/yuin/goldmark"
13	"github.com/yuin/goldmark/ast"
14	"github.com/yuin/goldmark/extension"
15	"github.com/yuin/goldmark/parser"
16	"github.com/yuin/goldmark/renderer"
17	mdhtml "github.com/yuin/goldmark/renderer/html"
18	"github.com/yuin/goldmark/util"
19
20	"xonecas.io/site/internal/repo"
21)
22
23// Raw HTML stays: READMEs come from xonecas's own repos, and several centre a logo with <p align>.
24var md = goldmark.New(
25	goldmark.WithExtensions(extension.GFM),
26	goldmark.WithParserOptions(parser.WithAutoHeadingID()),
27	goldmark.WithRendererOptions(mdhtml.WithUnsafe(), renderer.WithNodeRenderers(util.Prioritized(fenced{}, 100))),
28)
29
30// fenced renders a fenced code block in the file pages' colours, by the fence's language.
31// A block with no language, or one chroma does not know, stays plain.
32type fenced struct{}
33
34func (fenced) RegisterFuncs(r renderer.NodeRendererFuncRegisterer) {
35	r.Register(ast.KindFencedCodeBlock, func(w util.BufWriter, src []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
36		if !entering {
37			return ast.WalkSkipChildren, nil
38		}
39		b := n.(*ast.FencedCodeBlock)
40		var text strings.Builder
41		for i := range b.Lines().Len() {
42			line := b.Lines().At(i)
43			text.Write(line.Value(src))
44		}
45		lang := string(b.Language(src))
46		lexer := lexers.Get(lang)
47		if lexer == nil {
48			lexer = lexers.Fallback
49		}
50		tokens, err := tokenise(lexer, text.String())
51		if err != nil {
52			return ast.WalkStop, err
53		}
54		w.WriteString(`<pre><code class="code language-` + html.EscapeString(lang) + `">`)
55		writeTokens(w, tokens)
56		w.WriteString("</code></pre>\n")
57		return ast.WalkSkipChildren, nil
58	})
59}
60
61var (
62	attr     = regexp.MustCompile(`\b(src|href)="([^"]*)"`)
63	external = regexp.MustCompile(`(?i)^([a-z][a-z0-9+.-]*:|#|/)`)
64	image    = regexp.MustCompile(`(?i)\.(png|jpe?g|gif|svg|webp|avif|ico|bmp)$`)
65	markdown = regexp.MustCompile(`(?i)\.(md|markdown|mdown|mkd)$`)
66	heading  = regexp.MustCompile(`^(#{1,6})([^#\s])`)
67	fence    = regexp.MustCompile("^\\s*(```|~~~)")
68)
69
70// oldHeadings adds the space early Markdown let READMEs skip, as in "#Title", outside code fences.
71func oldHeadings(text string) string {
72	lines, code := strings.Split(text, "\n"), false
73	for i, l := range lines {
74		if fence.MatchString(l) {
75			code = !code
76		} else if !code {
77			lines[i] = heading.ReplaceAllString(l, "$1 $2")
78		}
79	}
80	return strings.Join(lines, "\n")
81}
82
83// Readme renders the README of project name: Markdown as HTML, anything else as plain text.
84// Relative links point at the file pages, and relative images at raw/, which serves the file itself.
85func Readme(dir, name, readme string, t Tree) (template.HTML, error) {
86	text, err := repo.Git(dir, "show", "HEAD:"+readme)
87	if err != nil || !markdown.MatchString(readme) {
88		return template.HTML(`<pre class="whitespace-pre-wrap font-mono text-[12.5px]">` + html.EscapeString(text) + `</pre>`), err
89	}
90	var buf bytes.Buffer
91	if err := md.Convert([]byte(oldHeadings(text)), &buf); err != nil {
92		return "", err
93	}
94	out := attr.ReplaceAllStringFunc(buf.String(), func(m string) string {
95		sub := attr.FindStringSubmatch(m)
96		u := html.UnescapeString(sub[2])
97		if u == "" || external.MatchString(u) {
98			return m
99		}
100		p, frag, _ := strings.Cut(u, "#")
101		p, _, _ = strings.Cut(p, "?")
102		p = path.Join(path.Dir(readme), p)
103		_, file := t.Files[p]
104		switch {
105		case file && (sub[1] == "src" || image.MatchString(p)):
106			u = href(name, "raw", p)
107		case file:
108			u = href(name, "blob", p)
109		case t.Dirs[p]:
110			u = href(name, "tree", p)
111		default:
112			return m
113		}
114		if frag != "" {
115			u += "#" + frag
116		}
117		return sub[1] + `="` + html.EscapeString(u) + `"`
118	})
119	return template.HTML(out), nil
120}