naming: localise liturgical day names in any language

Add internal/naming, which renders temporal day names and celebration
display names from the calendar engine's slugs in any language. English is
the built-in baseline; a language is data -- an embedded lang/<code>.ini
(pl shipped) and/or a user file at <config dir>/names/<code>.ini that
overrides it key by key. Names compose from a small vocabulary plus
per-language format templates, so word order and grammatical case can
differ (e.g. Polish genitive "3. Niedziela Okresu Zwykłego"); any string a
language omits falls back to English.

- Move day-name generation out of calendar (calendar.HumanizeSlug removed,
  calendar stays a pure engine) into naming.DayName; the English golden
  cases carry over verbatim.
- naming.CelebrationName unifies the three duplicated resolvers
  (cli/readings/calfeed): name.<lang> -> English -> Latin -> humanized slug.
  Saint names stay in the calendar data (name.<lang>), overridable via
  calendar layers.
- config: ui_language now accepts any code (lower-cased, not clamped to
  en/pl) so names/<code>.ini applies; UI chrome still resolves en/pl and
  falls back to English. Add NamesDir(); wire naming.SetUserDir (and the
  previously unwired bible.SetUserCorporaDir) in the TUI and web mains too,
  so external corpora and name files work across all three binaries.

1 files changed, 453 insertions, 0 deletions

diff --git a/internal/naming/naming.go b/internal/naming/naming.go
new file mode 100644
index 0000000..ca47a15
--- /dev/null
+++ b/internal/naming/naming.go
@@ -0,0 +1,453 @@
+// Package naming renders human-readable liturgical day names from the calendar
+// engine's computed slugs, in any language. English is the built-in baseline
+// (builtinEN, below); every other language is data: an embedded lang/<code>.ini
+// shipped with lectio, and/or a user file at <names dir>/<code>.ini that
+// overrides it key by key. A partial translation never breaks -- any string a
+// language omits falls back to English.
+//
+// Two things are localised here: the generated TEMPORAL day names (e.g. "3rd
+// Sunday in Ordinary Time"), composed from a small vocabulary plus per-language
+// format templates so word order and grammatical case can differ; and the
+// display name of any celebration (CelebrationName), which prefers the
+// calendar entry's own name.<lang> and falls back through English, Latin, and
+// finally the humanized slug. Saint names themselves live in the calendar data
+// (name.<lang>), not here.
+package naming
+
+import (
+	"embed"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/lukaszkasprzak/lectio/internal/calendar"
+	"github.com/lukaszkasprzak/lectio/internal/ini"
+)
+
+//go:embed lang
+var langFS embed.FS
+
+// Table is one language's temporal-naming data. Every field is optional in a
+// language file: a missing entry falls back to the English baseline (for maps,
+// per key), so a translator fills in only what they want to change.
+type Table struct {
+	Weekdays   map[string]string // mon,tue,wed,thu,fri,sat,sun -> weekday name
+	NamedDays  map[string]string // temporal slug -> proper name (Good Friday, ...)
+	Seasons    map[string]string // season slug -> localised season name
+	SeasonPrep map[string]string // season slug -> preposition joining it to a week/Sunday
+	Months     []string          // 12 month names (index 0 = January), for dated ferias
+	Templates  map[string]string // template id -> format with {ord}{wd}{season}{prep}{day}{month}
+	Ordinals   map[string]string // "1".."40" -> localised ordinal (optional; overrides OrdinalFmt)
+	OrdinalFmt string            // printf-style fallback ordinal, e.g. "%d." (optional)
+}
+
+// ---- temporal slug patterns (the calendar engine's own slug shapes) ---------
+
+var (
+	reSeasonSun = regexp.MustCompile(`^(.+)-sunday-(\d+)$`)                 // <season>-sunday-N (all numbered Sundays)
+	reOctave    = regexp.MustCompile(`^easter-octave-([a-z]+)$`)            // Octave of Easter weekday
+	reAfterAsh  = regexp.MustCompile(`^lent-after-ashes-([a-z]+)$`)         // Thu/Fri/Sat after Ash Wednesday
+	reHolyWeek  = regexp.MustCompile(`^holy-week-([a-z]+)$`)                // Mon-Wed of Holy Week
+	reAdventDec = regexp.MustCompile(`^advent-dec-(\d+)$`)                  // late-Advent dated feria
+	reXmasDate  = regexp.MustCompile(`^christmas-(dec|jan)-(\d+)$`)         // Christmastide dated feria
+	reAftEpiph  = regexp.MustCompile(`^christmas-after-epiphany-([a-z]+)$`) // weekday after Epiphany
+	reEmber     = regexp.MustCompile(`^(september|advent)-ember-([a-z]+)$`) // Ember day
+	reWeekday   = regexp.MustCompile(`^(.+)-(\d+)-([a-z]+)$`)               // <season>-<week>-<weekday>
+	rePlacehold = regexp.MustCompile(`\{[a-z]+\}`)                          // leftover {token} cleanup
+)
+
+// weekdayAbbrev maps any weekday token the slugs use (abbreviated or full) to
+// the canonical three-letter key the Table's Weekdays map is keyed by.
+var weekdayAbbrev = map[string]string{
+	"mon": "mon", "tue": "tue", "wed": "wed", "thu": "thu", "fri": "fri", "sat": "sat", "sun": "sun",
+	"monday": "mon", "tuesday": "tue", "wednesday": "wed", "thursday": "thu",
+	"friday": "fri", "saturday": "sat", "sunday": "sun",
+}
+
+// builtinEN is the English baseline every other language overlays. The season
+// name/preposition and ordinal for English are computed (enSeasonName,
+// enSeasonPrep, enOrdinal) rather than tabulated, so unlisted seasons still
+// read correctly; a language file supplies Seasons/SeasonPrep/Ordinals to
+// override them.
+var builtinEN = Table{
+	Weekdays: map[string]string{
+		"mon": "Monday", "tue": "Tuesday", "wed": "Wednesday", "thu": "Thursday",
+		"fri": "Friday", "sat": "Saturday", "sun": "Sunday",
+	},
+	NamedDays: map[string]string{
+		"triduum-thu": "Holy Thursday", "triduum-fri": "Good Friday", "triduum-sat": "Holy Saturday",
+		"maundy-thursday": "Holy Thursday", "good-friday": "Good Friday", "holy-saturday": "Holy Saturday",
+		"palm-sunday": "Palm Sunday", "passion-sunday": "Passion Sunday", "low-sunday": "Second Sunday of Easter",
+		"trinity-sunday": "The Most Holy Trinity", "trinity": "Trinity Sunday",
+		"corpus-christi": "The Body and Blood of Christ", "sacred-heart": "The Most Sacred Heart of Jesus",
+		"christ-the-king": "Our Lord Jesus Christ, King of the Universe",
+		"easter-sunday":   "Easter Sunday", "pentecost": "Pentecost Sunday", "ascension": "The Ascension of the Lord",
+		"holy-family": "The Holy Family of Jesus, Mary and Joseph", "baptism-of-the-lord": "The Baptism of the Lord",
+		"epiphany": "The Epiphany of the Lord", "christmas": "The Nativity of the Lord", "nativity": "The Nativity of the Lord",
+		"circumcision": "The Circumcision of the Lord", "ash-wednesday": "Ash Wednesday",
+		"ascension-vigil": "Vigil of the Ascension", "pentecost-vigil": "Vigil of Pentecost",
+		"christmas-sunday-sun":                   "Second Sunday after the Nativity",
+		"mary-mother-of-god-octave-of-christmas": "Mary, the Holy Mother of God",
+	},
+	Months: []string{"January", "February", "March", "April", "May", "June",
+		"July", "August", "September", "October", "November", "December"},
+	Templates: map[string]string{
+		"sunday":          "{ord} Sunday {prep} {season}",
+		"weekday":         "{wd} of the {ord} Week {prep} {season}",
+		"weekday_no_week": "{wd} {prep} {season}",
+		"octave_easter":   "{wd} in the Octave of Easter",
+		"after_ashes":     "{wd} after Ash Wednesday",
+		"holy_week":       "{wd} of Holy Week",
+		"after_epiphany":  "{wd} after the Epiphany",
+		"ember":           "Ember {wd} of {season}",
+		"passion_week":    "{wd} of Passion Week",
+		"date":            "{month} {day}",
+	},
+	Seasons:    map[string]string{},
+	SeasonPrep: map[string]string{},
+	Ordinals:   map[string]string{},
+}
+
+// ---- table resolution + caching ---------------------------------------------
+
+var (
+	tblMu    sync.Mutex
+	tblCache = map[string]Table{}
+	userDir  string
+)
+
+// SetUserDir points naming at the drop-in dir holding user language files
+// (<dir>/<code>.ini) and invalidates the cache. Empty string disables it.
+func SetUserDir(dir string) {
+	tblMu.Lock()
+	userDir = dir
+	tblCache = map[string]Table{}
+	tblMu.Unlock()
+}
+
+// tableFor returns the merged table for lang: the English baseline, overlaid by
+// the embedded lang/<code>.ini (if lectio ships one), overlaid by the user's
+// <dir>/<code>.ini (if present).
+func tableFor(lang string) Table {
+	tblMu.Lock()
+	defer tblMu.Unlock()
+	if t, ok := tblCache[lang]; ok {
+		return t
+	}
+	t := builtinEN.clone()
+	if lang != "" && lang != "en" {
+		if data, err := langFS.ReadFile("lang/" + lang + ".ini"); err == nil {
+			t.overlay(parseTable(data))
+		}
+	}
+	if userDir != "" && lang != "" {
+		if data, err := os.ReadFile(filepath.Join(userDir, lang+".ini")); err == nil {
+			t.overlay(parseTable(data))
+		}
+	}
+	tblCache[lang] = t
+	return t
+}
+
+func (t Table) clone() Table {
+	c := Table{
+		Weekdays: cloneMap(t.Weekdays), NamedDays: cloneMap(t.NamedDays),
+		Seasons: cloneMap(t.Seasons), SeasonPrep: cloneMap(t.SeasonPrep),
+		Templates: cloneMap(t.Templates), Ordinals: cloneMap(t.Ordinals),
+		OrdinalFmt: t.OrdinalFmt,
+	}
+	c.Months = append([]string(nil), t.Months...)
+	return c
+}
+
+// overlay copies o's non-empty entries onto t (per key), so a partial language
+// file overrides only the strings it provides.
+func (t *Table) overlay(o Table) {
+	mergeMap(t.Weekdays, o.Weekdays)
+	mergeMap(t.NamedDays, o.NamedDays)
+	mergeMap(t.Seasons, o.Seasons)
+	mergeMap(t.SeasonPrep, o.SeasonPrep)
+	mergeMap(t.Templates, o.Templates)
+	mergeMap(t.Ordinals, o.Ordinals)
+	if o.OrdinalFmt != "" {
+		t.OrdinalFmt = o.OrdinalFmt
+	}
+	for i, m := range o.Months {
+		if m != "" && i < len(t.Months) {
+			t.Months[i] = m
+		}
+	}
+}
+
+func cloneMap(m map[string]string) map[string]string {
+	c := make(map[string]string, len(m))
+	for k, v := range m {
+		c[k] = v
+	}
+	return c
+}
+
+// mergeMap copies every entry of src over dst, including empty values: an empty
+// override is respected where it is meaningful (a season_prep a language leaves
+// blank because it joins by grammatical case) and harmless elsewhere, since the
+// getters fall back to English when a looked-up string is empty.
+func mergeMap(dst, src map[string]string) {
+	for k, v := range src {
+		dst[k] = v
+	}
+}
+
+// ---- public API -------------------------------------------------------------
+
+// DayName renders a temporal day slug as a proper name in lang, e.g.
+// DayName("ordinary-sunday-11", "en") == "11th Sunday in Ordinary Time".
+func DayName(slug, lang string) string {
+	return tableFor(lang).day(slug)
+}
+
+// CelebrationName is a celebration's display name in lang: its own name.<lang>
+// if present, else name.en, else name.la, else the humanized temporal slug.
+// Returns "" only for an unnamed celebration with an empty slug (the caller
+// decides how to render a bare feria).
+func CelebrationName(lang string, c calendar.Celebration) string {
+	if lang != "" {
+		if n := c.Name[lang]; n != "" {
+			return n
+		}
+	}
+	if n := c.Name["en"]; n != "" {
+		return n
+	}
+	if n := c.Name["la"]; n != "" {
+		return n
+	}
+	if c.Slug == "" {
+		return ""
+	}
+	return DayName(c.Slug, lang)
+}
+
+// ---- composition ------------------------------------------------------------
+
+func (t Table) day(slug string) string {
+	s := strings.TrimPrefix(slug, "ef-")
+	if n, ok := t.NamedDays[s]; ok {
+		return n
+	}
+	if m := reSeasonSun.FindStringSubmatch(s); m != nil {
+		return t.render("sunday", map[string]string{
+			"ord": t.ordinal(atoi(m[2])), "prep": t.prep(m[1]), "season": t.season(m[1]),
+		})
+	}
+	if m := reOctave.FindStringSubmatch(s); m != nil {
+		return t.render("octave_easter", map[string]string{"wd": t.weekday(m[1])})
+	}
+	if m := reAfterAsh.FindStringSubmatch(s); m != nil {
+		if weekdayAbbrev[m[1]] == "wed" {
+			return t.NamedDays["ash-wednesday"] // the day the ferias hang off of
+		}
+		return t.render("after_ashes", map[string]string{"wd": t.weekday(m[1])})
+	}
+	if m := reHolyWeek.FindStringSubmatch(s); m != nil {
+		return t.render("holy_week", map[string]string{"wd": t.weekday(m[1])})
+	}
+	if m := reAdventDec.FindStringSubmatch(s); m != nil {
+		return t.render("date", map[string]string{"month": t.month(12), "day": m[1]})
+	}
+	if m := reXmasDate.FindStringSubmatch(s); m != nil {
+		mon := 12
+		if m[1] == "jan" {
+			mon = 1
+		}
+		return t.render("date", map[string]string{"month": t.month(mon), "day": m[2]})
+	}
+	if m := reAftEpiph.FindStringSubmatch(s); m != nil {
+		return t.render("after_epiphany", map[string]string{"wd": t.weekday(m[1])})
+	}
+	if m := reEmber.FindStringSubmatch(s); m != nil {
+		return t.render("ember", map[string]string{"wd": t.weekday(m[2]), "season": t.season(m[1])})
+	}
+	if m := reWeekday.FindStringSubmatch(s); m != nil {
+		if _, ok := weekdayAbbrev[m[3]]; ok {
+			n := atoi(m[2])
+			if n == 0 { // Passiontide's pre-Palm-Sunday week carries no number
+				if m[1] == "passiontide" {
+					return t.render("passion_week", map[string]string{"wd": t.weekday(m[3])})
+				}
+				return t.render("weekday_no_week", map[string]string{
+					"wd": t.weekday(m[3]), "prep": t.prep(m[1]), "season": t.season(m[1]),
+				})
+			}
+			return t.render("weekday", map[string]string{
+				"wd": t.weekday(m[3]), "ord": t.ordinal(n), "prep": t.prep(m[1]), "season": t.season(m[1]),
+			})
+		}
+	}
+	return titleCase(strings.ReplaceAll(s, "-", " "))
+}
+
+// render fills a template's {tokens}, drops any left unfilled, and collapses
+// whitespace -- so a language with an empty preposition (case-joined seasons)
+// never leaves a double space.
+func (t Table) render(id string, vars map[string]string) string {
+	f := t.Templates[id]
+	if f == "" {
+		f = builtinEN.Templates[id]
+	}
+	for k, v := range vars {
+		f = strings.ReplaceAll(f, "{"+k+"}", v)
+	}
+	f = rePlacehold.ReplaceAllString(f, "")
+	return strings.Join(strings.Fields(f), " ")
+}
+
+func (t Table) weekday(tok string) string {
+	if ab, ok := weekdayAbbrev[tok]; ok {
+		if name := t.Weekdays[ab]; name != "" {
+			return name
+		}
+	}
+	return titleCase(tok)
+}
+
+func (t Table) month(n int) string {
+	if n >= 1 && n <= len(t.Months) && t.Months[n-1] != "" {
+		return t.Months[n-1]
+	}
+	return builtinEN.Months[n-1]
+}
+
+func (t Table) ordinal(n int) string {
+	if s, ok := t.Ordinals[strconv.Itoa(n)]; ok {
+		return s
+	}
+	if t.OrdinalFmt != "" {
+		return fmt.Sprintf(t.OrdinalFmt, n)
+	}
+	return enOrdinal(n)
+}
+
+func (t Table) season(slug string) string {
+	if s, ok := t.Seasons[slug]; ok {
+		return s
+	}
+	return enSeasonName(slug)
+}
+
+func (t Table) prep(slug string) string {
+	if p, ok := t.SeasonPrep[slug]; ok {
+		return p // may be intentionally empty
+	}
+	return enSeasonPrep(slug)
+}
+
+// ---- English fallbacks (match the historical HumanizeSlug behaviour) ---------
+
+func enSeasonName(slug string) string {
+	if slug == "ordinary" {
+		return "Ordinary Time"
+	}
+	if rest := strings.TrimPrefix(slug, "time-after-"); rest != slug {
+		return titleCase(rest)
+	}
+	return titleCase(strings.ReplaceAll(slug, "-", " "))
+}
+
+func enSeasonPrep(slug string) string {
+	if slug == "ordinary" {
+		return "in"
+	}
+	if strings.HasPrefix(slug, "time-after-") {
+		return "after"
+	}
+	return "of"
+}
+
+func enOrdinal(n int) string {
+	s := strconv.Itoa(n)
+	if n%100 >= 11 && n%100 <= 13 {
+		return s + "th"
+	}
+	switch n % 10 {
+	case 1:
+		return s + "st"
+	case 2:
+		return s + "nd"
+	case 3:
+		return s + "rd"
+	}
+	return s + "th"
+}
+
+func titleCase(s string) string {
+	small := map[string]bool{"of": true, "the": true, "in": true, "after": true, "before": true}
+	words := strings.Fields(s)
+	for i, w := range words {
+		if i > 0 && small[w] {
+			continue
+		}
+		if w != "" {
+			words[i] = strings.ToUpper(w[:1]) + w[1:]
+		}
+	}
+	return strings.Join(words, " ")
+}
+
+func atoi(s string) int { n, _ := strconv.Atoi(s); return n }
+
+// ---- language-file parsing --------------------------------------------------
+
+// parseTable reads a language INI into a (partial) Table. Sections:
+//
+//	[templates]   id = format
+//	[weekdays]    mon..sun = name
+//	[months]      1..12 = name
+//	[seasons]     <season slug> = name
+//	[season_prep] <season slug> = preposition (may be empty)
+//	[named]       <temporal slug> = name
+//	[ordinal]     format = %d.   |   1 = 1st, 2 = 2nd, ...
+func parseTable(data []byte) Table {
+	t := Table{
+		Weekdays: map[string]string{}, NamedDays: map[string]string{},
+		Seasons: map[string]string{}, SeasonPrep: map[string]string{},
+		Templates: map[string]string{}, Ordinals: map[string]string{},
+		Months: make([]string, 12),
+	}
+	secs, err := ini.Parse(data)
+	if err != nil {
+		return t
+	}
+	for _, s := range secs {
+		for _, p := range s.Pairs {
+			switch s.Name {
+			case "templates":
+				t.Templates[p.Key] = p.Val
+			case "weekdays":
+				if ab, ok := weekdayAbbrev[p.Key]; ok {
+					t.Weekdays[ab] = p.Val
+				}
+			case "months":
+				if i := atoi(p.Key); i >= 1 && i <= 12 {
+					t.Months[i-1] = p.Val
+				}
+			case "seasons":
+				t.Seasons[p.Key] = p.Val
+			case "season_prep":
+				t.SeasonPrep[p.Key] = p.Val
+			case "named":
+				t.NamedDays[p.Key] = p.Val
+			case "ordinal":
+				if p.Key == "format" {
+					t.OrdinalFmt = p.Val
+				} else {
+					t.Ordinals[p.Key] = p.Val
+				}
+			}
+		}
+	}
+	return t
+}