docs/plans/2026-09-25-gallery-v1.org

git switch main && git pull && git switch -c v1
go mod init gitbay.org/cmc/gallery

package format

import (
	"io"
	"path/filepath"
	"strings"
	"testing"
)

type fake struct{ name, ext string }

func (f fake) Name() string                      { return f.name }
func (f fake) Match(p string) bool               { return strings.EqualFold(filepath.Ext(p), f.ext) }
func (fake) Metadata(string) (Meta, error)       { return Meta{}, nil }
func (fake) Resize(string, int, io.Writer) error { return nil }
func (fake) Kind() Kind                          { return KindImage }

func TestRegistryFirstMatchWins(t *testing.T) {
	var r Registry
	r.Register(fake{"a", ".jpg"})
	r.Register(fake{"b", ".jpg"})
	r.Register(fake{"c", ".png"})

	if got := r.Lookup("x/IMG.JPG"); got == nil || got.Name() != "a" {
		t.Fatalf("jpg: got %v, want a", got)
	}
	if got := r.Lookup("x.png"); got == nil || got.Name() != "c" {
		t.Fatalf("png: got %v, want c", got)
	}
	if got := r.Lookup("notes.txt"); got != nil {
		t.Fatalf("txt: got %v, want nil", got)
	}
}

func TestHasExt(t *testing.T) {
	exts := []string{".jpg", ".jpeg"}
	for p, want := range map[string]bool{
		"a.jpg": true, "a.JPEG": true, "a.png": false, "jpg": false, "a.jpg.txt": false,
	} {
		if got := hasExt(p, exts); got != want {
			t.Errorf("hasExt(%q) = %v, want %v", p, got, want)
		}
	}
}

// Package format describes the file types the gallery can show.
package format

import (
	"io"
	"path/filepath"
	"strings"
	"time"
)

type Kind int

const (
	KindImage Kind = iota
)

// Meta holds display metadata. Width and Height are after EXIF orientation.
type Meta struct {
	Width, Height int
	Taken         time.Time
	Camera, Lens  string
	Aperture      string
	Shutter       string
	ISO           int
}

type Format interface {
	Name() string
	Match(path string) bool
	Metadata(path string) (Meta, error)
	Resize(src string, width int, dst io.Writer) error
	Kind() Kind
}

// Registry resolves a path to the first registered Format that matches it.
type Registry struct {
	formats []Format
}

func (r *Registry) Register(f Format) {
	r.formats = append(r.formats, f)
}

func (r *Registry) Lookup(path string) Format {
	for _, f := range r.formats {
		if f.Match(path) {
			return f
		}
	}
	return nil
}

func hasExt(path string, exts []string) bool {
	ext := strings.ToLower(filepath.Ext(path))
	for _, e := range exts {
		if ext == e {
			return true
		}
	}
	return false
}

git add .gitignore go.mod internal/format
git commit -m "Add format registry"

package format

import (
	"testing"
	"time"
)

func TestParseExifFull(t *testing.T) {
	data := []byte(`[{
		"SourceFile": "a.jpg",
		"ImageWidth": 6240, "ImageHeight": 4160, "Orientation": 1,
		"DateTimeOriginal": "2025:03:14 23:10:05",
		"Make": "FUJIFILM", "Model": "X-T5", "LensModel": "XF23mmF2 R WR",
		"FNumber": 2, "ExposureTime": 0.008, "ISO": 1600
	}]`)
	m, err := parseExif(data)
	if err != nil {
		t.Fatal(err)
	}
	want := Meta{
		Width: 6240, Height: 4160,
		Taken:    time.Date(2025, 3, 14, 23, 10, 5, 0, time.UTC),
		Camera:   "FUJIFILM X-T5",
		Lens:     "XF23mmF2 R WR",
		Aperture: "f/2",
		Shutter:  "1/125",
		ISO:      1600,
	}
	if m != want {
		t.Fatalf("got %+v\nwant %+v", m, want)
	}
}

func TestParseExifRotatedSwapsDimensions(t *testing.T) {
	for _, o := range []string{"5", "6", "7", "8"} {
		m, err := parseExif([]byte(`[{"ImageWidth": 300, "ImageHeight": 200, "Orientation": ` + o + `}]`))
		if err != nil {
			t.Fatal(err)
		}
		if m.Width != 200 || m.Height != 300 {
			t.Errorf("orientation %s: got %dx%d, want 200x300", o, m.Width, m.Height)
		}
	}
}

func TestParseExifFallbacks(t *testing.T) {
	m, err := parseExif([]byte(`[{
		"ImageWidth": 10, "ImageHeight": 10,
		"CreateDate": "2024:01:02 03:04:05+01:00",
		"Make": "Canon", "Model": "Canon EOS R6",
		"FNumber": 5.6, "ExposureTime": 2
	}]`))
	if err != nil {
		t.Fatal(err)
	}
	if want := time.Date(2024, 1, 2, 3, 4, 5, 0, time.UTC); !m.Taken.Equal(want) {
		t.Errorf("Taken = %v, want %v", m.Taken, want)
	}
	if m.Camera != "Canon EOS R6" {
		t.Errorf("Camera = %q", m.Camera)
	}
	if m.Aperture != "f/5.6" || m.Shutter != "2s" {
		t.Errorf("Aperture %q Shutter %q", m.Aperture, m.Shutter)
	}
}

func TestParseExifMinimal(t *testing.T) {
	m, err := parseExif([]byte(`[{"ImageWidth": 120, "ImageHeight": 80}]`))
	if err != nil {
		t.Fatal(err)
	}
	if (m != Meta{Width: 120, Height: 80}) {
		t.Fatalf("got %+v", m)
	}
}

func TestParseExifErrors(t *testing.T) {
	for _, in := range []string{`not json`, `[]`, `[{}, {}]`, `[{"ImageWidth": 10}]`} {
		if _, err := parseExif([]byte(in)); err == nil {
			t.Errorf("%s: want error", in)
		}
	}
}

package format

import (
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"strconv"
	"strings"
	"time"
)

type exifRecord struct {
	ImageWidth       int
	ImageHeight      int
	Orientation      int
	DateTimeOriginal string
	CreateDate       string
	Make             string
	Model            string
	LensModel        string
	FNumber          float64
	ExposureTime     float64
	ISO              int
}

// parseExif reads `exiftool -json -n` output for a single file.
func parseExif(data []byte) (Meta, error) {
	var recs []exifRecord
	if err := json.Unmarshal(data, &recs); err != nil {
		return Meta{}, fmt.Errorf("exiftool output: %w", err)
	}
	if len(recs) != 1 {
		return Meta{}, fmt.Errorf("exiftool output: %d records, want 1", len(recs))
	}
	e := recs[0]
	if e.ImageWidth == 0 || e.ImageHeight == 0 {
		return Meta{}, errors.New("exiftool output: no image dimensions")
	}
	m := Meta{Width: e.ImageWidth, Height: e.ImageHeight, Lens: e.LensModel, ISO: e.ISO}
	if e.Orientation >= 5 && e.Orientation <= 8 {
		m.Width, m.Height = m.Height, m.Width
	}
	m.Taken = exifTime(e.DateTimeOriginal)
	if m.Taken.IsZero() {
		m.Taken = exifTime(e.CreateDate)
	}
	m.Camera = camera(e.Make, e.Model)
	if e.FNumber > 0 {
		m.Aperture = "f/" + strconv.FormatFloat(e.FNumber, 'f', -1, 64)
	}
	m.Shutter = shutter(e.ExposureTime)
	return m, nil
}

// exifTime parses "YYYY:MM:DD HH:MM:SS", ignoring any trailing subseconds or zone.
func exifTime(s string) time.Time {
	if len(s) < 19 {
		return time.Time{}
	}
	t, err := time.Parse("2006:01:02 15:04:05", s[:19])
	if err != nil {
		return time.Time{}
	}
	return t
}

func camera(maker, model string) string {
	maker, model = strings.TrimSpace(maker), strings.TrimSpace(model)
	if maker == "" {
		return model
	}
	if model == "" {
		return maker
	}
	brand := strings.ToLower(strings.Fields(maker)[0])
	if strings.Contains(strings.ToLower(model), brand) {
		return model
	}
	return maker + " " + model
}

func shutter(sec float64) string {
	switch {
	case sec <= 0:
		return ""
	case sec >= 1:
		return strconv.FormatFloat(sec, 'f', -1, 64) + "s"
	default:
		return "1/" + strconv.Itoa(int(math.Round(1/sec)))
	}
}

git add internal/format
git commit -m "Parse exiftool metadata"

package format

import (
	"bytes"
	"fmt"
	"image/jpeg"
	"os/exec"
	"path/filepath"
	"testing"
	"time"
)

func requireTools(t *testing.T) {
	t.Helper()
	if err := CheckTools(); err != nil {
		t.Skip(err)
	}
}

func makeImage(t *testing.T, name string, w, h int) string {
	t.Helper()
	p := filepath.Join(t.TempDir(), name)
	run(t, "magick", "-size", fmt.Sprintf("%dx%d", w, h), "xc:gray", p)
	return p
}

func run(t *testing.T, name string, args ...string) {
	t.Helper()
	if out, err := exec.Command(name, args...).CombinedOutput(); err != nil {
		t.Fatalf("%s %v: %v\n%s", name, args, err, out)
	}
}

func resizedSize(t *testing.T, f Format, src string, w int) (int, int) {
	t.Helper()
	var buf bytes.Buffer
	if err := f.Resize(src, w, &buf); err != nil {
		t.Fatal(err)
	}
	cfg, err := jpeg.DecodeConfig(&buf)
	if err != nil {
		t.Fatalf("output is not JPEG: %v", err)
	}
	return cfg.Width, cfg.Height
}

func TestMagickJPEG(t *testing.T) {
	requireTools(t)
	p := makeImage(t, "a.jpg", 300, 200)
	run(t, "exiftool", "-overwrite_original", "-DateTimeOriginal=2025:03:14 23:10:05", "-Model=TestCam", p)

	f := NewMagick("jpeg", ".jpg", ".jpeg")
	m, err := f.Metadata(p)
	if err != nil {
		t.Fatal(err)
	}
	if m.Width != 300 || m.Height != 200 || m.Camera != "TestCam" {
		t.Fatalf("got %+v", m)
	}
	if want := time.Date(2025, 3, 14, 23, 10, 5, 0, time.UTC); !m.Taken.Equal(want) {
		t.Fatalf("Taken = %v", m.Taken)
	}
	if w, h := resizedSize(t, f, p, 150); w != 150 || h != 100 {
		t.Fatalf("resized to %dx%d, want 150x100", w, h)
	}
}

func TestMagickOrientation(t *testing.T) {
	requireTools(t)
	p := makeImage(t, "r.jpg", 300, 200)
	run(t, "exiftool", "-overwrite_original", "-n", "-Orientation=6", p)

	f := NewMagick("jpeg", ".jpg")
	m, err := f.Metadata(p)
	if err != nil {
		t.Fatal(err)
	}
	if m.Width != 200 || m.Height != 300 {
		t.Fatalf("metadata %dx%d, want 200x300", m.Width, m.Height)
	}
	if w, h := resizedSize(t, f, p, 100); w != 100 || h != 150 {
		t.Fatalf("resized to %dx%d, want 100x150", w, h)
	}
}

func TestMagickPNG(t *testing.T) {
	requireTools(t)
	p := makeImage(t, "a.png", 120, 80)
	f := NewMagick("png", ".png")
	m, err := f.Metadata(p)
	if err != nil {
		t.Fatal(err)
	}
	if m.Width != 120 || m.Height != 80 {
		t.Fatalf("got %+v", m)
	}
	if w, h := resizedSize(t, f, p, 60); w != 60 || h != 40 {
		t.Fatalf("resized to %dx%d, want 60x40", w, h)
	}
}

func TestMagickResizeError(t *testing.T) {
	requireTools(t)
	var buf bytes.Buffer
	if err := NewMagick("jpeg", ".jpg").Resize(filepath.Join(t.TempDir(), "missing.jpg"), 100, &buf); err == nil {
		t.Fatal("want error")
	}
}

func TestDefaultRegistry(t *testing.T) {
	r := Default()
	for path, want := range map[string]string{"a.JPG": "jpeg", "a.jpeg": "jpeg", "a.png": "png"} {
		if f := r.Lookup(path); f == nil || f.Name() != want {
			t.Errorf("%s: got %v, want %s", path, f, want)
		}
	}
	if r.Lookup("a.heic") != nil {
		t.Error("heic should not match in v1")
	}
}

package format

import (
	"bytes"
	"fmt"
	"io"
	"os/exec"
	"strconv"
	"strings"
)

// Magick reads metadata with exiftool and resizes with ImageMagick.
type Magick struct {
	name string
	exts []string
}

func NewMagick(name string, exts ...string) *Magick {
	return &Magick{name: name, exts: exts}
}

func (m *Magick) Name() string          { return m.name }
func (m *Magick) Match(path string) bool { return hasExt(path, m.exts) }
func (m *Magick) Kind() Kind             { return KindImage }

func (m *Magick) Metadata(path string) (Meta, error) {
	out, err := exec.Command("exiftool", "-json", "-n",
		"-ImageWidth", "-ImageHeight", "-Orientation",
		"-DateTimeOriginal", "-CreateDate",
		"-Make", "-Model", "-LensModel",
		"-FNumber", "-ExposureTime", "-ISO",
		path).Output()
	if err != nil {
		return Meta{}, fmt.Errorf("exiftool %s: %w", path, err)
	}
	return parseExif(out)
}

func (m *Magick) Resize(src string, width int, dst io.Writer) error {
	cmd := exec.Command("magick", src,
		"-auto-orient", "-resize", strconv.Itoa(width)+"x",
		"-strip", "-quality", "82", "jpg:-")
	var stderr bytes.Buffer
	cmd.Stdout = dst
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("magick %s: %w: %s", src, err, strings.TrimSpace(stderr.String()))
	}
	return nil
}

// Default returns the formats supported in v1.
func Default() *Registry {
	r := &Registry{}
	r.Register(NewMagick("jpeg", ".jpg", ".jpeg"))
	r.Register(NewMagick("png", ".png"))
	return r
}

// CheckTools reports the first required external tool missing from PATH.
func CheckTools() error {
	for _, tool := range []string{"magick", "exiftool"} {
		if _, err := exec.LookPath(tool); err != nil {
			return fmt.Errorf("%s not found on PATH", tool)
		}
	}
	return nil
}

git add internal/format
git commit -m "Add ImageMagick-backed JPEG and PNG formats"

go get github.com/niklasfasching/go-org@latest

package library

import (
	"strings"
	"testing"
)

func TestParseOrg(t *testing.T) {
	src := "#+title: Tokyo: nights\n#+COVER: a.jpg\n\n#+begin_quote\nA /quiet/ week.\n#+end_quote\n"
	kw, html, err := parseOrg([]byte(src), "album.org")
	if err != nil {
		t.Fatal(err)
	}
	if len(kw) != 2 || kw["title"] != "Tokyo: nights" || kw["cover"] != "a.jpg" {
		t.Fatalf("keywords = %v", kw)
	}
	for _, want := range []string{"<blockquote>", "<em>quiet</em>"} {
		if !strings.Contains(string(html), want) {
			t.Errorf("html missing %q:\n%s", want, html)
		}
	}
}

func TestParseOrgKeywordsOnly(t *testing.T) {
	kw, html, err := parseOrg([]byte("#+title: x\n\n"), "album.org")
	if err != nil {
		t.Fatal(err)
	}
	if kw["title"] != "x" || html != "" {
		t.Fatalf("kw=%v html=%q", kw, html)
	}
}

package library

import (
	"html/template"
	"strings"

	"github.com/niklasfasching/go-org/org"
)

// parseOrg splits "#+KEY: value" lines out as lower-cased keywords and
// renders the rest of the document to HTML.
func parseOrg(src []byte, path string) (map[string]string, template.HTML, error) {
	kw := map[string]string{}
	var body []string
	for _, line := range strings.Split(string(src), "\n") {
		t := strings.TrimSpace(line)
		if rest, ok := strings.CutPrefix(t, "#+"); ok {
			if k, v, ok := strings.Cut(rest, ":"); ok && k != "" && !strings.ContainsAny(k, " \t") {
				kw[strings.ToLower(k)] = strings.TrimSpace(v)
				continue
			}
		}
		body = append(body, line)
	}
	text := strings.TrimSpace(strings.Join(body, "\n"))
	if text == "" {
		return kw, "", nil
	}
	out, err := org.New().Parse(strings.NewReader(text), path).Write(org.NewHTMLWriter())
	if err != nil {
		return nil, "", err
	}
	return kw, template.HTML(out), nil
}

git add go.mod go.sum internal/library
git commit -m "Parse org keywords and body"

package library

import (
	"io/fs"
	"os"
	"path/filepath"
	"testing"
	"time"

	"gitbay.org/cmc/gallery/internal/format"
)

func statFile(t *testing.T, body string) (string, fs.FileInfo) {
	t.Helper()
	p := filepath.Join(t.TempDir(), "a.jpg")
	if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
		t.Fatal(err)
	}
	fi, err := os.Stat(p)
	if err != nil {
		t.Fatal(err)
	}
	return p, fi
}

func TestMetaCacheRoundTrip(t *testing.T) {
	path := filepath.Join(t.TempDir(), "sub", "meta.json")
	c, err := OpenMetaCache(path)
	if err != nil {
		t.Fatal(err)
	}
	_, fi := statFile(t, "x")
	m := format.Meta{Width: 3, Height: 2, Camera: "X-T5", Taken: time.Date(2025, 3, 1, 0, 0, 0, 0, time.UTC)}
	c.put("tokyo/a.jpg", fi, m)
	c.put("gone/b.jpg", fi, m)
	if err := c.save(map[string]bool{"tokyo/a.jpg": true}); err != nil {
		t.Fatal(err)
	}

	c2, err := OpenMetaCache(path)
	if err != nil {
		t.Fatal(err)
	}
	got, ok := c2.get("tokyo/a.jpg", fi)
	if !ok || !got.Taken.Equal(m.Taken) || got.Camera != "X-T5" || got.Width != 3 {
		t.Fatalf("get = %+v, %v", got, ok)
	}
	if _, ok := c2.get("gone/b.jpg", fi); ok {
		t.Fatal("entry outside keep survived save")
	}
}

func TestMetaCacheMissOnChange(t *testing.T) {
	c, _ := OpenMetaCache(filepath.Join(t.TempDir(), "meta.json"))
	p, fi := statFile(t, "x")
	c.put("a.jpg", fi, format.Meta{Width: 1, Height: 1})

	if err := os.WriteFile(p, []byte("longer"), 0o644); err != nil {
		t.Fatal(err)
	}
	fi2, _ := os.Stat(p)
	if _, ok := c.get("a.jpg", fi2); ok {
		t.Fatal("size change should miss")
	}

	later := fi.ModTime().Add(time.Hour)
	os.WriteFile(p, []byte("x"), 0o644)
	os.Chtimes(p, later, later)
	fi3, _ := os.Stat(p)
	if _, ok := c.get("a.jpg", fi3); ok {
		t.Fatal("mtime change should miss")
	}
}

func TestMetaCacheCorruptStartsEmpty(t *testing.T) {
	path := filepath.Join(t.TempDir(), "meta.json")
	os.WriteFile(path, []byte("{nope"), 0o644)
	c, err := OpenMetaCache(path)
	if err != nil {
		t.Fatal(err)
	}
	if len(c.entries) != 0 {
		t.Fatalf("entries = %v", c.entries)
	}
}

package library

import (
	"encoding/json"
	"errors"
	"io/fs"
	"log"
	"os"
	"path/filepath"

	"gitbay.org/cmc/gallery/internal/format"
)

type metaEntry struct {
	ModTime int64       `json:"mtime"`
	Size    int64       `json:"size"`
	Meta    format.Meta `json:"meta"`
}

// MetaCache persists extracted metadata keyed by album-relative path.
type MetaCache struct {
	path    string
	entries map[string]metaEntry
}

func OpenMetaCache(path string) (*MetaCache, error) {
	c := &MetaCache{path: path, entries: map[string]metaEntry{}}
	data, err := os.ReadFile(path)
	if errors.Is(err, fs.ErrNotExist) {
		return c, nil
	}
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(data, &c.entries); err != nil {
		log.Printf("meta cache %s unreadable, starting empty: %v", path, err)
		c.entries = map[string]metaEntry{}
	}
	return c, nil
}

func (c *MetaCache) get(rel string, fi fs.FileInfo) (format.Meta, bool) {
	e, ok := c.entries[rel]
	if !ok || e.ModTime != fi.ModTime().UnixNano() || e.Size != fi.Size() {
		return format.Meta{}, false
	}
	return e.Meta, true
}

func (c *MetaCache) put(rel string, fi fs.FileInfo, m format.Meta) {
	c.entries[rel] = metaEntry{ModTime: fi.ModTime().UnixNano(), Size: fi.Size(), Meta: m}
}

func (c *MetaCache) save(keep map[string]bool) error {
	for k := range c.entries {
		if !keep[k] {
			delete(c.entries, k)
		}
	}
	data, err := json.Marshal(c.entries)
	if err != nil {
		return err
	}
	if err := os.MkdirAll(filepath.Dir(c.path), 0o755); err != nil {
		return err
	}
	tmp := c.path + ".tmp"
	if err := os.WriteFile(tmp, data, 0o644); err != nil {
		return err
	}
	return os.Rename(tmp, c.path)
}