feat: load site.json and the language files

This commit is contained in:
tgiachi 2026-11-15 09:44:01 +01:00
commit 97af0c422d
2 changed files with 267 additions and 0 deletions

131
internal/site/site.go Normal file
View file

@ -0,0 +1,131 @@
// SPDX-License-Identifier: GPL-3.0-or-later
// Package site loads the configuration of a site: site.json and the language
// files in lang/.
package site
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
)
// Config is the content of site.json.
type Config struct {
// Strings holds every string value of site.json, plus the derived
// contact_shown, security_shown and abuse_shown.
Strings map[string]string
// Languages lists the language codes; the first one is the default and
// lives at the root of the site.
Languages []string
// Assets maps the published name of a file to its source in the site
// directory; the files are copied as they are.
Assets map[string]string
}
// Lang is the content of lang/<code>.json: the strings of one language.
type Lang struct {
// Code is the language code, such as "en".
Code string
// Strings holds every string value of the file.
Strings map[string]string
// Nav maps a menu entry to its label in this language.
Nav map[string]string
}
// shownKeys are the address keys that get a harvest-proof "_shown" twin.
var shownKeys = []string{"contact", "security", "abuse"}
// Load reads site.json and the language file of every language it lists. All
// paths in error messages are relative to dir.
func Load(dir string) (Config, map[string]Lang, error) {
raw, err := readObject(dir, "site.json")
if err != nil {
return Config{}, nil, err
}
cfg := Config{Strings: stringValues(raw), Assets: map[string]string{}}
if err := decodeField(raw, "site.json", "languages", &cfg.Languages); err != nil {
return Config{}, nil, err
}
if len(cfg.Languages) == 0 {
return Config{}, nil, fmt.Errorf("site.json: languages is empty")
}
if err := decodeField(raw, "site.json", "assets", &cfg.Assets); err != nil {
return Config{}, nil, err
}
for _, key := range shownKeys {
if value, ok := cfg.Strings[key]; ok {
cfg.Strings[key+"_shown"] = strings.ReplaceAll(value, "@", " (at) ")
}
}
langs := make(map[string]Lang, len(cfg.Languages))
for _, code := range cfg.Languages {
lang, err := loadLang(dir, code)
if err != nil {
return Config{}, nil, err
}
langs[code] = lang
}
return cfg, langs, nil
}
// loadLang reads lang/<code>.json and checks the keys every language needs.
func loadLang(dir, code string) (Lang, error) {
name := filepath.ToSlash(filepath.Join("lang", code+".json"))
raw, err := readObject(dir, name)
if err != nil {
return Lang{}, err
}
lang := Lang{Code: code, Strings: stringValues(raw), Nav: map[string]string{}}
if lang.Strings["lang_name"] == "" {
return Lang{}, fmt.Errorf("%s: missing lang_name", name)
}
if _, ok := raw["nav"]; !ok {
return Lang{}, fmt.Errorf("%s: missing nav", name)
}
if err := decodeField(raw, name, "nav", &lang.Nav); err != nil {
return Lang{}, err
}
return lang, nil
}
// readObject reads a JSON file that holds one object and returns its fields
// undecoded. Errors name the file.
func readObject(dir, name string) (map[string]json.RawMessage, error) {
data, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(name)))
if err != nil {
return nil, fmt.Errorf("read %s: %w", name, err)
}
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, fmt.Errorf("%s: %w", name, err)
}
return raw, nil
}
// stringValues returns the fields of raw whose value is a JSON string.
func stringValues(raw map[string]json.RawMessage) map[string]string {
out := make(map[string]string)
for key, value := range raw {
var s string
if json.Unmarshal(value, &s) == nil {
out[key] = s
}
}
return out
}
// decodeField decodes raw[key] into target when the field exists.
func decodeField(raw map[string]json.RawMessage, name, key string, target any) error {
value, ok := raw[key]
if !ok {
return nil
}
if err := json.Unmarshal(value, target); err != nil {
return fmt.Errorf("%s: %s: %w", name, key, err)
}
return nil
}

136
internal/site/site_test.go Normal file
View file

@ -0,0 +1,136 @@
// SPDX-License-Identifier: GPL-3.0-or-later
package site
import (
"os"
"path/filepath"
"strings"
"testing"
)
// writeSite writes files (path relative to a new directory, then content) and
// returns the directory.
func writeSite(t *testing.T, files map[string]string) string {
t.Helper()
dir := t.TempDir()
for name, content := range files {
path := filepath.Join(dir, name)
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
}
return dir
}
// validFiles is a small complete site configuration.
func validFiles() map[string]string {
return map[string]string{
"site.json": `{
"base_url": "https://kmalloc.org",
"languages": ["en", "it"],
"contact": "squid@kmalloc.org",
"security": "security@kmalloc.org",
"abuse": "abuse@kmalloc.org",
"assets": {"favicon.svg": "logo/svg/favicon-auto.svg", "squid.asc": "static/squid.asc"},
"services": [{"id": "ignored"}]
}`,
"lang/en.json": `{"lang_name": "English", "nojs": "No JavaScript.", "nav": {"news": "News"}}`,
"lang/it.json": `{"lang_name": "Italiano", "nojs": "Niente JavaScript.", "nav": {"news": "Novità"}}`,
}
}
// TestLoadDerivesShownAddresses checks that addresses get a harvest-proof twin.
func TestLoadDerivesShownAddresses(t *testing.T) {
cfg, langs, err := Load(writeSite(t, validFiles()))
if err != nil {
t.Fatalf("Load() error = %v", err)
}
want := map[string]string{
"contact_shown": "squid (at) kmalloc.org",
"security_shown": "security (at) kmalloc.org",
"abuse_shown": "abuse (at) kmalloc.org",
"base_url": "https://kmalloc.org",
}
for k, v := range want {
if got := cfg.Strings[k]; got != v {
t.Errorf("Strings[%q] = %q, want %q", k, got, v)
}
}
if len(cfg.Languages) != 2 || cfg.Languages[0] != "en" || cfg.Languages[1] != "it" {
t.Errorf("Languages = %v, want [en it]", cfg.Languages)
}
if got := langs["it"].Nav["news"]; got != "Novità" {
t.Errorf("it nav news = %q, want %q", got, "Novità")
}
if got := langs["en"].Strings["nojs"]; got != "No JavaScript." {
t.Errorf("en nojs = %q", got)
}
if got := langs["en"].Code; got != "en" {
t.Errorf("en Code = %q", got)
}
}
// TestLoadAssets checks the published-name to source map.
func TestLoadAssets(t *testing.T) {
cfg, _, err := Load(writeSite(t, validFiles()))
if err != nil {
t.Fatal(err)
}
if got := cfg.Assets["squid.asc"]; got != "static/squid.asc" {
t.Errorf("Assets[squid.asc] = %q", got)
}
if len(cfg.Assets) != 2 {
t.Errorf("len(Assets) = %d, want 2", len(cfg.Assets))
}
}
// TestLoadUnknownLanguageFile checks that a listed language needs its file.
func TestLoadUnknownLanguageFile(t *testing.T) {
files := validFiles()
delete(files, "lang/it.json")
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "lang/it.json") {
t.Errorf("Load() error = %v, want it to name lang/it.json", err)
}
}
// TestLoadBadJSON checks that a JSON error names the file.
func TestLoadBadJSON(t *testing.T) {
files := validFiles()
files["lang/en.json"] = `{"lang_name": `
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "lang/en.json") {
t.Errorf("Load() error = %v, want it to name lang/en.json", err)
}
}
// TestLoadLanguageNeedsNameAndNav checks the keys every language must have.
func TestLoadLanguageNeedsNameAndNav(t *testing.T) {
for _, tt := range []struct{ name, body, want string }{
{"no name", `{"nav": {}}`, "lang_name"},
{"no nav", `{"lang_name": "English"}`, "nav"},
} {
t.Run(tt.name, func(t *testing.T) {
files := validFiles()
files["lang/en.json"] = tt.body
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), tt.want) || !strings.Contains(err.Error(), "lang/en.json") {
t.Errorf("Load() error = %v, want it to name lang/en.json and %s", err, tt.want)
}
})
}
}
// TestLoadNeedsLanguages checks that an empty language list is an error.
func TestLoadNeedsLanguages(t *testing.T) {
files := validFiles()
files["site.json"] = `{"base_url": "https://kmalloc.org", "languages": []}`
_, _, err := Load(writeSite(t, files))
if err == nil || !strings.Contains(err.Error(), "languages") {
t.Errorf("Load() error = %v, want it to mention languages", err)
}
}