Rename app to radiantwave: embed and provision assets, drop proclamations

internal/application/application.go

@@ -2,6 +2,7 @@ package application
 
 import (
 	"errors"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"time"
@@ -10,6 +11,7 @@ import (
 	"github.com/veandco/go-sdl2/sdl"
 	"github.com/veandco/go-sdl2/ttf"
 	"gorm.io/gorm"
+	"rhemawavetech.com/rhemawave/internal/assets"
 	"rhemawavetech.com/rhemawave/internal/db"
 	"rhemawavetech.com/rhemawave/internal/download"
 	"rhemawavetech.com/rhemawave/internal/fontManager"
@@ -59,11 +61,16 @@ type Application struct {
 var lastNetworkCheckTime time.Time
 var networkIsUp bool
 
+// DataDirFor returns the per-user data directory for the application.
+func DataDirFor(homeDir string) string {
+	return filepath.Join(homeDir, ".local", "share", "radiantwave")
+}
+
 // ----------------------------------------------------------------------------
 // Main Entry Point
 // ----------------------------------------------------------------------------
 
-func Run() {
+func Run(bundled fs.FS) {
 	var err error
 	var homeDir string
 	var dataDir string
@@ -79,7 +86,7 @@ func Run() {
 		return
 	}
 
-	dataDir = filepath.Join(homeDir, ".local", "share", "rhemawave")
+	dataDir = DataDirFor(homeDir)
 	if err := os.MkdirAll(dataDir, 0755); err != nil {
 		logger.Error("unable to create data directory %s %v", dataDir, err)
 		return
@@ -137,6 +144,16 @@ func Run() {
 
 	logger.AddDatabase(DB)
 
+	// Ensure bundled static assets (fonts, shaders, tos) are present in the
+	// assets directory before any manager tries to load them.
+	config, err := db.GetConfig(DB)
+	if err != nil {
+		panic(err)
+	}
+	if err := assets.Provision(bundled, config.AssetsDir); err != nil {
+		logger.Error("failed to provision bundled assets into %s: %v", config.AssetsDir, err)
+	}
+
 	app := &Application{
 		DB: DB,
 	}

internal/application/application_test.go

@@ -445,6 +445,16 @@ func TestMultipleComputeStateCallsAfterDownloadComplete(t *testing.T) {
 	}
 }
 
+// TestDataDirFor verifies the per-user data directory resolves to the
+// radiantwave path, not the legacy rhemawave name.
+func TestDataDirFor(t *testing.T) {
+	got := DataDirFor("/home/kiosk")
+	want := "/home/kiosk/.local/share/radiantwave"
+	if got != want {
+		t.Errorf("DataDirFor(/home/kiosk) = %q, want %q", got, want)
+	}
+}
+
 func setupTestDB(t *testing.T) *gorm.DB {
 	t.Helper()
 	d, err := db.Connect(":memory:")

internal/assets/assets.go

@@ -0,0 +1,50 @@
+// Package assets provisions the static assets bundled into the binary
+// (fonts, shaders, and terms-of-service pages) into a per-user assets
+// directory at application startup.
+package assets
+
+import (
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+)
+
+// Provision copies every file from the embedded filesystem into destDir,
+// preserving the relative directory structure. Existing files are
+// overwritten so the deployed assets always match the running binary.
+func Provision(bundled fs.FS, destDir string) error {
+	return fs.WalkDir(bundled, ".", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() {
+			return nil
+		}
+
+		src, err := bundled.Open(path)
+		if err != nil {
+			return fmt.Errorf("opening bundled asset %s: %w", path, err)
+		}
+		defer src.Close()
+
+		dst := filepath.Join(destDir, filepath.FromSlash(path))
+		if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+			return fmt.Errorf("creating asset directory for %s: %w", path, err)
+		}
+
+		out, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+		if err != nil {
+			return fmt.Errorf("creating asset file %s: %w", dst, err)
+		}
+		if _, err := io.Copy(out, src); err != nil {
+			out.Close()
+			return fmt.Errorf("writing asset file %s: %w", dst, err)
+		}
+		if err := out.Close(); err != nil {
+			return fmt.Errorf("closing asset file %s: %w", dst, err)
+		}
+		return nil
+	})
+}

internal/assets/assets_test.go

@@ -0,0 +1,65 @@
+package assets
+
+import (
+	"embed"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+//go:embed testdata
+var testFS embed.FS
+
+func TestProvisionCopiesBundledFiles(t *testing.T) {
+	dest := t.TempDir()
+
+	if err := Provision(testFS, dest); err != nil {
+		t.Fatalf("Provision returned error: %v", err)
+	}
+
+	for _, rel := range []string{
+		"testdata/fonts/TestFont.ttf",
+		"testdata/shaders/solid_color.frag",
+		"testdata/shaders/solid_color.vert",
+		"testdata/tos/01 - WELCOME.html",
+	} {
+		got, err := os.ReadFile(filepath.Join(dest, filepath.FromSlash(rel)))
+		if err != nil {
+			t.Errorf("expected %s to be provisioned: %v", rel, err)
+			continue
+		}
+		want, err := testFS.ReadFile(rel)
+		if err != nil {
+			t.Fatalf("reading fixture %s: %v", rel, err)
+		}
+		if string(got) != string(want) {
+			t.Errorf("provisioned %s content mismatch", rel)
+		}
+	}
+}
+
+func TestProvisionOverwritesStaleFiles(t *testing.T) {
+	dest := t.TempDir()
+
+	// Plant a stale shader that differs from the bundled one.
+	stalePath := filepath.Join(dest, "testdata", "shaders", "solid_color.vert")
+	if err := os.MkdirAll(filepath.Dir(stalePath), 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(stalePath, []byte("stale content"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := Provision(testFS, dest); err != nil {
+		t.Fatalf("Provision returned error: %v", err)
+	}
+
+	got, err := os.ReadFile(stalePath)
+	if err != nil {
+		t.Fatalf("reading provisioned file: %v", err)
+	}
+	want, _ := testFS.ReadFile("testdata/shaders/solid_color.vert")
+	if string(got) != string(want) {
+		t.Errorf("stale file was not overwritten: got %q want %q", got, want)
+	}
+}

internal/assets/testdata/fonts/TestFont.ttf

@@ -0,0 +1 @@
+fake-font-bytes

internal/assets/testdata/shaders/solid_color.frag

@@ -0,0 +1 @@
+fake-frag

internal/assets/testdata/shaders/solid_color.vert

@@ -0,0 +1 @@
+fake-vert

internal/assets/testdata/tos/01 - WELCOME.html

@@ -0,0 +1 @@
+<html>welcome</html>

internal/page/licenseKeyPage.go

@@ -202,7 +202,7 @@ func (p *LicenseKeyPage) HandleEvent(event *sdl.Event) error {
 
 				// Write license key to plain text file for the updater
 				if homeDir, err := os.UserHomeDir(); err == nil {
-					keyPath := filepath.Join(homeDir, ".local", "share", "rhemawave", "license_key")
+					keyPath := filepath.Join(homeDir, ".local", "share", "radiantwave", "license_key")
 					if err := os.WriteFile(keyPath, []byte(p.inputText), 0644); err != nil {
 						logger.Error("Failed to write license key file: %v", err)
 					}