landing page (#63)

* remove daisyui and rebuild styles

* very basic setup of new design - missing components etc

* basic navbar with reusable landing components

* basic puzzle of the day

* update todos

* update todos

* add curated landing puzzle cards with selectable board (#55)

* update with footer

* add button to solve today's puzzle

* Make landing page a dead view

Render the home page from PageController with a static board preview, link puzzle cards and CTAs to public-code play routes, count puzzles from the DB, and add a global footer.

* Serve a marketing-only JS bundle on the landing page

Build a small marketing entry point with phoenix_html and the plain-DOM navbar, select it on controller-rendered pages, and keep the full LiveView bundle for LiveView pages.

* Add landing page SEO metadata

Replace the Phoenix default title with a descriptive Lucid Chess title, and add description, canonical, Open Graph, and Twitter card tags to the landing page.

* Complete the hero copy block

Add the spark icon primitive and the Endgames, made clear eyebrow. The primary CTA keeps linking to the active puzzle rather than scrolling to the board.

* Add a persisted global daily puzzle

Assign one endgame per UTC day in a daily_puzzles table with a unique date, preferring endgames unused in the last 30 days and falling back to any. Concurrent first requests insert with on-conflict-ignore and read the winning row. The landing board now shows the daily puzzle.

* remove unused CSS, nav links, time pill

* allow devices to connect to dev server by changing IP address to 0.0.0.0

* Restore the colour-mode switch and add a dark palette

* Use brand colour tokens on the play page

* self host fonts  - closes issue #62

* begin splitting CSS into modules

* remove hover on hero chessboard, split more css modules

* remove interactivity from hero chessboard

* update todo
This commit is contained in:
2026-11-05 13:52:14 +01:00
committed by GitHub
parent fd6277ef92
commit 93806b9ab2
60 changed files with 2253 additions and 11028 deletions
+108
View File
@@ -0,0 +1,108 @@
defmodule Chesstrainer.DailyPuzzlesTest do
use Chesstrainer.DataCase
alias Chesstrainer.DailyPuzzles
alias Chesstrainer.DailyPuzzles.DailyPuzzle
alias Chesstrainer.Endgames
alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Repo
alias Ecto.Adapters.SQL.Sandbox
@kr "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
@kr_other "8/8/4k3/8/8/3K1R2/8/8 w - - 0 1"
@kq "8/8/3k4/8/8/3K1Q2/8/8 w - - 0 1"
defp create_endgame!(fen) do
{:ok, endgame} =
Endgames.create_endgame(%{fen: fen, color: :white, result: :win, rating: 1500})
endgame
end
test "returns nil and persists nothing when there are no endgames" do
date = ~D[2026-01-01]
assert DailyPuzzles.for_date(date) == nil
assert Repo.get_by(DailyPuzzle, date: date) == nil
end
test "persists one stable endgame for the day" do
endgame = create_endgame!(@kr)
date = ~D[2026-01-01]
assert DailyPuzzles.for_date(date).id == endgame.id
assert DailyPuzzles.for_date(date).id == endgame.id
assert %DailyPuzzle{endgame_id: endgame_id} = Repo.get_by(DailyPuzzle, date: date)
assert endgame_id == endgame.id
assert Repo.aggregate(DailyPuzzle, :count) == 1
end
test "rotates through endgames across consecutive days" do
create_endgame!(@kr)
create_endgame!(@kr_other)
create_endgame!(@kq)
day = ~D[2026-01-01]
ids = for offset <- 0..2, do: DailyPuzzles.for_date(Date.add(day, offset)).id
assert length(Enum.uniq(ids)) == 3
end
test "falls back to an endgame when the eligible pool is exhausted" do
endgame = create_endgame!(@kr)
day = ~D[2026-01-01]
assert DailyPuzzles.for_date(day).id == endgame.id
assert DailyPuzzles.for_date(Date.add(day, 1)).id == endgame.id
end
test "concurrent first requests create a single assignment" do
date = ~D[2026-01-01]
fens = [@kr, @kr_other, @kq]
cleanup = fn ->
Sandbox.unboxed_run(Repo, fn ->
Repo.delete_all(from daily_puzzle in DailyPuzzle, where: daily_puzzle.date == ^date)
Repo.delete_all(from endgame in Endgame, where: endgame.fen in ^fens)
end)
end
# This test commits outside the sandbox so the worker tasks use real,
# separate connections and actually race on the unique date constraint.
cleanup.()
on_exit(cleanup)
endgame_ids =
Sandbox.unboxed_run(Repo, fn ->
for fen <- fens, do: create_endgame!(fen).id
end)
tasks =
for _ <- 1..8 do
Task.async(fn ->
receive do
:go -> :ok
end
Sandbox.unboxed_run(Repo, fn -> DailyPuzzles.for_date(date).id end)
end)
end
Enum.each(tasks, &send(&1.pid, :go))
assigned_ids = Task.await_many(tasks, 10_000)
assert [assigned_id] = Enum.uniq(assigned_ids)
assert assigned_id in endgame_ids
count =
Sandbox.unboxed_run(Repo, fn ->
Repo.aggregate(
from(daily_puzzle in DailyPuzzle, where: daily_puzzle.date == ^date),
:count
)
end)
assert count == 1
end
end
+78
View File
@@ -5,6 +5,12 @@ defmodule Chesstrainer.EndgamesTest do
alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Themes
setup do
previous = Application.get_env(:chesstrainer, :curated_endgame_codes)
on_exit(fn -> Application.put_env(:chesstrainer, :curated_endgame_codes, previous) end)
:ok
end
@kr "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
@kr_other "8/8/4k3/8/8/3K1R2/8/8 w - - 0 1"
@kq "8/8/3k4/8/8/3K1Q2/8/8 w - - 0 1"
@@ -302,4 +308,76 @@ defmodule Chesstrainer.EndgamesTest do
assert Endgames.list_key_groups(%{key: "KQ v K"}) == [{"KQ v K", 1}]
end
end
describe "count_endgames/0" do
test "returns 0 when there are no endgames" do
assert Endgames.count_endgames() == 0
end
test "counts every stored endgame" do
create_endgame!(@kr)
create_endgame!(@kq)
assert Endgames.count_endgames() == 2
end
end
describe "random_endgame/0" do
test "returns nil when there are no endgames" do
assert Endgames.random_endgame() == nil
end
test "returns one of the existing endgames" do
kr = create_endgame!(@kr)
kq = create_endgame!(@kq)
assert Endgames.random_endgame().id in [kr.id, kq.id]
end
end
describe "curated_endgames/1" do
test "returns the configured endgames in order with themes preloaded" do
{:ok, theme} = Themes.create_theme(%{name: "Opposition", category: :endgame})
first = create_endgame!(@kr, [theme])
second = create_endgame!(@kq)
Application.put_env(:chesstrainer, :curated_endgame_codes, [
first.public_code,
second.public_code
])
assert [one, two] = Endgames.curated_endgames(2)
assert one.id == first.id
assert two.id == second.id
assert Enum.map(one.themes, & &1.name) == ["Opposition"]
end
test "fills missing or unresolved codes from the database" do
first = create_endgame!(@kr)
second = create_endgame!(@kq)
Application.put_env(:chesstrainer, :curated_endgame_codes, [first.public_code, "missing"])
endgames = Endgames.curated_endgames(2)
assert length(endgames) == 2
assert hd(endgames).id == first.id
assert Enum.any?(endgames, &(&1.id == second.id))
end
test "returns a date-seeded selection when nothing is configured" do
first = create_endgame!(@kr)
second = create_endgame!(@kq)
Application.put_env(:chesstrainer, :curated_endgame_codes, [])
ids = Endgames.curated_endgames(3) |> Enum.map(& &1.id)
assert Enum.sort(ids) == Enum.sort([first.id, second.id])
end
test "returns an empty list when there are no endgames" do
Application.put_env(:chesstrainer, :curated_endgame_codes, [])
assert Endgames.curated_endgames() == []
end
end
end
+31
View File
@@ -114,4 +114,35 @@ defmodule Chesstrainer.FENTest do
assert FEN.piece_count(nil) == nil
end
end
describe "board/1" do
test "returns eight ranks of eight squares" do
board = FEN.board("8/8/3k4/8/8/3K1R2/8/8 w - - 0 1")
assert length(board) == 8
assert Enum.all?(board, &(length(&1) == 8))
end
test "expands empty-square digits into nil squares" do
assert FEN.board("8/8/8/8/8/8/8/8") ==
List.duplicate(List.duplicate(nil, 8), 8)
end
test "maps each piece letter to its square" do
board = FEN.board("8/8/3k4/8/8/3K1R2/8/8 w - - 0 1")
assert Enum.at(board, 2) == [nil, nil, nil, "k", nil, nil, nil, nil]
assert Enum.at(board, 5) == [nil, nil, nil, "K", nil, "R", nil, nil]
end
test "reads only the board field" do
assert FEN.board("8/8/3k4/8/8/3K1R2/8/8 w - - 37 99") ==
FEN.board("8/8/3k4/8/8/3K1R2/8/8")
end
test "returns nil for a malformed board" do
assert FEN.board("not a fen") == nil
assert FEN.board(nil) == nil
end
end
end