From 97af0c422d20d0540457f78aac922543466481af Mon Sep 17 00:00:00 2001 From: tgiachi Date: Sun, 15 Nov 2026 09:44:01 +0100 Subject: [PATCH] feat: load site.json and the language files --- internal/site/site.go | 131 +++++++++++++++++++++++++++++++++++ internal/site/site_test.go | 136 +++++++++++++++++++++++++++++++++++++ 2 files changed, 267 insertions(+) create mode 100644 internal/site/site.go create mode 100644 internal/site/site_test.go diff --git a/internal/site/site.go b/internal/site/site.go new file mode 100644 index 0000000..419d9e8 --- /dev/null +++ b/internal/site/site.go @@ -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/.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/.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 +} diff --git a/internal/site/site_test.go b/internal/site/site_test.go new file mode 100644 index 0000000..215a4e6 --- /dev/null +++ b/internal/site/site_test.go @@ -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) + } +}