117 lines
3.6 KiB
Go
117 lines
3.6 KiB
Go
package api
|
|
|
|
import "strings"
|
|
|
|
// frontmatter is an ordered, line-preserving view of a note's YAML
|
|
// frontmatter block. It deliberately avoids a full YAML round-trip: the
|
|
// brain writes flat `key: value` frontmatter by hand, and a yaml.v3
|
|
// re-marshal would reorder keys and strip comments. Preserving the
|
|
// original lines verbatim keeps brain_update a surgical edit — only the
|
|
// keys it manages (updated_at, supersedes, supersede_reason) change.
|
|
type frontmatter struct {
|
|
lines []fmLine
|
|
}
|
|
|
|
// fmLine is one frontmatter line. For `key: value` lines, key and value
|
|
// are populated; for blank lines, comments, or anything that isn't a
|
|
// simple scalar pair, key is empty and raw holds the line verbatim.
|
|
type fmLine struct {
|
|
key string
|
|
value string
|
|
raw string
|
|
}
|
|
|
|
// parseFrontmatter splits src into its frontmatter block and body. A
|
|
// frontmatter block is recognised only when the file opens with a `---`
|
|
// fence and a closing `---` fence follows. Otherwise the whole input is
|
|
// the body and the returned frontmatter is empty.
|
|
func parseFrontmatter(src string) (frontmatter, string) {
|
|
var fm frontmatter
|
|
if !strings.HasPrefix(src, "---\n") {
|
|
return fm, src
|
|
}
|
|
rest := src[len("---\n"):]
|
|
end := strings.Index(rest, "\n---\n")
|
|
if end < 0 {
|
|
// Opening fence with no closing fence — treat as bodyless content.
|
|
return fm, src
|
|
}
|
|
block := rest[:end]
|
|
body := rest[end+len("\n---\n"):]
|
|
|
|
for _, line := range strings.Split(block, "\n") {
|
|
// An indented line is a continuation (a YAML block-list item, a
|
|
// wrapped value) never a top-level key, regardless of whether it
|
|
// happens to contain a colon — " - 'Chapter 3: The Reckoning'" is
|
|
// not a key named "- 'Chapter 3" (hyperguild#128). Checked before
|
|
// Cut so a colon inside one never reaches the key/value path.
|
|
if line != "" && (line[0] == ' ' || line[0] == '\t') {
|
|
fm.lines = append(fm.lines, fmLine{raw: line})
|
|
continue
|
|
}
|
|
key, val, ok := strings.Cut(line, ":")
|
|
key = strings.TrimSpace(key)
|
|
if !ok || key == "" || strings.HasPrefix(strings.TrimSpace(line), "#") {
|
|
fm.lines = append(fm.lines, fmLine{raw: line})
|
|
continue
|
|
}
|
|
fm.lines = append(fm.lines, fmLine{key: key, value: strings.TrimSpace(val)})
|
|
}
|
|
return fm, body
|
|
}
|
|
|
|
// get returns the value for key, or "" if absent.
|
|
func (f *frontmatter) get(key string) string {
|
|
for _, l := range f.lines {
|
|
if l.key == key {
|
|
return l.value
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// set overrides the value for an existing key in place, or appends a new
|
|
// `key: value` line when the key is absent.
|
|
func (f *frontmatter) set(key, value string) {
|
|
for i := range f.lines {
|
|
if f.lines[i].key == key {
|
|
f.lines[i].value = value
|
|
return
|
|
}
|
|
}
|
|
f.lines = append(f.lines, fmLine{key: key, value: value})
|
|
}
|
|
|
|
// render serialises the frontmatter back into a `---`-fenced block. An
|
|
// empty frontmatter renders to the empty string so bodies without a
|
|
// header stay header-less.
|
|
func (f *frontmatter) render() string {
|
|
if len(f.lines) == 0 {
|
|
return ""
|
|
}
|
|
var b strings.Builder
|
|
b.WriteString("---\n")
|
|
for _, l := range f.lines {
|
|
switch {
|
|
case l.key == "":
|
|
b.WriteString(l.raw)
|
|
case l.value == "":
|
|
// A key with nothing after the colon (the YAML block-list
|
|
// shape: "aliases:" followed by indented "- item" lines on
|
|
// their own raw lines) must stay bare — "key: " with a
|
|
// trailing space is a different byte sequence than the
|
|
// original, and this type's whole purpose (see the package
|
|
// doc) is a byte-preserving round-trip.
|
|
b.WriteString(l.key)
|
|
b.WriteByte(':')
|
|
default:
|
|
b.WriteString(l.key)
|
|
b.WriteString(": ")
|
|
b.WriteString(l.value)
|
|
}
|
|
b.WriteByte('\n')
|
|
}
|
|
b.WriteString("---\n")
|
|
return b.String()
|
|
}
|