Files
pages/internal/grammaratur/authoring.go
T
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts.

Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation.

Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
2026-11-01 15:23:31 +09:00

131 lines
3.8 KiB
Go

package grammaratur
import (
"bytes"
"encoding/json"
"sort"
"strings"
"github.com/google/uuid"
"golang.org/x/net/html"
)
// HTMLToMarkdownAuthoring keeps source HTML when conversion loses structure,
// attributes, comments or text. This is not a sanitization boundary.
func HTMLToMarkdownAuthoring(source string) (string, error) {
converted, err := HTMLToMarkdown(source)
if err != nil {
return "", err
}
if htmlStructure(source) != htmlStructure(MarkdownToHTML(converted)) {
return rawHTMLBlock(source), nil
}
return converted, nil
}
// {=html} is an explicit authoring fence, not an ordinary code sample. The
// closing delimiter is longer than any run in the source, so arbitrary HTML
// (including Markdown examples) cannot accidentally terminate it.
func rawHTMLBlock(source string) string {
longest, run := 2, 0
for _, c := range source {
if c == '`' {
run++
if run > longest {
longest = run
}
} else {
run = 0
}
}
fence := strings.Repeat("`", longest+1)
return fence + "{=html}\n" + source + "\n" + fence
}
// MarkdownAuthoringHTML preserves protected HTML byte-for-byte while rendering
// ordinary Markdown. Callers must still apply projection sanitization for UI.
func MarkdownAuthoringHTML(source string) string {
lines := strings.SplitAfter(source, "\n")
var markdown strings.Builder
type rawBlock struct{ token, html string }
var blocks []rawBlock
var ordinary byte
ordinaryLen := 0
for i := 0; i < len(lines); i++ {
line := strings.TrimSuffix(strings.TrimSuffix(lines[i], "\n"), "\r")
char, n := byte(0), 0
if len(line) > 0 && (line[0] == '`' || line[0] == '~') {
char = line[0]
for n < len(line) && line[n] == char {
n++
}
}
if ordinary != 0 {
markdown.WriteString(lines[i])
if char == ordinary && n >= ordinaryLen && strings.TrimSpace(line[n:]) == "" {
ordinary = 0
}
continue
}
if char == '`' && n >= 3 && strings.TrimSpace(line[n:]) == "{=html}" {
end := i + 1
for ; end < len(lines); end++ {
close := strings.TrimSpace(lines[end])
if len(close) >= n && strings.Trim(close, "`") == "" {
break
}
}
if end < len(lines) {
raw := strings.TrimSuffix(strings.Join(lines[i+1:end], ""), "\n")
token := "PAGESWIKIRAW" + strings.ReplaceAll(uuid.NewString(), "-", "")
blocks = append(blocks, rawBlock{token, raw})
markdown.WriteString("\n\n" + token + "\n\n")
i = end
continue
}
}
if n >= 3 {
ordinary, ordinaryLen = char, n
}
markdown.WriteString(lines[i])
}
if len(blocks) == 1 && strings.TrimSpace(markdown.String()) == blocks[0].token {
return blocks[0].html
}
out := MarkdownToHTML(markdown.String())
for _, block := range blocks {
out = strings.Replace(out, "<p>"+block.token+"</p>", block.html, 1)
}
return out
}
func htmlStructure(source string) string {
n, err := html.Parse(strings.NewReader(source))
if err != nil {
return source
}
var out bytes.Buffer
var visit func(*html.Node, bool)
visit = func(n *html.Node, literal bool) {
literal = literal || n.Data == "pre" || n.Data == "code" || n.Data == "script" || n.Data == "style"
data := n.Data
if n.Type == html.TextNode && !literal {
if strings.TrimSpace(data) == "" && (n.Parent == nil || n.Parent.Data == "body" || n.Parent.Data == "html") {
return
}
// Inline whitespace can separate words (including around an inline
// element). Never normalize it away when deciding conversion safety.
}
attrs := append([]html.Attribute(nil), n.Attr...)
sort.Slice(attrs, func(i, j int) bool { return attrs[i].Namespace+":"+attrs[i].Key < attrs[j].Namespace+":"+attrs[j].Key })
b, _ := json.Marshal([]any{n.Type, n.Namespace, data, attrs})
out.Write(b)
for c := n.FirstChild; c != nil; c = c.NextSibling {
visit(c, literal)
}
out.WriteByte(')')
}
visit(n, false)
return out.String()
}