snowchive-server/glossary.go
2026-11-19 04:40:59 +02:00

135 lines
3.5 KiB
Go

// glossary.go - codename/term glossary loaded from data/glossary.json.
package main
import (
"encoding/json"
"html/template"
"log"
"net/http"
"os"
"sort"
"strings"
)
type GlossaryEntry struct {
Term string `json:"term"`
Aka []string `json:"aka,omitempty"`
Definition string `json:"definition"`
See []string `json:"see,omitempty"`
SeeLinks []seeLink `json:"-"`
searchLink string
}
type seeLink struct{ Name, Term string }
func (e GlossaryEntry) DefinitionHTML() template.HTML {
return template.HTML(e.Definition)
}
func (e GlossaryEntry) SearchURL() string {
if e.searchLink != "" {
return e.searchLink
}
return e.buildSearchURL()
}
func (e GlossaryEntry) buildSearchURL() string {
clauses := []searchClause{{Conj: "and", Field: "TE", Value: searchClauseValue(e.Term)}}
for _, a := range e.Aka {
if strings.TrimSpace(a) != "" {
clauses = append(clauses, searchClause{Conj: "or", Field: "TE", Value: searchClauseValue(a)})
}
}
return searchURL(clauses)
}
func searchClauseValue(v string) string {
v = strings.TrimSpace(v)
if len(splitWords(v)) == 1 && len(splitWords(v)[0]) == len(v) {
return v
}
return `"` + v + `"`
}
func (co *Corpus) glossaryLookup(term string) *GlossaryEntry {
return co.glossaryIndex[strings.ToLower(term)]
}
func (co *Corpus) loadGlossary() {
p := projectPath("glossary.json")
b, err := os.ReadFile(p)
if err != nil {
log.Printf("Note: %s not found - glossary page will be empty.", p)
return
}
if err := json.Unmarshal(b, &co.glossary); err != nil {
warnf("%s is malformed: %v - glossary disabled.", p, err)
co.glossary = nil
return
}
co.glossaryIndex = map[string]*GlossaryEntry{}
sort.SliceStable(co.glossary, func(i, j int) bool {
return normFoldString(co.glossary[i].Term) < normFoldString(co.glossary[j].Term)
})
for i := range co.glossary {
e := &co.glossary[i]
e.searchLink = e.buildSearchURL()
addIndex := func(key string) {
low := strings.ToLower(key)
if prev := co.glossaryIndex[low]; prev != nil && prev != e {
warnf("glossary term/alias %q appears under both %q and %q - the later entry wins", key, prev.Term, e.Term)
}
co.glossaryIndex[low] = e
}
addIndex(e.Term)
for _, a := range e.Aka {
addIndex(a)
}
}
var unknown []string
for i := range co.glossary {
e := &co.glossary[i]
e.SeeLinks = nil
for _, name := range e.See {
l := seeLink{Name: name}
if t := co.glossaryLookup(name); t != nil {
l.Term = t.Term
} else {
unknown = append(unknown, name)
}
e.SeeLinks = append(e.SeeLinks, l)
}
}
if len(unknown) > 0 {
warnf("glossary: %d see-also names match no term or alias, shown unlinked: %s",
len(unknown), strings.Join(firstN(unknown, 8), ", "))
}
co.buildGlossaryGroups()
log.Printf("Glossary loaded: %d terms", len(co.glossary))
}
type glossaryGroup struct {
Letter string
Entries []GlossaryEntry
}
func (co *Corpus) buildGlossaryGroups() {
co.glossaryGroups = nil
for _, e := range co.glossary {
letter := firstLetter(e.Term)
if len(co.glossaryGroups) == 0 || co.glossaryGroups[len(co.glossaryGroups)-1].Letter != letter {
co.glossaryGroups = append(co.glossaryGroups, glossaryGroup{Letter: letter})
}
co.glossaryGroups[len(co.glossaryGroups)-1].Entries = append(co.glossaryGroups[len(co.glossaryGroups)-1].Entries, e)
}
}
func (co *Corpus) handleGlossary(w http.ResponseWriter, r *http.Request) {
render(w, r, &glossaryPage{
Groups: co.glossaryGroups,
GroupsHTML: co.preHTML("glossary"),
Total: len(co.glossary),
})
}