pandorga 1.2.1

data/scripts/test/test-git-chronology.rb

@@ -0,0 +1,414 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+require_relative "../../_plugins/git_chronology"
+
+def check!(condition, message = "condition was false")
+  raise "Assertion failed: #{message}" unless condition
+end
+
+def assert_equal(expected, actual, message = nil)
+  return if expected == actual
+
+  label = message || "expected #{expected.inspect}, got #{actual.inspect}"
+  raise "Assertion failed: #{label}"
+end
+
+def git!(argv, env: {}, chdir:)
+  full_env = {
+    "GIT_AUTHOR_NAME" => "Test",
+    "GIT_AUTHOR_EMAIL" => "test@example.com",
+    "GIT_COMMITTER_NAME" => "Test",
+    "GIT_COMMITTER_EMAIL" => "test@example.com"
+  }.merge(env)
+  system(full_env, *argv, chdir: chdir) || raise("git command failed: #{argv.join(' ')}")
+end
+
+def with_temp_git_repo
+  GitChronology.reset_cache!
+  Dir.mktmpdir("git-chronology") do |tmpdir|
+    git!(%w[git init -b main], chdir: tmpdir)
+    git!(%w[git config user.name Test], chdir: tmpdir)
+    git!(%w[git config user.email test@example.com], chdir: tmpdir)
+    yield tmpdir
+  end
+end
+
+puts "Testing GitChronology..."
+
+with_temp_git_repo do |repo|
+  path = "content/collections/articles/sample.md"
+  file = File.join(repo, path)
+  FileUtils.mkdir_p(File.dirname(file))
+
+  File.write(
+    file,
+    <<~MARKDOWN
+      ---
+      title: Original title
+      ---
+      Body version one.
+    MARKDOWN
+  )
+  git!(
+    %W[git add #{path}],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-01-10T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-01-10T12:00:00"
+    }
+  )
+  git!(
+    %w[git commit -m create],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-01-10T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-01-10T12:00:00"
+    }
+  )
+
+  File.write(
+    file,
+    <<~MARKDOWN
+      ---
+      title: Renamed title
+      thumbnail: /media/images/new-thumb.png
+      ---
+      Body version one.
+    MARKDOWN
+  )
+  git!(%W[git add #{path}], chdir: repo)
+  git!(
+    %w[git commit -m front-matter-only],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-02-15T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-02-15T12:00:00"
+    }
+  )
+
+  File.write(
+    file,
+    <<~MARKDOWN
+      ---
+      title: Renamed title
+      thumbnail: /media/images/new-thumb.png
+      ---
+      Body version two.
+    MARKDOWN
+  )
+  git!(%W[git add #{path}], chdir: repo)
+  git!(
+    %w[git commit -m body-edit],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-03-20T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-03-20T12:00:00"
+    }
+  )
+
+  File.write(
+    file,
+    <<~MARKDOWN
+      ---
+      title: Another title tweak
+      thumbnail: /media/images/another-thumb.png
+      ---
+      Body version two.
+    MARKDOWN
+  )
+  git!(%W[git add #{path}], chdir: repo)
+  git!(
+    %w[git commit -m front-matter-only-after-body],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-04-01T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-04-01T12:00:00"
+    }
+  )
+
+  Dir.chdir(repo) do
+    chronology = GitChronology.chronology_for(path, type: "article")
+    assert_equal "2026-01-10", chronology["date"]
+    assert_equal "2026-03-20", chronology["last_updated"], "front-matter-only commits must not advance last_updated"
+    assert_equal "2026-04-01", GitChronology.git_date(path, :updated), "file-level git_date still tracks any edit"
+  end
+end
+
+with_temp_git_repo do |repo|
+  path = "content/collections/posts/do-avesso.md"
+  file = File.join(repo, path)
+  FileUtils.mkdir_p(File.dirname(file))
+
+  File.write(
+    file,
+    <<~MARKDOWN
+      ---
+      title: Do avesso
+      date: '2026-05-15'
+      thumbnail: "/media/thumbnails/old.png"
+      ---
+      <div class="poem" markdown="1">
+
+      Minha goela,
+      meus entréns.
+
+      </div>
+    MARKDOWN
+  )
+  git!(
+    %W[git add #{path}],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-05-15T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-05-15T12:00:00"
+    }
+  )
+  git!(
+    %w[git commit -m create-post],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-05-15T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-05-15T12:00:00"
+    }
+  )
+
+  File.write(
+    file,
+    <<~MARKDOWN
+      ---
+      title: Do avesso
+      date: 2026-05-15
+      thumbnail: https://example.com/new-thumb.jpg
+      last_updated: 2026-08-28
+      ---
+      <div class="poem" markdown="1">
+      Minha goela,
+      meus entréns.
+
+      </div>
+    MARKDOWN
+  )
+  git!(%W[git add #{path}], chdir: repo)
+  git!(
+    %w[git commit -m studio-front-matter-and-whitespace],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-08-28T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-08-28T12:00:00"
+    }
+  )
+
+  Dir.chdir(repo) do
+    chronology = GitChronology.chronology_for(path, type: "post")
+    assert_equal "2026-05-15", chronology["date"]
+    assert_equal "2026-05-15", chronology["last_updated"],
+                 "CMS whitespace reformat with front-matter edits must not advance last_updated"
+  end
+end
+
+with_temp_git_repo do |repo|
+  # Regression for the 2026-06-19 content-path migration class of bugs: git log --follow
+  # reaches _posts/… history but git show sha:content/collections/posts/… fails on those
+  # commits unless the historical path is used. See docs/content/architecture.md.
+  old_path = "_posts/sample.md"
+  new_path = "content/collections/posts/sample.md"
+  old_file = File.join(repo, old_path)
+  new_file = File.join(repo, new_path)
+  FileUtils.mkdir_p(File.dirname(old_file))
+
+  File.write(
+    old_file,
+    <<~MARKDOWN
+      ---
+      title: Original
+      ---
+      Body version one.
+    MARKDOWN
+  )
+  git!(%W[git add #{old_path}], chdir: repo)
+  git!(
+    %w[git commit -m create-at-old-path],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-05-01T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-05-01T12:00:00"
+    }
+  )
+
+  File.write(
+    old_file,
+    <<~MARKDOWN
+      ---
+      title: Original
+      ---
+      Body version two.
+    MARKDOWN
+  )
+  git!(%W[git add #{old_path}], chdir: repo)
+  git!(
+    %w[git commit -m body-edit-before-rename],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-05-15T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-05-15T12:00:00"
+    }
+  )
+
+  FileUtils.mkdir_p(File.dirname(new_file))
+  git!(%W[git mv #{old_path} #{new_path}], chdir: repo)
+  git!(
+    %w[git commit -m rename-only],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-06-19T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-06-19T12:00:00"
+    }
+  )
+
+  File.write(
+    new_file,
+    <<~MARKDOWN
+      ---
+      title: Retitled after rename
+      ---
+      Body version two.
+    MARKDOWN
+  )
+  git!(%W[git add #{new_path}], chdir: repo)
+  git!(
+    %w[git commit -m front-matter-after-rename],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-06-20T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-06-20T12:00:00"
+    }
+  )
+
+  Dir.chdir(repo) do
+    chronology = GitChronology.chronology_for(new_path, type: "post")
+    assert_equal "2026-05-01", chronology["date"]
+    assert_equal "2026-05-15", chronology["last_updated"], "rename-only migration must not advance last_updated"
+  end
+end
+
+with_temp_git_repo do |repo|
+  # Regression for content/articles → content/collections/articles rename (2026-07).
+  old_path = "content/articles/sample.md"
+  new_path = "content/collections/articles/sample.md"
+  old_file = File.join(repo, old_path)
+  new_file = File.join(repo, new_path)
+  FileUtils.mkdir_p(File.dirname(old_file))
+
+  File.write(
+    old_file,
+    <<~MARKDOWN
+      ---
+      title: Original
+      ---
+      Body version one.
+    MARKDOWN
+  )
+  git!(%W[git add #{old_path}], chdir: repo)
+  git!(
+    %w[git commit -m create-at-old-article-path],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-05-10T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-05-10T12:00:00"
+    }
+  )
+
+  File.write(
+    old_file,
+    <<~MARKDOWN
+      ---
+      title: Original
+      ---
+      Body version two.
+    MARKDOWN
+  )
+  git!(%W[git add #{old_path}], chdir: repo)
+  git!(
+    %w[git commit -m body-edit-before-article-rename],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-05-18T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-05-18T12:00:00"
+    }
+  )
+
+  FileUtils.mkdir_p(File.dirname(new_file))
+  git!(%W[git mv #{old_path} #{new_path}], chdir: repo)
+  git!(
+    %w[git commit -m rename-article-into-collections],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-07-12T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-07-12T12:00:00"
+    }
+  )
+
+  File.write(
+    new_file,
+    <<~MARKDOWN
+      ---
+      title: Retitled after rename
+      ---
+      Body version two.
+    MARKDOWN
+  )
+  git!(%W[git add #{new_path}], chdir: repo)
+  git!(
+    %w[git commit -m front-matter-after-article-rename],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-07-13T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-07-13T12:00:00"
+    }
+  )
+
+  Dir.chdir(repo) do
+    chronology = GitChronology.chronology_for(new_path, type: "article")
+    assert_equal "2026-05-10", chronology["date"]
+    assert_equal "2026-05-18", chronology["last_updated"], "article rename into collections must not advance last_updated"
+  end
+end
+
+with_temp_git_repo do |repo|
+  # Legacy imports: filename carries the original publication date; Git first-add is later.
+  path = "content/collections/posts/2021-03-17-o-espaco.md"
+  file = File.join(repo, path)
+  FileUtils.mkdir_p(File.dirname(file))
+
+  File.write(
+    file,
+    <<~MARKDOWN
+      ---
+      title: O espaco
+      date: 2021-03-17
+      ---
+      Body from the legacy platform.
+    MARKDOWN
+  )
+  git!(%W[git add #{path}], chdir: repo)
+  git!(
+    %w[git commit -m import-legacy-post],
+    chdir: repo,
+    env: {
+      "GIT_AUTHOR_DATE" => "2026-05-01T12:00:00",
+      "GIT_COMMITTER_DATE" => "2026-05-01T12:00:00"
+    }
+  )
+
+  Dir.chdir(repo) do
+    chronology = GitChronology.chronology_for(path, type: "post")
+    assert_equal "2021-03-17", chronology["date"], "creation date must follow filename/front matter, not Git first-add"
+    assert_equal "2021-03-17", chronology["last_updated"], "body-only chronology with a single commit falls back to creation date"
+  end
+end
+
+puts "GitChronology OK"

data/scripts/test/test-hero-portraits.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+// AC-HERO-06 and AC-HERO-07. Executes the functions in
+// _includes/content-runtime/60-fragments.html rather than a copy of them.
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const source = fs.readFileSync(
+  path.join(root, '_includes/content-runtime/60-fragments.html'),
+  'utf8'
+);
+
+const start = source.indexOf('function heroPortraitEntries');
+const end = source.indexOf('function applyHeroPortrait');
+if (start < 0 || end < start) {
+  console.error('hero portrait functions missing from 60-fragments.html');
+  process.exit(1);
+}
+
+const api = new Function(
+  `${source.slice(start, end)}\nreturn { heroPortraitEntries, pickHeroPortrait };`
+)();
+
+const { heroPortraitEntries, pickHeroPortrait } = api;
+
+let failed = 0;
+
+function check(condition, message) {
+  if (!condition) {
+    console.error(`FAIL: ${message}`);
+    failed += 1;
+  }
+}
+
+function same(got, expected, message) {
+  const left = JSON.stringify(got);
+  const right = JSON.stringify(expected);
+  check(left === right, `${message}: got ${left}, want ${right}`);
+}
+
+// AC-HERO-07
+same(heroPortraitEntries(null), [], 'null payload');
+same(heroPortraitEntries({ src: '/media/images/hero/a.jpg' }), [], 'object payload');
+same(
+  heroPortraitEntries([
+    null,
+    [],
+    { alt: 'no src' },
+    { src: '' },
+    { src: '   ' },
+    { src: 12 },
+  ]),
+  [],
+  'ineligible rows'
+);
+same(
+  heroPortraitEntries([
+    { src: '  /media/images/hero/a.JPG  ' },
+    { src: '/media/images/hero/b.JPG', alt: '  face  ' },
+    { src: '/media/images/hero/c.JPG', alt: 4 },
+    { src: '/media/images/hero/d.JPG', alt: '   ' },
+  ]),
+  [
+    { src: '/media/images/hero/a.JPG', alt: '' },
+    { src: '/media/images/hero/b.JPG', alt: 'face' },
+    { src: '/media/images/hero/c.JPG', alt: '' },
+    { src: '/media/images/hero/d.JPG', alt: '' },
+  ],
+  'normalised rows'
+);
+
+// AC-HERO-06
+const two = [
+  { src: '/media/images/hero/a.JPG', alt: '' },
+  { src: '/media/images/hero/b.JPG', alt: 'second' },
+];
+check(pickHeroPortrait([], () => 0) === null, 'empty list');
+check(pickHeroPortrait(null, () => 0) === null, 'null list');
+same(pickHeroPortrait(two, () => 0), two[0], 'roll 0');
+same(pickHeroPortrait(two, () => 0.5), two[1], 'roll 0.5');
+same(pickHeroPortrait(two, () => 0.999), two[1], 'roll just below 1');
+same(pickHeroPortrait(two, () => 1), two[0], 'roll 1');
+same(pickHeroPortrait(two, () => -0.1), two[0], 'negative roll');
+same(pickHeroPortrait(two, () => Number.NaN), two[0], 'NaN roll');
+same(pickHeroPortrait(two, () => '0'), two[0], 'non-number roll');
+same(pickHeroPortrait([two[0]], () => 0.999), two[0], 'single entry');
+
+const three = two.concat([{ src: '/media/images/hero/c.JPG', alt: '' }]);
+same(pickHeroPortrait(three, () => 0.4), three[1], 'roll 0.4 of three');
+
+if (failed) {
+  console.error(`hero portraits: ${failed} failure(s)`);
+  process.exit(1);
+}
+console.log('PASS: hero portrait picker');

data/scripts/test/test-hero-portraits.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Home hero portraits (docs/features/hero-portraits.md).
+#
+# AC-HERO-01 the pool directory and the list agree
+# AC-HERO-02 the export writes pages/home/portraits.json
+# AC-HERO-03 Studio does not register an editorial list
+# AC-HERO-04 the plate starts with no photograph
+# AC-HERO-05 the runtime draws once per load and fades the file in after it loads
+# AC-HERO-06 / AC-HERO-07 the picker, executed from the runtime source
+
+require "fileutils"
+require "json"
+require "open3"
+require "pathname"
+require "tmpdir"
+require "yaml"
+require "date"
+
+require_relative "../content/hero_portraits"
+
+ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+EXPORT = ROOT.join("scripts/content/export-content-json.rb")
+LAYOUT = ROOT.join("_layouts/home.html")
+HOME_CSS = ROOT.join("assets/css/ledger/home.css")
+RUNTIME = ROOT.join("_includes/content-runtime/60-fragments.html")
+SCHEMA = ROOT.join("studio/schema.yml")
+PICKER = ROOT.join("scripts/test/test-hero-portraits.mjs")
+POOL = ROOT.join("content/media/images/hero")
+
+def check!(condition, message = "condition was false")
+  raise "Assertion failed: #{message}" unless condition
+end
+
+puts "Testing home hero portraits..."
+
+# ── AC-HERO-01 ──────────────────────────────────────────────────────────────
+
+check!(POOL.directory?, "missing #{POOL}")
+check!(!ROOT.join("content/pages/home/portraits.yml").exist?,
+       "the author does not keep a portrait list")
+
+pool_names = POOL.children.select(&:file?).map { |path| path.basename.to_s }.sort
+check!(pool_names == %w[DSC00571.JPG DSC00632.JPG DSC00721.JPG DSC00727.JPG],
+       "the hero folder must hold the four uploaded photographs, got #{pool_names.inspect}")
+
+Dir.mktmpdir("hero-pool") do |dir|
+  root = Pathname.new(dir)
+  pool = root.join("media/images/hero")
+  pool.mkpath
+  FileUtils.touch(pool.join("b.JPG"))
+  FileUtils.touch(pool.join("a.png"))
+  FileUtils.touch(pool.join("note.txt"))
+
+  got = HeroPortraits.entries(root)
+  check!(got == [
+           { "src" => "/media/images/hero/a.png" },
+           { "src" => "/media/images/hero/b.JPG" }
+         ],
+         "the folder is the pool and non-images stay out, got #{got.inspect}")
+end
+
+# ── AC-HERO-03 ──────────────────────────────────────────────────────────────
+
+schema = YAML.safe_load(SCHEMA.read, permitted_classes: [Date, Time], aliases: true) || {}
+
+def each_content_entry(nodes, &block)
+  Array(nodes).each do |entry|
+    next unless entry.is_a?(Hash)
+
+    if entry["type"].to_s == "group"
+      each_content_entry(entry["items"], &block)
+    else
+      yield entry
+    end
+  end
+end
+
+registered = nil
+each_content_entry(schema["content"]) do |entry|
+  registered = entry if entry["path"].to_s == "content/pages/home/portraits.yml"
+end
+check!(registered.nil?, "studio/schema.yml must not register a portrait list")
+
+# ── AC-HERO-04 and AC-HERO-05 (source shape) ───────────────────────────────
+
+layout = LAYOUT.read
+check!(!layout.include?("profile-monologue"),
+       "the deleted shell photograph must not be referenced")
+check!(!ROOT.join("assets/images/profile-monologue.JPG").exist?,
+       "profile-monologue.JPG must not exist")
+hero_img = layout[/<img[^>]*data-content-hero-portrait[^>]*>/m]
+check!(hero_img && !hero_img.include?("src=") && hero_img.include?('alt=""'),
+       "the plate starts without a photographic src and keeps an empty alt, got #{hero_img.inspect}")
+
+home_css = HOME_CSS.read
+check!(home_css.include?("background: black"),
+       "the plate waits on black")
+plate_img = home_css[/^\.home-hero-plate img \{.*?\n\}/m]
+check!(plate_img&.match?(/opacity:\s*0/) && plate_img.match?(/transition:[^;]*opacity/m),
+       "the photograph stays hidden and fades in, got #{plate_img.inspect}")
+shown = home_css[/^\.home-hero-plate img\.is-shown \{.*?\n\}/m]
+check!(shown&.match?(/opacity:\s*1/),
+       "a ready photograph fades to full opacity, got #{shown.inspect}")
+
+runtime = RUNTIME.read
+start = runtime.index("function heroPortraitEntries")
+finish = runtime.index("function hydratePageFragments")
+check!(start && finish && finish > start, "hero portrait functions must precede hydratePageFragments")
+body = runtime[start...finish]
+check!(body.include?("loadJson('pages/home/portraits.json')"), "the runtime must fetch the exported list")
+check!(body.include?("pickHeroPortrait(entries, Math.random)"),
+       "the draw must use Math.random once per load")
+check!(body.include?("return next();"),
+       "a failed image load must try the next pool file")
+check!(body.include?("probe.onload = function ()"), "src must change from the image onload")
+onload = body[/probe\.onload = function \(\) \{.*?\n        \};/m]
+check!(onload&.include?("img.src = nextSrc") && onload.include?("img.alt = nextAlt") &&
+         onload.include?("img.classList.add('is-shown')"),
+       "src, alt, and the fade-in must be applied together after load, got #{onload.inspect}")
+onerror = body[/probe\.onerror = function \(\) \{.*?\n        \};/m]
+check!(onerror && !onerror.include?("img.src") && !onerror.include?("is-shown"),
+       "a failed image load must leave the plate black, got #{onerror.inspect}")
+check!(!body.include?("sessionStorage") && !body.include?("localStorage"),
+       "the draw must not persist a choice")
+check!(runtime.include?("hydrateHeroPortrait();"), "hydratePageFragments must draw the plate")
+
+# ── AC-HERO-06 / AC-HERO-07 ─────────────────────────────────────────────────
+
+stdout, stderr, status = Open3.capture3("node", PICKER.to_s)
+print stdout
+warn stderr unless stderr.strip.empty?
+check!(status.success?, "picker cases failed")
+
+# ── AC-HERO-02 ──────────────────────────────────────────────────────────────
+
+Dir.mktmpdir("hero-portraits") do |dir|
+  out = Pathname.new(dir).join("export")
+  env = { "CONTENT_API_BASE_URL" => "", "CONTENT_EXPORT_SKIP_VALIDATE" => "1" }
+  command = ["ruby", EXPORT.to_s, ROOT.join("content").to_s, out.to_s]
+  output, export_status = Open3.capture2e(env, *command, chdir: ROOT.to_s)
+  check!(export_status.success?, "export failed:\n#{output}")
+
+  exported = out.join("pages/home/portraits.json")
+  check!(exported.file?, "the export must write pages/home/portraits.json")
+  payload = JSON.parse(exported.read)
+  expected = HeroPortraits.entries(ROOT.join("content"))
+  check!(payload == expected, "the exported list must be the hero folder, got #{payload.inspect}")
+  srcs = payload.map { |entry| entry["src"] }
+  check!(srcs == pool_names.map { |name| "/media/images/hero/#{name}" },
+         "the export must name the four photographs, got #{srcs.inspect}")
+  check!(srcs.none? { |src| src.include?("profile-monologue") },
+         "the deleted monologue file must not stay in the draw")
+
+  manifest = JSON.parse(out.join("manifest.json").read)
+  listed = Array(manifest.dig("files", "page_headers"))
+  check!(listed.include?("pages/home/portraits.json"),
+         "manifest page_headers must include the portrait list, got #{listed.inspect}")
+end
+
+puts "All home hero portrait checks passed."