Compare commits

..
9 Commits
Author SHA1 Message Date
owenrees 2759b34296 Derive only-move, underpromotion and 50-move motif themes (#195)
Motifs describe the kind of problem, independent of the material family. One
local tablebase probe returns the root WDL, the DTZ and every legal move with
its own WDL, so each motif is proved without a search or a remote lookup.

- only move: more than one legal move and exactly one preserves the
  50-move-aware result, for wins and draws.
- underpromotion: a preserving underpromotion exists while no preserving queen
  promotion does.
- 50-move draw: cursed/blessed WDL, or a win whose DTZ exceeds the remaining
  halfmove budget.

Motif links are recorded as derived and refreshed as a whole, scoped to the
motif themes, so material, curated and community links survive. Loss endgames
are skipped because only-move is undefined there.

Stalemate is deferred: a stored endgame cannot itself be terminal, so it can
only describe a line and needs a definition before it becomes a predicate.

Release helpers run the derivation without starting the web application, so
`bin/chesstrainer eval` works on the server.

Closes #188
2026-11-17 22:37:37 +01:00
owenrees e6f08e0ca6 Add a workspace for tagging technique themes by family (#194)
An admin picks a technique theme and sees candidate endgames grouped by Key
with counts. Expanding a family previews its boards without starting a puzzle,
and selecting positions applies the theme in bulk as curated. Large families are
paginated so a 600-endgame group stays usable, and curated links can be removed
from the same surface.

Removal is scoped to curated links, so derived and community links are never
deleted by hand. Material themes are refused because derivation owns them.

Closes #187
2026-11-17 21:55:37 +01:00
owenrees 946fc38756 Derive disjoint material family themes from each endgame's Key (#193)
Every endgame now belongs to exactly one material family derived from its Key:
pawn, rook, rook and pawn, queen, queen and pawn, minor piece, minor piece and
pawn, basic mate, king and pawn, or bare king other. The bare-king families are
split out because those positions teach a mating or promotion technique rather
than a general material class.

Family membership is objective, so a derivation pass owns links to its themes:
refreshing rewrites them as derived and removes a curated link that contradicts
the family, while technique themes are untouched. Re-running is idempotent.

A mix task applies the mapping to the whole library. Seeds add the king
technique themes for later human tagging.

Closes #186
2026-11-17 21:18:11 +01:00
owenrees 80cb033077 Add theme slugs, kinds and link provenance (#192)
* add function for upgrading a user's plan in interactive Elixir

* Add theme slugs, kinds and link provenance

Themes gain a stable slug, an optional description and a kind so the app can
tell material, motif and technique labels apart. Slugs are generated from the
name on first save and keep their value when the theme is renamed, so links to
a theme stay valid.

Endgame-to-theme links now record their source (derived, curated or community)
and creation time. Existing links are backfilled as curated. A derived pass can
therefore replace only its own links, leaving human work untouched.

The admin index shows each theme's kind and its coverage across the library.
Creating a theme name requires the manage_themes capability, and members get an
unauthorized error instead, ahead of the suggestion flow.

Closes #185
2026-11-17 20:46:43 +01:00
owenrees 7209923de7 Align board file labels with their squares 2026-11-17 15:13:47 +01:00
owenrees f4ff1e00fb Move colour mode and Discord controls into the mobile menu 2026-11-17 15:05:02 +01:00
owenrees 514c6ac924 Add Discord invite link to navbar and footer 2026-11-17 15:00:38 +01:00
owenrees e0b446bbfb Weight puzzle selection and stop repeats inside a session (#183)
Selection took a hard rating band (medium = user rating ± 100), removed
everything attempted in the last 30 days, and drew uniformly from what was
left. Because the bulk importer gives every endgame in a batch the same
rating, the band held either the whole library or — once a user's rating
drifted past it — only the endgames that user had already played. With
`fresh` empty, the fallback re-drew from the same band ignoring recency, so
recently played puzzles came straight back. An empty band used a
deterministic nearest-match, alternating between the same two puzzles.

Difficulty is now a bias rather than a filter: candidates are weighted by
`exp(-|rating - target| / spread)` and drawn with an exponential race, so
the whole library stays reachable and a thin region around the user's rating
can never empty the pool. `easy` and `hard` keep one-sided guards so the
labels stay honest. When every candidate is excluded, selection serves the
least recently attempted endgame instead of a random recent one.

Sessions now carry the ids they have served, which fixes the observed
in-session repeat (only the current puzzle used to be excluded), and guest
training gets the same treatment. The 30-day window is configurable as the
repeat window and is now named in GLOSSARY.md, distinct from the rating
window and from the tablebase cooldown.

Difficulty copy is qualitative, since the band numbers no longer describe
how selection works.
2026-11-17 14:28:24 +01:00
owenrees fa1fef7b62 Launch amendments: one login, crawler policy, and asset caching (#180)
* lesson library shown as com,ing soon. re-enable learngin strip

* replace learning strip text with a lasker quote

* remove admin login endpoint

* fix crawler directives and prelaunch login

- noindex the authenticated scope and the 404 catch-all, and cover the
  mailing-list confirmation redirect
- emit noindex, nofollow from the robots meta and /health, and assert
  public pages stay indexable and followable
- stop inventing lastmod values in the sitemap
- log in through /users/log-in during prelaunch now that the admin login
  endpoint is gone; drop create_admin/2 and its orphaned tests

* update caching length to 1 year - name change will invalidate cache

* remove logger

* fix tablebase path breaking tests

* test: check cache headers without requiring built assets

CI's test job does not run mix assets.build, so /assets/css/app.css is a
404 there. Committed piece art is already content-hashed and takes the same
Plug.Static cache option, so the test no longer needs a build step and
passes on a fresh checkout.
2026-11-17 12:55:47 +01:00
64 changed files with 2823 additions and 246 deletions
+2
View File
@@ -11,6 +11,8 @@ SES_CONFIGURATION_SET=my-first-configuration-set
# Optional: override the sender or send everything to one address while testing. # Optional: override the sender or send everything to one address while testing.
# MAIL_FROM=no-reply@mail.innersquare.app # MAIL_FROM=no-reply@mail.innersquare.app
# MAIL_REDIRECT_TO=you@example.com # MAIL_REDIRECT_TO=you@example.com
# Optional: directory of local Syzygy .rtbw/.rtbz files. Ignored by the test
# suite, which always uses the committed 3-piece fixtures.
TABLEBASE_PATH= TABLEBASE_PATH=
MATOMO_URL=https://analytics.owenrees.eu/ MATOMO_URL=https://analytics.owenrees.eu/
+15 -5
View File
@@ -105,6 +105,14 @@ carries a start time and a rating baseline for the timer and rating-gain
monitor. Ephemeral — it lives only in the running LiveView, never persisted. monitor. Ephemeral — it lives only in the running LiveView, never persisted.
_Avoid_: Run, game, attempt _Avoid_: Run, game, attempt
**Repeat window**:
The minimum interval before the same endgame may be served to the same user
again. Selection skips endgames attempted inside the window; only when nothing
else is available does the least recently attempted endgame come back. It is
independent of the rating window, which decides whether a replay may move a
rating.
_Avoid_: Cooldown (reserved for tablebase rate-limiting), due date
## Ratings ## Ratings
**Rating**: **Rating**:
@@ -128,11 +136,13 @@ systems; the trainer deliberately does not track it.
_Avoid_: Variance, inconsistency _Avoid_: Variance, inconsistency
**Difficulty**: **Difficulty**:
A choice — `easy`, `medium` or `hard` — that selects which puzzles to serve A choice — `easy`, `medium` or `hard` — that biases which puzzles are served
relative to the current user's rating: `medium` is near the user's rating, relative to the current user's rating: `medium` centres on the user's rating,
`easy` below it, `hard` above it. The band width is a configured constant. It is `easy` below it, `hard` above it. Candidates are weighted by how close their
a property of a session, not of an endgame — the same endgame is easy for one rating is to that centre, so a session draws mostly from near the target but the
user and hard for another. whole library stays reachable. The spread is a configured constant. It is a
property of a session, not of an endgame — the same endgame is easy for one user
and hard for another.
_Avoid_: Level, rank, tier _Avoid_: Level, rank, tier
## Infrastructure ## Infrastructure
+5
View File
@@ -43,6 +43,10 @@
.avatar-stack i:last-child { background: var(--color-deep); color: var(--color-on-deep); } .avatar-stack i:last-child { background: var(--color-deep); color: var(--color-on-deep); }
.puzzle-section { width: min(1180px, calc(100% - 48px)); margin: 0 auto; padding: 110px 0 125px; } .puzzle-section { width: min(1180px, calc(100% - 48px)); margin: 0 auto; padding: 110px 0 125px; }
.puzzle-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; } .puzzle-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; }
.puzzle-coming-soon { min-height: 285px; display: grid; place-content: center; justify-items: center; gap: 10px; padding: 46px 28px; text-align: center; border: 1px dashed var(--color-hairline); border-radius: 12px; background: var(--color-canvas-raised); }
.puzzle-coming-soon .eyebrow { margin-bottom: 6px; }
.puzzle-coming-soon strong { font-family: 'DM Serif Display', serif; font-size: 30px; font-weight: 400; }
.puzzle-coming-soon p { max-width: 420px; margin: 0; color: var(--color-muted); font-size: 14px; line-height: 1.7; }
.puzzle-card { display: block; position: relative; min-height: 285px; padding: 25px; text-align: left; text-decoration: none; color: inherit; cursor: pointer; border: 1px solid var(--color-hairline); border-radius: 12px; background: rgba(255,255,255,.28); overflow: hidden; transition: transform .25s, background .25s, box-shadow .25s; } .puzzle-card { display: block; position: relative; min-height: 285px; padding: 25px; text-align: left; text-decoration: none; color: inherit; cursor: pointer; border: 1px solid var(--color-hairline); border-radius: 12px; background: rgba(255,255,255,.28); overflow: hidden; transition: transform .25s, background .25s, box-shadow .25s; }
.puzzle-card:hover, .puzzle-card.active { transform: translateY(-5px); background: var(--color-canvas-raised); box-shadow: 0 18px 36px rgba(23,53,45,.08); } .puzzle-card:hover, .puzzle-card.active { transform: translateY(-5px); background: var(--color-canvas-raised); box-shadow: 0 18px 36px rgba(23,53,45,.08); }
.puzzle-card.active { border-color: var(--color-success-text); } .puzzle-card.active { border-color: var(--color-success-text); }
@@ -69,6 +73,7 @@ html[data-theme="dark"] .learning-strip { box-shadow: inset 0 1px 0 var(--color-
@media (max-width: 650px) { @media (max-width: 650px) {
.puzzle-section { width: calc(100% - 36px); padding: 80px 0; } .puzzle-section { width: calc(100% - 36px); padding: 80px 0; }
.puzzle-grid { grid-template-columns: 1fr; } .puzzle-grid { grid-template-columns: 1fr; }
.puzzle-coming-soon { min-height: 255px; padding: 38px 22px; }
.puzzle-card { min-height: 255px; } .puzzle-card { min-height: 255px; }
.progress-banner { width: calc(100% - 36px); padding: 48px 28px; flex-direction: column; align-items: flex-start; gap: 34px; } .progress-banner { width: calc(100% - 36px); padding: 48px 28px; flex-direction: column; align-items: flex-start; gap: 34px; }
} }
+7
View File
@@ -43,6 +43,13 @@
/* Play board */ /* Play board */
#endgame-board { position: relative; } #endgame-board { position: relative; }
/* Chessground's stock stylesheet shifts the file labels 24px right of the
board, assuming a gutter we don't have, so they land on square boundaries
instead of under each file. Place the row on the board and right-justify
each label within its square; the row's width already matches the board
because the container is sized to whole squares. */
#endgame-board coords.files { left: 0; text-align: right; }
/* Chessground's wrapper has no intrinsic height; let it fill the sized /* Chessground's wrapper has no intrinsic height; let it fill the sized
aspect-ratio container so the board scales with the viewport. */ aspect-ratio container so the board scales with the viewport. */
#endgame-board .cg-wrap { width: 100%; height: 100%; } #endgame-board .cg-wrap { width: 100%; height: 100%; }
+7
View File
@@ -1,2 +1,9 @@
.eyebrow { display: flex; align-items: center; gap: 9px; margin-bottom: 27px; color: var(--color-coral-text); text-transform: uppercase; letter-spacing: .13em; font-size: 12px; font-weight: 700; } .eyebrow { display: flex; align-items: center; gap: 9px; margin-bottom: 27px; color: var(--color-coral-text); text-transform: uppercase; letter-spacing: .13em; font-size: 12px; font-weight: 700; }
.eyebrow svg { width: 20px; height: 20px; } .eyebrow svg { width: 20px; height: 20px; }
/* Icon-only external links, e.g. the Discord invite in the navbar and footer.
Colour is inherited so the glyph matches the surrounding link row. */
.discord-link { display: inline-flex; align-items: center; color: inherit; transition: opacity .2s; }
.discord-link:hover { opacity: .55; }
.discord-link:focus-visible { outline: 2px solid var(--color-coral-control); outline-offset: 3px; border-radius: 4px; }
.discord-link svg { width: 20px; height: 20px; }
+4 -2
View File
@@ -3,7 +3,9 @@
display: grid; grid-template-columns: 1.5fr repeat(3, 1fr); align-items: center; background: var(--color-deep); color: var(--color-on-deep); display: grid; grid-template-columns: 1.5fr repeat(3, 1fr); align-items: center; background: var(--color-deep); color: var(--color-on-deep);
} }
.learning-strip > p { max-width: 260px; color: var(--color-on-deep-muted); font-family: 'DM Serif Display', serif; font-size: 19px; line-height: 1.25; } .learning-quote { margin: 0; max-width: 300px; }
.learning-quote blockquote { margin: 0; color: var(--color-on-deep); font-family: 'DM Serif Display', serif; font-size: 19px; line-height: 1.25; }
.learning-quote figcaption { margin-top: 10px; color: var(--color-on-deep-faint); font-size: 10px; text-transform: uppercase; letter-spacing: .09em; }
.stat { padding-left: 34px; border-left: 1px solid rgba(255,255,255,.17); } .stat { padding-left: 34px; border-left: 1px solid rgba(255,255,255,.17); }
.stat strong { display: block; font-family: 'DM Serif Display', serif; font-size: 28px; font-weight: 400; } .stat strong { display: block; font-family: 'DM Serif Display', serif; font-size: 28px; font-weight: 400; }
@@ -15,7 +17,7 @@
@media (max-width: 650px) { @media (max-width: 650px) {
.learning-strip { padding: 38px 24px; grid-template-columns: 1fr 1fr; gap: 30px 10px; } .learning-strip { padding: 38px 24px; grid-template-columns: 1fr 1fr; gap: 30px 10px; }
.learning-strip > p { grid-column: 1 / -1; } .learning-quote { grid-column: 1 / -1; }
.stat { padding-left: 18px; } .stat { padding-left: 18px; }
.stat:last-child { grid-column: 1 / -1; } .stat:last-child { grid-column: 1 / -1; }
} }
+8
View File
@@ -14,6 +14,9 @@
.nav-links a { transition: opacity .2s; } .nav-links a { transition: opacity .2s; }
.nav-links a:hover { opacity: .55; } .nav-links a:hover { opacity: .55; }
.nav-links a.nav-cta:hover { opacity: 1; } .nav-links a.nav-cta:hover { opacity: 1; }
/* Utilities (colour mode, Discord) sit in the bar on desktop and in the
collapsible menu on small screens. */
.nav-menu-tools { display: none; }
.nav-user-menu { position: relative; } .nav-user-menu { position: relative; }
.nav-user-menu summary { display: flex; align-items: center; gap: 6px; list-style: none; cursor: pointer; color: var(--color-muted); font-weight: 500; } .nav-user-menu summary { display: flex; align-items: center; gap: 6px; list-style: none; cursor: pointer; color: var(--color-muted); font-weight: 500; }
.nav-user-menu summary::-webkit-details-marker { display: none; } .nav-user-menu summary::-webkit-details-marker { display: none; }
@@ -42,6 +45,11 @@ html[data-theme="dark"] .nav-user-menu-panel { box-shadow: 0 18px 40px rgba(0, 0
.nav-links.open { display: flex; } .nav-links.open { display: flex; }
.nav-cta { width: 100%; } .nav-cta { width: 100%; }
.nav-links { display: none; position: absolute; top: 65px; left: 0; right: 0; padding: 24px; flex-direction: column; align-items: stretch; gap: 22px; border-radius: 10px; background: var(--color-canvas-raised); box-shadow: 0 18px 40px rgba(23,53,45,.15); } .nav-links { display: none; position: absolute; top: 65px; left: 0; right: 0; padding: 24px; flex-direction: column; align-items: stretch; gap: 22px; border-radius: 10px; background: var(--color-canvas-raised); box-shadow: 0 18px 40px rgba(23,53,45,.15); }
.nav-menu-tools { display: flex; align-items: center; justify-content: space-between; gap: 18px; width: 100%; }
/* The menu owns these on small screens; keep them in the bar only when no
menu is rendered (prelaunch with no links). */
.nav-wrap:has(#nav-links) .nav-right > [role="radiogroup"],
.nav-wrap:has(#nav-links) .nav-right > .discord-link { display: none; }
.nav-user-menu-panel { position: static; min-width: 0; padding: 12px 0 0; background: transparent; box-shadow: none; } .nav-user-menu-panel { position: static; min-width: 0; padding: 12px 0 0; background: transparent; box-shadow: none; }
html[data-theme="dark"] .nav-links { box-shadow: 0 18px 40px rgba(0, 0, 0, .45); } html[data-theme="dark"] .nav-links { box-shadow: 0 18px 40px rgba(0, 0, 0, .45); }
} }
+12 -6
View File
@@ -15,7 +15,8 @@ config :chesstrainer, :branding,
wordmark: "INNERSQUARE", wordmark: "INNERSQUARE",
tagline: "Endgame Trainer", tagline: "Endgame Trainer",
support_email: "support@innersquare.app", support_email: "support@innersquare.app",
mail_from: "no-reply@mail.innersquare.app" mail_from: "no-reply@mail.innersquare.app",
discord_invite: "https://discord.gg/Z2NfkG7thV"
# Prelaunch gating. Production sets these from PRELAUNCH and # Prelaunch gating. Production sets these from PRELAUNCH and
# MAILING_LIST_ENABLED; dev and test use these defaults. # MAILING_LIST_ENABLED; dev and test use these defaults.
@@ -61,11 +62,16 @@ config :chesstrainer, :ratings,
window_days: 7, window_days: 7,
rd_inflation_c: 10.0 rd_inflation_c: 10.0
# Difficulty bands for puzzle sessions. An endgame is "medium" when its rating # Puzzle selection. Difficulty is a weighted bias towards a target rating —
# falls within `band_width` of the user's rating, "easy" below that band and # `medium` targets the user's rating, `easy` 200 below it and `hard` 200 above
# "hard" above it. Tweak to widen or narrow the served difficulty (e.g. 150 or # it — and `spread` is how many rating points it takes for a puzzle's chance to
# 200). # fall off by a factor of e. `repeat_window_days` is how long an attempted
config :chesstrainer, :puzzles, band_width: 100 # puzzle stays out of the pool. Tweak `spread` to widen or narrow the served
# difficulty (e.g. 100 or 250).
config :chesstrainer, :puzzles,
spread: 150,
repeat_window_days: 30,
targets: [easy: -200, medium: 0, hard: 200]
# Public codes of the endgames pinned to the landing-page puzzle grid, in # Public codes of the endgames pinned to the landing-page puzzle grid, in
# display order. When empty (or short) the grid is topped up with a date-seeded # display order. When empty (or short) the grid is topped up with a date-seeded
+6 -2
View File
@@ -48,9 +48,13 @@ config :chesstrainer, :mail_redirect_to, System.get_env("MAIL_REDIRECT_TO")
# Local Syzygy tablebases: set TABLEBASE_PATH to the directory holding the # Local Syzygy tablebases: set TABLEBASE_PATH to the directory holding the
# .rtbw/.rtbz files. When unset, the local backend stays disabled and lookups # .rtbw/.rtbz files. When unset, the local backend stays disabled and lookups
# fall back to Lichess. # fall back to Lichess. Tests are always pinned to the committed 3-piece
if tablebase_path = System.get_env("TABLEBASE_PATH") do # fixtures by config/test.exs, so an exported TABLEBASE_PATH cannot make them
# depend on whatever tables the developer happens to have downloaded.
if config_env() != :test do
if tablebase_path = System.get_env("TABLEBASE_PATH") do
config :chesstrainer, :tablebase_path, tablebase_path config :chesstrainer, :tablebase_path, tablebase_path
end
end end
# Tablebase cache: size and the UTC time of the daily backup. Environment # Tablebase cache: size and the UTC time of the daily backup. Environment
+12
View File
@@ -168,6 +168,18 @@ defmodule Chesstrainer.Accounts do
|> Repo.update() |> Repo.update()
end end
@doc """
Updates a user's subscription plan.
Plans are programmatic values; registration never casts `plan`, so a user
cannot upgrade themselves.
"""
def update_user_plan(%User{} = user, plan) do
user
|> User.plan_changeset(%{plan: plan})
|> Repo.update()
end
## Admin user management ## Admin user management
@doc """ @doc """
+11
View File
@@ -55,6 +55,17 @@ defmodule Chesstrainer.Accounts.User do
|> validate_required([:role]) |> validate_required([:role])
end end
@doc """
A user changeset for changing the plan.
The plan is programmatic and must never be cast from user-supplied params.
"""
def plan_changeset(user, attrs) do
user
|> cast(attrs, [:plan])
|> validate_required([:plan])
end
@doc """ @doc """
A user changeset for an admin-created invitation. A user changeset for an admin-created invitation.
+2 -2
View File
@@ -106,8 +106,8 @@ defmodule Chesstrainer.Attempts do
@doc """ @doc """
The distinct endgame ids `user_id` has attempted in the last `days` days. The distinct endgame ids `user_id` has attempted in the last `days` days.
Used by puzzle selection to prefer fresh puzzles; a retry still counts as an Used by puzzle selection to skip puzzles inside the repeat window; a retry
attempt, even though the rating window leaves it unrated. still counts as an attempt, even though the rating window leaves it unrated.
""" """
def recent_endgame_ids(user_id, days \\ 30) do def recent_endgame_ids(user_id, days \\ 30) do
cutoff = DateTime.add(DateTime.utc_now(), -days, :day) cutoff = DateTime.add(DateTime.utc_now(), -days, :day)
+22 -1
View File
@@ -12,7 +12,8 @@ defmodule Chesstrainer.Branding do
wordmark: "INNERSQUARE", wordmark: "INNERSQUARE",
tagline: "Endgame Trainer", tagline: "Endgame Trainer",
support_email: "support@innersquare.app", support_email: "support@innersquare.app",
mail_from: "no-reply@mail.innersquare.app" mail_from: "no-reply@mail.innersquare.app",
discord_invite: "https://discord.gg/Z2NfkG7thV"
] ]
@doc "The display name, e.g. `\"Lucid Chess\"`." @doc "The display name, e.g. `\"Lucid Chess\"`."
@@ -30,6 +31,26 @@ defmodule Chesstrainer.Branding do
@doc "The From address used for outgoing mail." @doc "The From address used for outgoing mail."
def mail_from, do: get(:mail_from) def mail_from, do: get(:mail_from)
@doc """
The Discord invite URL, or `nil` when no invite is configured.
Accepts either a bare invite code (`"abc123"`) or a full URL; a bare code is
expanded to `https://discord.gg/<code>`.
"""
def discord_invite_url do
case get(:discord_invite) do
value when is_binary(value) ->
case String.trim(value) do
"" -> nil
"http" <> _ = url -> url
code -> "https://discord.gg/#{code}"
end
_ ->
nil
end
end
@doc "The home-page title, e.g. `\"Lucid Chess — Endgame Trainer\"`." @doc "The home-page title, e.g. `\"Lucid Chess — Endgame Trainer\"`."
def home_title, do: "#{name()} — #{tagline()}" def home_title, do: "#{name()} — #{tagline()}"
+44 -4
View File
@@ -111,8 +111,13 @@ defmodule Chesstrainer.Endgames do
@doc """ @doc """
Returns `{key, count}` groups for endgames matching the filters, sorted by key. Returns `{key, count}` groups for endgames matching the filters, sorted by key.
Filters is a map with optional `:themes` (a list of theme ids; an endgame must Filters is a map with optional:
carry any one of them) and `:key` (an exact Key).
* `:themes` - a list of theme ids; an endgame must carry any one of them
* `:key` - an exact Key
* `:with_theme` - `{theme_id, source}`; only endgames linked to the theme
with that source
* `:without_theme` - a theme id; only endgames not linked to the theme at all
""" """
def list_key_groups(filters \\ %{}) do def list_key_groups(filters \\ %{}) do
Endgame Endgame
@@ -125,20 +130,31 @@ defmodule Chesstrainer.Endgames do
@doc """ @doc """
Returns the endgames for one Key, matching the filters, with themes preloaded. Returns the endgames for one Key, matching the filters, with themes preloaded.
Accepts `:limit` and `:offset` options for paginating large Key groups.
""" """
def list_endgames_for_key(key, filters \\ %{}) do def list_endgames_for_key(key, filters \\ %{}, opts \\ []) do
skip = Keyword.get(opts, :offset, 0)
Endgame Endgame
|> apply_filters(filters) |> apply_filters(filters)
|> where([e], e.key == ^key) |> where([e], e.key == ^key)
|> preload(:themes) |> preload(:themes)
|> order_by([e], asc: e.fen) |> order_by([e], asc: e.fen, asc: e.id)
|> limit_query(Keyword.get(opts, :limit))
|> offset(^skip)
|> Repo.all() |> Repo.all()
end end
defp limit_query(query, nil), do: query
defp limit_query(query, limit), do: limit(query, ^limit)
defp apply_filters(query, filters) do defp apply_filters(query, filters) do
query query
|> filter_themes(Map.get(filters, :themes, [])) |> filter_themes(Map.get(filters, :themes, []))
|> filter_key(Map.get(filters, :key)) |> filter_key(Map.get(filters, :key))
|> filter_with_theme(Map.get(filters, :with_theme))
|> filter_without_theme(Map.get(filters, :without_theme))
end end
defp filter_themes(query, []), do: query defp filter_themes(query, []), do: query
@@ -156,6 +172,30 @@ defmodule Chesstrainer.Endgames do
defp filter_key(query, key) when key in [nil, ""], do: query defp filter_key(query, key) when key in [nil, ""], do: query
defp filter_key(query, key), do: where(query, [e], e.key == ^key) defp filter_key(query, key), do: where(query, [e], e.key == ^key)
defp filter_with_theme(query, nil), do: query
defp filter_with_theme(query, {theme_id, source}) do
endgame_ids =
from(t in "endgames_themes",
where: t.theme_id == ^theme_id and t.source == ^to_string(source),
select: t.endgame_id
)
where(query, [e], e.id in subquery(endgame_ids))
end
defp filter_without_theme(query, nil), do: query
defp filter_without_theme(query, theme_id) do
endgame_ids =
from(t in "endgames_themes",
where: t.theme_id == ^theme_id,
select: t.endgame_id
)
where(query, [e], e.id not in subquery(endgame_ids))
end
@doc """ @doc """
Gets a single endgame. Gets a single endgame.
@@ -0,0 +1,215 @@
defmodule Chesstrainer.Endgames.MaterialThemes do
@moduledoc """
Derives each endgame's material family from its canonical Key.
Every endgame belongs to exactly one family, so the themes behave as a
partition: selecting several in a filter produces their union, never an
ambiguous intersection. A lone king against heavy or pawn material is split
out because those positions teach a specific technique — basic mate or
promotion — rather than a general material class.
Families are derived, never judged. They are stored with source `derived`, so
a refresh replaces them without touching curated or community themes.
Positions with no legal content (`K v K`) and rows without a Key are skipped.
"""
import Ecto.Query, warn: false
alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Repo
alias Chesstrainer.Themes
@families [
basic_mate: %{
name: "basic mate",
description:
"A lone king against the queen or a rook, with no pawns: the puzzle is about delivering mate."
},
king_and_pawn: %{
name: "king and pawn",
description:
"A lone king against king and pawns: the puzzle is about promotion, or holding the draw."
},
bare_king_other: %{
name: "bare king other",
description:
"A lone king against minor pieces, or against pawns and pieces: usually a technique exercise with little counterplay."
},
queen_and_pawn: %{
name: "queen and pawn",
description: "Queens and pawns on the board."
},
queen_endgame: %{
name: "queen endgame",
description: "Queens on the board, with no pawns."
},
rook_and_pawn: %{
name: "rook and pawn",
description: "Rooks and pawns, with no queens."
},
rook_endgame: %{
name: "rook endgame",
description: "Rooks, with no queens and no pawns."
},
minor_piece_and_pawn: %{
name: "minor piece and pawn",
description: "Bishops and knights with pawns, with no queens or rooks."
},
minor_piece_endgame: %{
name: "minor piece endgame",
description: "Bishops and knights, with no queens, rooks or pawns."
},
pawn_endgame: %{
name: "pawn endgame",
description: "Kings and pawns only."
}
]
@type family ::
:basic_mate
| :king_and_pawn
| :bare_king_other
| :queen_and_pawn
| :queen_endgame
| :rook_and_pawn
| :rook_endgame
| :minor_piece_and_pawn
| :minor_piece_endgame
| :pawn_endgame
@doc "The material families, in a stable order."
def families, do: @families
@doc """
Returns the material family for a Key.
Returns `:kings_only` for `"K v K"` and `:unknown` when the Key is missing or
not shaped like `"<side> v <side>"`.
"""
@spec family(String.t() | nil) :: family() | :kings_only | :unknown
def family(key) when is_binary(key) do
case String.split(key, " v ") do
[a, b] ->
cond do
bare?(a) and bare?(b) -> :kings_only
bare?(a) -> bare_king_family(counts(b))
bare?(b) -> bare_king_family(counts(a))
true -> material_family(merge(counts(a), counts(b)))
end
_ ->
:unknown
end
end
def family(_key), do: :unknown
@doc """
Creates or corrects the material themes, keyed by family.
An existing theme with the same name is reused and its kind and description
are corrected, so a theme seeded as a technique becomes a material theme
without losing its existing links.
"""
@spec ensure_themes() :: %{family() => Chesstrainer.Themes.Theme.t()}
def ensure_themes do
Map.new(@families, fn {family, attrs} ->
{:ok, theme} = Themes.get_or_create(attrs.name, "endgame", kind: :material)
{family, ensure_material_theme(theme, attrs)}
end)
end
@doc """
Refreshes every endgame's derived material theme.
Returns the number of endgames tagged, the number skipped (kings only or no
Key) and the number of material themes. Re-running is idempotent.
"""
@spec derive() :: %{
tagged: non_neg_integer(),
skipped: non_neg_integer(),
themes: non_neg_integer()
}
def derive do
themes = ensure_themes()
material_ids = Enum.map(themes, fn {_family, theme} -> theme.id end)
{links, skipped} =
Endgame
|> select([e], {e.id, e.key})
|> Repo.all()
|> Enum.reduce({[], 0}, fn {id, key}, {links, skipped} ->
case family(key) do
family when family in [:kings_only, :unknown] ->
{links, skipped + 1}
family ->
{[{id, Map.fetch!(themes, family).id} | links], skipped}
end
end)
:ok = Themes.replace_theme_links(material_ids, links)
%{tagged: length(links), skipped: skipped, themes: map_size(themes)}
end
defp ensure_material_theme(theme, attrs) do
if theme.kind == :material and (theme.description || "") == attrs.description do
theme
else
{:ok, updated} =
Themes.update_theme(theme, %{kind: :material, description: attrs.description})
updated
end
end
defp bare?(side), do: side == "K"
defp bare_king_family(counts) do
cond do
count(counts, "P") == 0 and (count(counts, "Q") > 0 or count(counts, "R") > 0) ->
:basic_mate
count(counts, "P") > 0 and count(counts, "Q") == 0 and count(counts, "R") == 0 ->
:king_and_pawn
true ->
:bare_king_other
end
end
defp material_family(counts) do
cond do
count(counts, "Q") > 0 and count(counts, "P") > 0 ->
:queen_and_pawn
count(counts, "Q") > 0 ->
:queen_endgame
count(counts, "R") > 0 and count(counts, "P") > 0 ->
:rook_and_pawn
count(counts, "R") > 0 ->
:rook_endgame
count(counts, "B") + count(counts, "N") > 0 and count(counts, "P") > 0 ->
:minor_piece_and_pawn
count(counts, "B") + count(counts, "N") > 0 ->
:minor_piece_endgame
count(counts, "P") > 0 ->
:pawn_endgame
true ->
:kings_only
end
end
defp counts(side), do: Enum.frequencies(String.graphemes(side))
defp merge(left, right), do: Map.merge(left, right, fn _piece, a, b -> a + b end)
defp count(counts, piece), do: Map.get(counts, piece, 0)
end
+198
View File
@@ -0,0 +1,198 @@
defmodule Chesstrainer.Endgames.MotifThemes do
@moduledoc """
Derives objective motif themes by probing each endgame's position.
Motifs describe the kind of problem, independent of the material family: an
endgame can be a rook endgame and an only-move puzzle at the same time. Every
motif is proved from the local Syzygy tables — one probe returns the root WDL,
the DTZ and every legal move with its own WDL — so nothing here is a guess and
nothing calls the remote backend.
Motif links are recorded as `derived` and refreshed as a whole. Material
families, curated links and community links are untouched because the refresh
is scoped to the motif themes.
Loss endgames are skipped: only-move is undefined when every move loses, and
the library no longer contains them.
"""
import Ecto.Query, warn: false
alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Endgames.Tablebase
alias Chesstrainer.Endgames.Tablebase.Backend.Fathom, as: FathomBackend
alias Chesstrainer.Repo
alias Chesstrainer.Themes
@motifs [
only_move: %{
name: "only move",
description:
"Exactly one legal move keeps the result, so the puzzle is about finding the single accurate move."
},
underpromotion: %{
name: "underpromotion",
description:
"The result can only be preserved by promoting to a rook, bishop or knight; promoting to a queen does not work."
},
fifty_move_draw: %{
name: "50-move draw",
description:
"The result turns on the fifty-move rule: the win needs more moves than the halfmove clock allows, so the defender can claim a draw."
}
]
@type motif :: :only_move | :underpromotion | :fifty_move_draw
@doc "The motif themes, in a stable order."
def motifs, do: @motifs
@doc """
Returns the motifs for one probed position.
`moves` are Fathom move tuples `{wdl, from, to, promotes, ep, dtz}` and carry
the mover's perspective, so they are compared with the root WDL directly.
`halfmove_clock` comes from the FEN; the probe itself runs with `rule50 = 0`.
"""
@spec motifs_for(atom(), integer() | nil, [tuple()], non_neg_integer()) :: [motif()]
def motifs_for(wdl, dtz, moves, halfmove_clock) do
outcome = Tablebase.normalize_wdl(wdl)
preserving =
Enum.filter(moves, fn {move_wdl, _from, _to, _promotes, _ep, _dtz} ->
Tablebase.normalize_wdl(move_wdl) == outcome
end)
[]
|> maybe_only_move(outcome, moves, preserving)
|> maybe_underpromotion(preserving)
|> maybe_fifty_move(wdl, dtz, halfmove_clock)
end
@doc """
Creates or corrects the motif themes, keyed by motif.
An existing theme with the same name is reused and its kind and description
are corrected, so a theme seeded as a technique becomes a motif without
losing its existing links.
"""
@spec ensure_themes() :: %{motif() => Chesstrainer.Themes.Theme.t()}
def ensure_themes do
Map.new(@motifs, fn {motif, attrs} ->
{:ok, theme} = Themes.get_or_create(attrs.name, "endgame", kind: :motif)
{motif, ensure_motif_theme(theme, attrs)}
end)
end
@doc """
Refreshes every endgame's derived motif links.
Returns the number of links written, the number of endgames skipped because
the local tables could not answer them, and a count per motif. Re-running is
idempotent.
"""
@spec derive() :: %{
links: non_neg_integer(),
skipped: non_neg_integer(),
by_motif: %{motif() => non_neg_integer()},
themes: non_neg_integer()
}
def derive do
themes = ensure_themes()
motif_ids = Enum.map(themes, fn {_motif, theme} -> theme.id end)
initial_counts = Map.new(@motifs, fn {motif, _attrs} -> {motif, 0} end)
{links, skipped, by_motif} =
Endgame
|> where([e], e.result in [:win, :draw])
|> select([e], {e.id, e.fen})
|> Repo.all()
|> Enum.reduce({[], 0, initial_counts}, fn {id, fen}, {links, skipped, counts} ->
case probe(fen) do
{:ok, %{wdl: wdl, dtz: dtz, moves: moves}} ->
motifs = motifs_for(wdl, dtz, moves, halfmove_clock(fen))
links =
Enum.reduce(motifs, links, fn motif, acc ->
[{id, Map.fetch!(themes, motif).id} | acc]
end)
counts =
Enum.reduce(motifs, counts, fn motif, acc ->
Map.update!(acc, motif, &(&1 + 1))
end)
{links, skipped, counts}
{:error, _reason} ->
{links, skipped + 1, counts}
end
end)
:ok = Themes.replace_theme_links(motif_ids, links)
%{links: length(links), skipped: skipped, by_motif: by_motif, themes: map_size(themes)}
end
defp ensure_motif_theme(theme, attrs) do
if theme.kind == :motif and (theme.description || "") == attrs.description do
theme
else
{:ok, updated} =
Themes.update_theme(theme, %{kind: :motif, description: attrs.description})
updated
end
end
defp probe(fen), do: probe_module().probe_local_detail(fen)
defp probe_module do
Application.get_env(:chesstrainer, :motif_probe, FathomBackend)
end
defp maybe_only_move(acc, outcome, moves, preserving) do
if outcome in [:win, :draw] and length(moves) > 1 and length(preserving) == 1 do
[:only_move | acc]
else
acc
end
end
defp maybe_underpromotion(acc, preserving) do
underpromotes? =
Enum.any?(preserving, fn {_wdl, _from, _to, promotes, _ep, _dtz} ->
promotes in [2, 3, 4]
end)
queen_promotes? =
Enum.any?(preserving, fn {_wdl, _from, _to, promotes, _ep, _dtz} ->
promotes == 1
end)
if underpromotes? and not queen_promotes?, do: [:underpromotion | acc], else: acc
end
defp maybe_fifty_move(acc, wdl, dtz, halfmove_clock) do
table_draw? = wdl in [:cursed_win, :blessed_loss]
clock_exhausted? =
wdl == :win and is_integer(dtz) and dtz > 100 - halfmove_clock
if table_draw? or clock_exhausted?, do: [:fifty_move_draw | acc], else: acc
end
defp halfmove_clock(fen) do
case String.split(fen, " ") do
[_board, _active, _castling, _ep, clock, _fullmove] ->
case Integer.parse(clock) do
{value, _rest} -> value
:error -> 0
end
_ ->
0
end
end
end
@@ -80,6 +80,38 @@ defmodule Chesstrainer.Endgames.Tablebase.Backend.Fathom do
end end
end end
@doc """
Probes the local tablebase and returns the raw root outcome and move list.
Unlike `probe_result_local/1`, this keeps the per-move tuples and the raw WDL
atom, including `:cursed_win` and `:blessed_loss`, which the motif derivation
needs. It never falls back to the remote backend or consults the cache.
Returns `{:error, :unsupported}` when the local files cannot answer the
position, including a partial tablebase set where Fathom reports `:failed`.
"""
@spec probe_local_detail(String.t()) ::
{:ok, %{wdl: atom(), dtz: integer(), moves: [tuple()]}}
| {:error, :not_configured | :terminal | :unsupported}
def probe_local_detail(fen) do
with {:ok, largest} <- Local.check(),
pieces when is_integer(pieces) <- FEN.piece_count(fen),
true <- pieces <= largest || {:error, :unsupported},
{:ok, {root, moves}} <- Nif.probe(fen) do
case root do
:failed -> {:error, :unsupported}
:checkmate -> {:error, :terminal}
:stalemate -> {:error, :terminal}
{wdl, _from, _to, _promotes, _ep, dtz} -> {:ok, %{wdl: wdl, dtz: dtz, moves: moves}}
end
else
{:error, :not_configured} = error -> error
{:error, :unsupported} = error -> error
{:error, _reason} -> {:error, :unsupported}
nil -> {:error, :unsupported}
end
end
defp fallback(fen) do defp fallback(fen) do
(Application.get_env(:chesstrainer, :tablebase_fallback) || Lichess).probe(fen) (Application.get_env(:chesstrainer, :tablebase_fallback) || Lichess).probe(fen)
end end
+85 -58
View File
@@ -2,14 +2,21 @@ defmodule Chesstrainer.Puzzles do
@moduledoc """ @moduledoc """
Selects endgames to serve as puzzles. Selects endgames to serve as puzzles.
A puzzle is played at one of three difficulties — `:easy`, `:medium` or Difficulty is a bias, not a filter. Every endgame is weighted by how close its
`:hard` — defined relative to the current user's rating: `:medium` is within rating is to a target derived from the user's rating — the user's own rating
a configurable band of the user's rating, `:easy` below it and `:hard` above for `:medium`, below it for `:easy` and above it for `:hard` — and one
it. The same endgame is therefore easy for one player and hard for another. candidate is drawn from that weighted distribution. Nearby endgames are much
more likely, but the whole library stays reachable, so a thin region around
the user's rating can never leave the pool empty.
Selection prefers endgames the user has not attempted in the last 30 days. Endgames the user has attempted inside the repeat window are skipped, as is
When that pool is empty it falls back to any endgame in the band; the rating anything passed in `:exclude_ids` (the puzzles already served in a session).
window keeps a recent replay unrated until it expires. Only when every candidate is excluded does selection fall back to the least
recently attempted endgame, so the repeat is the most overdue one rather than
an arbitrary one.
The same endgame is therefore easy for one player and hard for another: a
rating is what makes the two comparable.
""" """
import Ecto.Query, warn: false import Ecto.Query, warn: false
@@ -17,95 +24,115 @@ defmodule Chesstrainer.Puzzles do
alias Chesstrainer.Repo alias Chesstrainer.Repo
alias Chesstrainer.Accounts.User alias Chesstrainer.Accounts.User
alias Chesstrainer.Attempts alias Chesstrainer.Attempts
alias Chesstrainer.Attempts.Attempt
alias Chesstrainer.Endgames.Endgame alias Chesstrainer.Endgames.Endgame
@default_band_width 100 @default_spread 150
@default_repeat_window_days 30
@default_targets [easy: -200, medium: 0, hard: 200]
@difficulties [:easy, :medium, :hard] @difficulties [:easy, :medium, :hard]
@doc "The difficulties a session can be played at." @doc "The difficulties a session can be played at."
def difficulties, do: @difficulties def difficulties, do: @difficulties
@doc """ @doc """
The half-width of the medium band, in rating points. How far, in rating points, a puzzle's likelihood falls off from the target.
Configured under `:chesstrainer, :puzzles, :band_width`. A larger spread draws more widely around the target. Configured under
`:chesstrainer, :puzzles, :spread`.
""" """
def band_width do def spread, do: setting(:spread, @default_spread)
:chesstrainer
|> Application.get_env(:puzzles, [])
|> Keyword.get(:band_width, @default_band_width)
end
@doc """ @doc """
The `{min, max}` rating range for `difficulty` relative to `rating`. The minimum gap, in days, before the same endgame may be served again.
A `nil` bound is open-ended. Configured under `:chesstrainer, :puzzles, :repeat_window_days`.
""" """
def difficulty_range(rating, difficulty) when difficulty in @difficulties do def repeat_window_days, do: setting(:repeat_window_days, @default_repeat_window_days)
width = band_width()
case difficulty do @doc """
:easy -> {nil, rating - width} The rating `difficulty` aims at, given the player's `rating`.
:medium -> {rating - width, rating + width}
:hard -> {rating + width, nil} The offsets are configured under `:chesstrainer, :puzzles, :targets`.
end """
def difficulty_target(rating, difficulty) when difficulty in @difficulties do
rating + Keyword.fetch!(setting(:targets, @default_targets), difficulty)
end end
@doc """ @doc """
Picks the next puzzle for `user` at `difficulty`, using `user.rating` as the Picks the next puzzle for `user` at `difficulty`, using `user.rating` as the
baseline. baseline.
`:exclude_ids` (default `[]`) skips endgames by id — used to avoid repeating `:exclude_ids` (default `[]`) skips endgames by id — used for the puzzles
the puzzle just played. Returns `nil` when no endgame exists at all. already served in this session. Returns `nil` when no endgame exists at all.
""" """
def next_endgame(%User{} = user, difficulty, opts \\ []) def next_endgame(%User{} = user, difficulty, opts \\ [])
when difficulty in @difficulties do when difficulty in @difficulties do
exclude_ids = Keyword.get(opts, :exclude_ids, []) exclude_ids = Keyword.get(opts, :exclude_ids, [])
band = difficulty_range(user.rating, difficulty) recent_ids = Attempts.recent_endgame_ids(user.id, repeat_window_days())
recent_ids = Attempts.recent_endgame_ids(user.id) target = difficulty_target(user.rating, difficulty)
fresh =
Endgame Endgame
|> in_band(band) |> on_side_of(user.rating, difficulty)
|> skip_ids(exclude_ids) |> skip_ids(exclude_ids ++ recent_ids)
|> skip_ids(recent_ids) |> weighted_one(target)
|> random_one()
fresh || fallback(user.rating, band, exclude_ids)
end
defp fallback(rating, band, exclude_ids) do
Endgame
|> in_band(band)
|> skip_ids(exclude_ids)
|> random_one()
|> case do |> case do
nil -> nearest(rating, exclude_ids) nil -> least_recently_attempted(user.id, exclude_ids)
endgame -> endgame endgame -> endgame
end end
end end
defp nearest(rating, exclude_ids) do # Keep the labels honest: "easy" never serves above the user's rating plus the
# spread, and "hard" never below it minus the spread. "medium" is open, which
# is what lets it reach the rest of the library.
defp on_side_of(query, _rating, :medium), do: query
defp on_side_of(query, rating, :easy),
do: where(query, [e], e.rating <= ^(rating + spread()))
defp on_side_of(query, rating, :hard),
do: where(query, [e], e.rating >= ^(rating - spread()))
# Draw one row with probability proportional to
# `exp(-|rating - target| / spread)`: an exponential race, where the row with
# the smallest `-ln(U) / weight` wins.
defp weighted_one(query, target) do
spread = spread() * 1.0
target = target * 1.0
query
|> order_by(
[e],
fragment("-ln(1 - random()) * exp(abs(? - ?) / ?)", e.rating, ^target, ^spread)
)
|> limit(1)
|> Repo.one()
end
# Every candidate is excluded, so the repeat window is overruled: serve
# whatever the user has waited longest to see again.
defp least_recently_attempted(user_id, exclude_ids) do
attempted =
Attempt
|> where([a], a.user_id == ^user_id)
|> group_by([a], a.endgame_id)
|> select([a], %{endgame_id: a.endgame_id, last_at: max(a.inserted_at)})
Endgame Endgame
|> skip_ids(exclude_ids) |> skip_ids(exclude_ids)
|> order_by([e], asc: fragment("ABS(? - ?)", e.rating, ^rating)) |> join(:left, [e], a in subquery(attempted), on: a.endgame_id == e.id)
|> order_by([_e, a], asc_nulls_first: a.last_at)
|> order_by([e], fragment("random()"))
|> limit(1) |> limit(1)
|> Repo.one() |> Repo.one()
end end
defp random_one(query) do
query
|> order_by([e], fragment("RANDOM()"))
|> limit(1)
|> Repo.one()
end
defp in_band(query, {nil, max}), do: where(query, [e], e.rating <= ^max)
defp in_band(query, {min, nil}), do: where(query, [e], e.rating >= ^min)
defp in_band(query, {min, max}),
do: where(query, [e], e.rating >= ^min and e.rating <= ^max)
defp skip_ids(query, []), do: query defp skip_ids(query, []), do: query
defp skip_ids(query, ids), do: where(query, [e], e.id not in ^ids) defp skip_ids(query, ids), do: where(query, [e], e.id not in ^ids)
defp setting(key, default) do
:chesstrainer
|> Application.get_env(:puzzles, [])
|> Keyword.get(key, default)
end
end end
+22
View File
@@ -18,6 +18,28 @@ defmodule Chesstrainer.Release do
{:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version)) {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
end end
@doc """
Derives material family themes for the whole library.
Runs in the release without starting the web application: `with_repo/2`
starts just the repository, which is all the derivation needs.
"""
def derive_material, do: with_repo(&Chesstrainer.Endgames.MaterialThemes.derive/0)
@doc """
Derives motif themes from the local tablebase for the whole library.
"""
def derive_motifs, do: with_repo(&Chesstrainer.Endgames.MotifThemes.derive/0)
defp with_repo(fun) do
load_app()
for repo <- repos() do
{:ok, result, _} = Ecto.Migrator.with_repo(repo, fn _repo -> fun.() end)
result
end
end
defp repos do defp repos do
Application.fetch_env!(@app, :ecto_repos) Application.fetch_env!(@app, :ecto_repos)
end end
+184 -3
View File
@@ -4,6 +4,8 @@ defmodule Chesstrainer.Themes do
""" """
import Ecto.Query, warn: false import Ecto.Query, warn: false
alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Accounts.Scope
alias Chesstrainer.Repo alias Chesstrainer.Repo
alias Chesstrainer.Themes.Theme alias Chesstrainer.Themes.Theme
@@ -74,9 +76,26 @@ defmodule Chesstrainer.Themes do
""" """
def get_theme!(id), do: Repo.get!(Theme, id) def get_theme!(id), do: Repo.get!(Theme, id)
@doc """
Gets a single endgame theme by its slug.
Returns `nil` when no endgame theme has that slug.
"""
def get_theme_by_slug(slug) when is_binary(slug) do
Repo.one(
from t in Theme,
where: t.slug == ^slug and t.category == :endgame,
limit: 1
)
end
@doc """ @doc """
Creates a theme. Creates a theme.
This is the unscoped path used by internal callers such as seeds, fixtures and
the admin picker, which are already behind an authorization check. Prefer
`create_theme/2` wherever a scope is available.
## Examples ## Examples
iex> create_theme(%{field: value}) iex> create_theme(%{field: value})
@@ -92,6 +111,21 @@ defmodule Chesstrainer.Themes do
|> Repo.insert() |> Repo.insert()
end end
@doc """
Creates a theme on behalf of an administrator.
Members cannot introduce new theme names; their contribution path is a
suggestion, which a moderator reviews. Returns `{:error, :unauthorized}`
for a scope that cannot manage themes.
"""
def create_theme(%Scope{} = scope, attrs) do
if Policy.can?(scope, :manage_themes) do
create_theme(attrs)
else
{:error, :unauthorized}
end
end
@doc """ @doc """
Updates a theme. Updates a theme.
@@ -160,20 +194,167 @@ defmodule Chesstrainer.Themes do
@doc """ @doc """
Finds a theme by name (trimmed and case-insensitive) for a category, creating it Finds a theme by name (trimmed and case-insensitive) for a category, creating it
if it does not exist. if it does not exist.
Options:
* `:kind` - the kind for a newly created theme; defaults to `:technique`
This is the picker's helper and is expected to run behind an admin check.
""" """
def get_or_create(name, category) when is_binary(name) do def get_or_create(name, category, opts \\ []) when is_binary(name) do
name = String.trim(name) name = String.trim(name)
if name == "" do if name == "" do
{:error, :blank_name} {:error, :blank_name}
else else
case find_by_name(name, category) do case find_by_name(name, category) do
nil -> create_theme(%{name: name, category: category}) nil ->
theme -> {:ok, theme} create_theme(%{
name: name,
category: category,
kind: Keyword.get(opts, :kind, :technique)
})
theme ->
{:ok, theme}
end end
end end
end end
@doc """
Replaces every link to `scoped_theme_ids` with the derived links in `links`.
This is for themes that are objectively derived: the pass owns its themes
entirely, so a link's previous source is irrelevant and every link is
rewritten as `derived`. Links to themes outside `scoped_theme_ids` — curated
or community — are untouched.
The operation is a full refresh for the given themes, so it can move an
endgame between families when a rule changes. `links` is a list of
`{endgame_id, theme_id}` pairs.
"""
@spec replace_theme_links([term()], [{Ecto.UUID.t(), term()}]) :: :ok
def replace_theme_links(scoped_theme_ids, links) when is_list(links) do
now = DateTime.utc_now() |> DateTime.truncate(:second)
Repo.transaction(fn ->
if scoped_theme_ids != [] do
Repo.delete_all(
from l in "endgames_themes",
where: l.theme_id in ^scoped_theme_ids
)
end
links
|> Enum.map(fn {endgame_id, theme_id} ->
%{
endgame_id: Ecto.UUID.dump!(endgame_id),
theme_id: theme_id,
source: "derived",
inserted_at: now
}
end)
|> Enum.chunk_every(5_000)
|> Enum.each(fn rows ->
Repo.insert_all("endgames_themes", rows, on_conflict: :nothing)
end)
end)
:ok
end
@link_sources [:curated, :community]
@doc """
Links `theme` to many endgames at once with the given source.
Defaults to `:curated`, which is what the admin tagging workspace writes.
Existing links are left alone, so re-applying is safe. Returns the number of
endgames the link was attempted for.
"""
@spec tag_endgames(Theme.t(), [Ecto.UUID.t()], :curated | :community) ::
{:ok, non_neg_integer()}
def tag_endgames(%Theme{id: theme_id}, endgame_ids, source \\ :curated)
when is_list(endgame_ids) and source in @link_sources do
now = DateTime.utc_now() |> DateTime.truncate(:second)
endgame_ids
|> Enum.uniq()
|> Enum.map(fn endgame_id ->
%{
endgame_id: Ecto.UUID.dump!(endgame_id),
theme_id: theme_id,
source: to_string(source),
inserted_at: now
}
end)
|> Enum.chunk_every(5_000)
|> Enum.each(fn rows ->
Repo.insert_all("endgames_themes", rows, on_conflict: :nothing)
end)
{:ok, length(Enum.uniq(endgame_ids))}
end
@doc """
Removes a link from `theme` to one endgame, but only if it has the given
source.
The tagging workspace removes `:curated` links only, so a derived or
community link can never be deleted by hand. Returns the number removed.
"""
@spec untag_endgame(Theme.t(), Ecto.UUID.t(), :curated | :community) ::
{:ok, non_neg_integer()}
def untag_endgame(%Theme{id: theme_id}, endgame_id, source \\ :curated)
when source in @link_sources do
{count, _} =
Repo.delete_all(
from l in "endgames_themes",
where:
l.theme_id == ^theme_id and l.endgame_id == type(^endgame_id, :binary_id) and
l.source == ^to_string(source)
)
{:ok, count}
end
@doc """
Replaces the derived theme links for one endgame.
Only links whose source is `derived` are removed, so curated and
community-approved links survive every derivation pass. Links that are
already present are left alone, which makes the operation idempotent.
"""
@spec sync_derived_themes(Ecto.UUID.t(), [term()]) :: :ok
def sync_derived_themes(endgame_id, theme_ids) do
now = DateTime.utc_now() |> DateTime.truncate(:second)
Repo.transaction(fn ->
Repo.delete_all(
from l in "endgames_themes",
where: l.endgame_id == type(^endgame_id, :binary_id) and l.source == "derived"
)
rows =
theme_ids
|> Enum.uniq()
|> Enum.map(fn theme_id ->
%{
endgame_id: Ecto.UUID.dump!(endgame_id),
theme_id: theme_id,
source: "derived",
inserted_at: now
}
end)
if rows != [] do
Repo.insert_all("endgames_themes", rows, on_conflict: :nothing)
end
end)
:ok
end
defp find_by_name(name, category) do defp find_by_name(name, category) do
downcased = String.downcase(name) downcased = String.downcase(name)
+83 -6
View File
@@ -1,29 +1,106 @@
defmodule Chesstrainer.Themes.Theme do defmodule Chesstrainer.Themes.Theme do
@moduledoc """
A label describing an endgame's technique or goal.
A theme has a stable `slug` for URLs, a `kind` saying where the label comes
from — `material`, `motif` or `technique` — and an optional description. The
slug is generated from the name when the theme is first created and is then
left alone, so renaming a theme never breaks a link to it.
"""
use Ecto.Schema use Ecto.Schema
import Ecto.Changeset import Ecto.Changeset
@type t :: %__MODULE__{} @type t :: %__MODULE__{}
@kinds [material: "material", motif: "motif", technique: "technique"]
schema "themes" do schema "themes" do
field :name, :string field :name, :string
field :slug, :string
field :description, :string
field :kind, Ecto.Enum, values: @kinds, default: :technique
field :category, Ecto.Enum, values: [endgame: "endgame", opening: "opening", tactic: "tactic"] field :category, Ecto.Enum, values: [endgame: "endgame", opening: "opening", tactic: "tactic"]
timestamps(type: :utc_datetime) timestamps(type: :utc_datetime)
end end
@doc "The kinds a theme can have."
def kinds, do: Keyword.keys(@kinds)
@doc """
Turns a theme name into a URL-safe slug.
Lowercase letters, digits and single hyphens; accents are folded, runs of
other characters collapse to one hyphen, and a blank result becomes
`"theme"`.
"""
@spec slugify(String.t() | nil) :: String.t()
def slugify(name) do
slug =
name
|> to_string()
|> :unicode.characters_to_nfd_binary()
|> String.replace(~r/[\x{0300}-\x{036F}]/u, "")
|> String.downcase()
|> String.replace(~r/[^a-z0-9]+/u, "-")
|> String.trim("-")
if slug == "", do: "theme", else: slug
end
@doc false @doc false
def changeset(theme, attrs) do def changeset(theme, attrs) do
theme theme
|> cast(attrs, [:name, :category]) |> cast(attrs, [:name, :slug, :description, :kind, :category])
|> update_change(:name, fn |> update_change(:name, &trim/1)
name when is_binary(name) -> String.trim(name) |> update_change(:description, &trim/1)
name -> name |> put_slug()
end) |> validate_required([:name, :slug, :kind, :category])
|> validate_required([:name, :category])
|> validate_length(:name, min: 1, max: 60) |> validate_length(:name, min: 1, max: 60)
|> validate_length(:slug, min: 1, max: 80)
|> validate_length(:description, max: 500)
|> validate_format(:slug, ~r/\A[a-z0-9]+(?:-[a-z0-9]+)*\z/,
message: "must be lowercase letters, numbers and single hyphens"
)
|> unique_constraint(:name, |> unique_constraint(:name,
name: :themes_name_category_lower_index, name: :themes_name_category_lower_index,
message: "already exists" message: "already exists"
) )
|> unique_constraint(:slug, message: "is already taken")
|> check_constraint(:kind, name: :themes_kind_in_allowed)
end end
defp put_slug(changeset) do
case get_field(changeset, :slug) do
slug when is_binary(slug) ->
if String.trim(slug) == "" do
generate_slug(changeset)
else
put_change(changeset, :slug, slugify(slug))
end
nil ->
generate_slug(changeset)
end
end
# A new theme starts without a name, so generating a slug from it would only
# produce the fallback. Wait until there is a name to derive from.
defp generate_slug(changeset) do
case get_field(changeset, :name) do
name when is_binary(name) ->
if String.trim(name) == "" do
changeset
else
put_change(changeset, :slug, slugify(name))
end
_ ->
changeset
end
end
defp trim(value) when is_binary(value), do: String.trim(value)
defp trim(value), do: value
end end
@@ -126,8 +126,15 @@ defmodule ChesstrainerWeb.Layouts do
Start training <.icon_arrow /> Start training <.icon_arrow />
</.pill_button> </.pill_button>
<% end %> <% end %>
<div class="nav-menu-tools">
<.colour_mode_toggle />
<.discord_link />
</div>
</div> </div>
<% end %> <% end %>
<.discord_link />
</div> </div>
</nav> </nav>
</header> </header>
@@ -225,6 +232,7 @@ defmodule ChesstrainerWeb.Layouts do
<a href="/terms-conditions">Terms & Conditions</a> <a href="/terms-conditions">Terms & Conditions</a>
<a href="/mentions-legales">Mentions légales</a> <a href="/mentions-legales">Mentions légales</a>
<a href="/sitemap.xml">Sitemap</a> <a href="/sitemap.xml">Sitemap</a>
<.discord_link />
</nav> </nav>
<small>© {@year} {Branding.name()}</small> <small>© {@year} {Branding.name()}</small>
@@ -232,6 +240,35 @@ defmodule ChesstrainerWeb.Layouts do
""" """
end end
@doc """
Renders the Discord invite as an icon-only link.
The glyph is decorative; the `aria-label` carries the link's purpose for
screen readers. Renders nothing when no invite is configured, so environments
without one never show a dead link.
"""
def discord_link(assigns) do
assigns = assign(assigns, :href, Branding.discord_invite_url())
~H"""
<a
:if={@href}
class="discord-link"
href={@href}
target="_blank"
rel="noopener noreferrer"
aria-label={"Join the #{Branding.name()} Discord"}
>
<svg viewBox="0 0 24 24" aria-hidden="true" focusable="false">
<path
fill="currentColor"
d="M20.317 4.3698a19.7913 19.7913 0 0 0-4.8851-1.5152.0741.0741 0 0 0-.0785.0371c-.211.3753-.4447.8648-.6083 1.2495-1.8447-.2762-3.68-.2762-5.4868 0-.1636-.3933-.4058-.8742-.6177-1.2495a.077.077 0 0 0-.0785-.037 19.7363 19.7363 0 0 0-4.8852 1.515.0699.0699 0 0 0-.0321.0277C.5334 9.0458-.319 13.5799.0992 18.0578a.0824.0824 0 0 0 .0312.0561c2.0528 1.5076 4.0413 2.4228 5.9929 3.0294a.0777.0777 0 0 0 .0842-.0276c.4616-.6304.8731-1.2952 1.226-1.9942a.076.076 0 0 0-.0416-.1057c-.6528-.2476-1.2743-.5495-1.8722-.8923a.077.077 0 0 1-.0076-.1277c.1258-.0943.2517-.1923.3718-.2914a.0743.0743 0 0 1 .0776-.0105c3.9278 1.7933 8.18 1.7933 12.0614 0a.0739.0739 0 0 1 .0785.0105c.1202.0991.246.1971.3728.2914a.077.077 0 0 1-.0066.1277c-.5986.3428-1.2201.6447-1.8739.8923a.0766.0766 0 0 0-.0407.1057c.36.699.7715 1.3647 1.225 1.9942a.076.076 0 0 0 .0843.0276c1.9608-.6066 3.9493-1.5218 6.0021-3.0294a.077.077 0 0 0 .0322-.0561c.5008-5.1763-.8398-9.6746-3.5543-13.6607a.061.061 0 0 0-.0312-.0286zM8.02 15.3312c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9555-2.4189 2.157-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.9555 2.4189-2.1569 2.4189zm7.9748 0c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9554-2.4189 2.1569-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.946 2.4189-2.1568 2.4189Z"
/>
</svg>
</a>
"""
end
@doc """ @doc """
Shows the flash group with standard titles and content. Shows the flash group with standard titles and content.
@@ -3,7 +3,7 @@
<head> <head>
<meta charset="utf-8" /> <meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" /> <meta name="viewport" content="width=device-width, initial-scale=1" />
<meta :if={assigns[:noindex]} name="robots" content="noindex" /> <meta :if={assigns[:noindex]} name="robots" content="noindex, nofollow" />
<meta name="csrf-token" content={get_csrf_token()} /> <meta name="csrf-token" content={get_csrf_token()} />
<.live_title <.live_title
@@ -65,7 +65,10 @@
if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return; if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
event.preventDefault(); event.preventDefault();
const buttons = Array.from(document.querySelectorAll("[data-phx-theme]")); // Each breakpoint renders its own copy of the switch, so only the visible
// group takes part in arrow-key navigation.
const buttons = Array.from(document.querySelectorAll("[data-phx-theme]"))
.filter((button) => button.offsetParent !== null);
const offset = event.key === "ArrowRight" ? 1 : -1; const offset = event.key === "ArrowRight" ? 1 : -1;
const index = (buttons.indexOf(button) + offset + buttons.length) % buttons.length; const index = (buttons.indexOf(button) + offset + buttons.length) % buttons.length;
const next = buttons[index]; const next = buttons[index];
@@ -10,7 +10,7 @@ defmodule ChesstrainerWeb.HealthController do
status = if health.status == "down", do: :service_unavailable, else: :ok status = if health.status == "down", do: :service_unavailable, else: :ok
conn conn
|> put_resp_header("x-robots-tag", "noindex") |> put_resp_header("x-robots-tag", "noindex, nofollow")
|> put_status(status) |> put_status(status)
|> json(health) |> json(health)
end end
@@ -40,8 +40,11 @@
</div> </div>
</section> </section>
<%!-- <section class="learning-strip" id="method"> <section class="learning-strip" id="method">
<p>Built for the part of chess that decides everything.</p> <figure class="learning-quote">
<blockquote>“The hardest game to win is a won game.”</blockquote>
<figcaption>— Emmanuel Lasker</figcaption>
</figure>
<div class="stat"> <div class="stat">
<strong>{count_label(@puzzle_count)}</strong> <strong>{count_label(@puzzle_count)}</strong>
<span>puzzles</span> <span>puzzles</span>
@@ -50,9 +53,9 @@
<strong>{@user_count}</strong> <strong>{@user_count}</strong>
<span>Players improving their endgame</span> <span>Players improving their endgame</span>
</div> </div>
</section> --%> </section>
<%!-- <section class="puzzle-section" id="puzzles"> <section class="puzzle-section" id="puzzles">
<div class="section-heading"> <div class="section-heading">
<div> <div>
<span class="section-kicker">Choose your lesson</span> <span class="section-kicker">Choose your lesson</span>
@@ -65,16 +68,16 @@
that you’ll recognise over the board. that you’ll recognise over the board.
</p> </p>
</div> </div>
<div class="puzzle-grid"> <div class="puzzle-coming-soon">
<%= for {endgame, index} <- Enum.with_index(@endgames) do %> <div class="eyebrow">
<.puzzle_card <.icon_spark /> Coming soon
endgame={endgame}
index={index}
active={@active_endgame && endgame.id == @active_endgame.id}
/>
<% end %>
</div> </div>
</section> --%> <strong>The lesson library is on its way.</strong>
<p>
A growing set of positions, each teaching one idea. Today’s puzzle is already live.
</p>
</div>
</section>
<.mailing_list_signup :if={@mailing_list_enabled} /> <.mailing_list_signup :if={@mailing_list_enabled} />
@@ -6,19 +6,20 @@ defmodule ChesstrainerWeb.SitemapController do
them and they render the same interactive surface with only the position them and they render the same interactive surface with only the position
differing, so listing them all would be index bloat. Revisit that if public differing, so listing them all would be index bloat. Revisit that if public
browse pages (by Key or theme) exist and are worth ranking. browse pages (by Key or theme) exist and are worth ranking.
No `<lastmod>` is emitted: none of these pages has a stored modification time,
and an invented date (such as "today" on every request) teaches crawlers to
distrust the sitemap.
""" """
use ChesstrainerWeb, :controller use ChesstrainerWeb, :controller
def index(conn, _params) do def index(conn, _params) do
# The landing page changes every day (daily puzzle, counts), so its
# lastmod is honest. The legal pages have no stored modification time, and
# an invented lastmod is worse than none.
entries = [ entries = [
{url(conn, ~p"/"), Date.utc_today()}, url(conn, ~p"/"),
{url(conn, ~p"/privacy"), nil}, url(conn, ~p"/privacy"),
{url(conn, ~p"/terms-conditions"), nil}, url(conn, ~p"/terms-conditions"),
{url(conn, ~p"/mentions-legales"), nil} url(conn, ~p"/mentions-legales")
] ]
conn conn
@@ -28,8 +29,8 @@ defmodule ChesstrainerWeb.SitemapController do
defp render_sitemap(entries) do defp render_sitemap(entries) do
urls = urls =
Enum.map_join(entries, fn {loc, lastmod} -> Enum.map_join(entries, fn loc ->
" <url><loc>#{escape(loc)}</loc>#{lastmod_entry(lastmod)}</url>\n" " <url><loc>#{escape(loc)}</loc></url>\n"
end) end)
""" """
@@ -39,9 +40,6 @@ defmodule ChesstrainerWeb.SitemapController do
""" """
end end
defp lastmod_entry(nil), do: ""
defp lastmod_entry(%Date{} = date), do: "<lastmod>#{Date.to_iso8601(date)}</lastmod>"
# Templates escape automatically; this response is built as a plain string, # Templates escape automatically; this response is built as a plain string,
# so XML-significant characters must be escaped here. # so XML-significant characters must be escaped here.
defp escape(value) do defp escape(value) do
@@ -12,14 +12,6 @@ defmodule ChesstrainerWeb.UserSessionController do
authenticate(conn, user_params, ~p"/users/log-in", nil) authenticate(conn, user_params, ~p"/users/log-in", nil)
end end
def create_admin(conn, %{"user" => user_params}) do
if ChesstrainerWeb.prelaunch?() do
authenticate(conn, user_params, ~p"/admin/log-in", ~p"/admin/endgames")
else
authenticate(conn, user_params, ~p"/users/log-in", nil)
end
end
defp authenticate(conn, user_params, failure_path, success_path) do defp authenticate(conn, user_params, failure_path, success_path) do
%{"email" => login} = user_params %{"email" => login} = user_params
address = ClientAddress.from_conn(conn) address = ClientAddress.from_conn(conn)
+7 -1
View File
@@ -19,12 +19,18 @@ defmodule ChesstrainerWeb.Endpoint do
# #
# When code reloading is disabled (e.g., in production), # When code reloading is disabled (e.g., in production),
# the `gzip` option is enabled to serve compressed # the `gzip` option is enabled to serve compressed
# static files generated by running `phx.digest`. # static files generated by running `phx.digest`, and the cache headers promise
# a year. Build output is digested, and the stable-name assets (fonts, piece
# art, icons) only change when the file is renamed, so a long max-age is safe
# and keeps browsers and the CDN off the origin. Dev keeps plain `public` so
# edits show up immediately.
plug Plug.Static, plug Plug.Static,
at: "/", at: "/",
from: :chesstrainer, from: :chesstrainer,
gzip: not code_reloading?, gzip: not code_reloading?,
only: ChesstrainerWeb.static_paths(), only: ChesstrainerWeb.static_paths(),
cache_control_for_etags:
if(code_reloading?, do: "public", else: "public, max-age=31536000, immutable"),
raise_on_missing_only: code_reloading? raise_on_missing_only: code_reloading?
# Code reloading can be explicitly enabled under the # Code reloading can be explicitly enabled under the
@@ -11,6 +11,12 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
{"Tactic", "tactic"} {"Tactic", "tactic"}
] ]
@kind_options [
{"Technique", "technique"},
{"Motif", "motif"},
{"Material", "material"}
]
@impl true @impl true
def render(assigns) do def render(assigns) do
~H""" ~H"""
@@ -21,18 +27,31 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
{@page_title} {@page_title}
<:subtitle> <:subtitle>
Themes group endgames for filtering. Names must be unique within a category, Themes group endgames for filtering. Names must be unique within a category,
ignoring case. ignoring case. The slug is generated from the name and stays fixed afterwards,
so links to a theme keep working when it is renamed.
</:subtitle> </:subtitle>
</.header> </.header>
<.form for={@form} id="theme-form" phx-change="validate" phx-submit="save"> <.form for={@form} id="theme-form" phx-change="validate" phx-submit="save">
<.input field={@form[:name]} type="text" label="Name" autocomplete="off" required /> <.input field={@form[:name]} type="text" label="Name" autocomplete="off" required />
<.input
field={@form[:kind]}
type="select"
label="Kind"
options={@kind_options}
/>
<.input <.input
field={@form[:category]} field={@form[:category]}
type="select" type="select"
label="Category" label="Category"
options={@category_options} options={@category_options}
/> />
<.input
field={@form[:description]}
type="textarea"
label="Description"
rows="3"
/>
<footer> <footer>
<.button phx-disable-with="Saving..." variant="primary">Save theme</.button> <.button phx-disable-with="Saving..." variant="primary">Save theme</.button>
@@ -54,6 +73,7 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
socket socket
|> assign(:page_title, "New theme") |> assign(:page_title, "New theme")
|> assign(:theme, theme) |> assign(:theme, theme)
|> assign(:kind_options, @kind_options)
|> assign(:category_options, @category_options) |> assign(:category_options, @category_options)
|> assign(:form, to_form(Themes.change_theme(theme))) |> assign(:form, to_form(Themes.change_theme(theme)))
end end
@@ -64,6 +84,7 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
socket socket
|> assign(:page_title, "Edit theme") |> assign(:page_title, "Edit theme")
|> assign(:theme, theme) |> assign(:theme, theme)
|> assign(:kind_options, @kind_options)
|> assign(:category_options, @category_options) |> assign(:category_options, @category_options)
|> assign(:form, to_form(Themes.change_theme(theme))) |> assign(:form, to_form(Themes.change_theme(theme)))
end end
@@ -87,13 +108,16 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
end end
defp save_theme(socket, :new, theme_params) do defp save_theme(socket, :new, theme_params) do
case Themes.create_theme(theme_params) do case Themes.create_theme(socket.assigns.current_scope, theme_params) do
{:ok, _theme} -> {:ok, _theme} ->
{:noreply, {:noreply,
socket socket
|> put_flash(:info, "Theme created successfully.") |> put_flash(:info, "Theme created successfully.")
|> push_navigate(to: ~p"/admin/themes")} |> push_navigate(to: ~p"/admin/themes")}
{:error, :unauthorized} ->
{:noreply, put_flash(socket, :error, "You are not authorized to manage themes.")}
{:error, %Ecto.Changeset{} = changeset} -> {:error, %Ecto.Changeset{} = changeset} ->
{:noreply, assign(socket, :form, to_form(changeset, action: :insert))} {:noreply, assign(socket, :form, to_form(changeset, action: :insert))}
end end
@@ -2,6 +2,7 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
use ChesstrainerWeb, :live_view use ChesstrainerWeb, :live_view
alias Chesstrainer.Accounts.Policy alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Endgames
alias Chesstrainer.Themes alias Chesstrainer.Themes
@category_options [ @category_options [
@@ -20,7 +21,8 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
<.header> <.header>
Themes Themes
<:subtitle> <:subtitle>
Themes group endgames for filtering and puzzle selection. Deleting a theme detaches Themes group endgames for filtering and puzzle selection. Coverage shows how
many endgames carry a theme out of the whole library. Deleting a theme detaches
it from every endgame and leaves the endgames intact. it from every endgame and leaves the endgames intact.
</:subtitle> </:subtitle>
<:actions> <:actions>
@@ -69,26 +71,36 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
<thead> <thead>
<tr> <tr>
<th>Name</th> <th>Name</th>
<th>Kind</th>
<th>Category</th> <th>Category</th>
<th>Used by</th> <th>Coverage</th>
<th><span class="sr-only">Actions</span></th> <th><span class="sr-only">Actions</span></th>
</tr> </tr>
</thead> </thead>
<tbody id="themes"> <tbody id="themes">
<tr :for={{theme, usage_count} <- @themes} id={"theme-#{theme.id}"}> <tr :for={{theme, usage_count} <- @themes} id={"theme-#{theme.id}"}>
<td>{theme.name}</td> <td>{theme.name}</td>
<td>{theme.kind}</td>
<td>{theme.category}</td> <td>{theme.category}</td>
<td> <td>
<span id={"theme-usage-#{theme.id}"}>{usage_label(usage_count)}</span> <span id={"theme-usage-#{theme.id}"}>
{coverage_label(usage_count, @total_endgames)}
</span>
</td> </td>
<td class="w-0 font-semibold"> <td class="w-0 font-semibold">
<div class="flex gap-4"> <div class="flex gap-4">
<.link
:if={theme.category == :endgame and theme.kind == :technique}
navigate={~p"/admin/themes/#{theme.id}/tag"}
>
Tag
</.link>
<.link navigate={~p"/admin/themes/#{theme.id}/edit"}>Edit</.link> <.link navigate={~p"/admin/themes/#{theme.id}/edit"}>Edit</.link>
<.link <.link
phx-click="delete" phx-click="delete"
phx-value-id={theme.id} phx-value-id={theme.id}
data-confirm={ data-confirm={
"Delete #{theme.name}? Used by #{usage_label(usage_count)}. " <> "Delete #{theme.name}? Used by #{coverage_label(usage_count, @total_endgames)}. " <>
"The endgames will be kept and simply detached." "The endgames will be kept and simply detached."
} }
> >
@@ -152,9 +164,10 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
category: socket.assigns.category category: socket.assigns.category
) )
assign(socket, :themes, themes) assign(socket, themes: themes, total_endgames: Endgames.count_endgames())
end end
defp usage_label(1), do: "1 endgame" defp coverage_label(count, total) do
defp usage_label(count), do: "#{count} endgames" "#{count} of #{total} #{if total == 1, do: "endgame", else: "endgames"}"
end
end end
@@ -0,0 +1,460 @@
defmodule ChesstrainerWeb.Admin.ThemeLive.Tag do
@moduledoc """
Workspace for applying a technique theme to endgames by family.
Candidates are grouped by Key so an admin tags a whole family rather than
individual rows. Boards are previews only; nothing here starts a puzzle.
Only technique themes can be tagged, because material themes are derived and
a hand-made link would be erased by the next refresh.
"""
use ChesstrainerWeb, :live_view
alias Chesstrainer.Endgames
alias Chesstrainer.Game
alias Chesstrainer.Themes
import ChesstrainerWeb.Board.BoardComponent
@page_size 24
@impl true
def render(assigns) do
~H"""
<Layouts.app flash={@flash} wide>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
Tag “{@theme.name}”
<:subtitle>
Pick a family, preview the positions and apply the theme in bulk. The links are
recorded as curated, so derivation never overwrites them.
</:subtitle>
<:actions>
<.button navigate={~p"/admin/themes"}>
<.icon name="hero-arrow-left" /> All themes
</.button>
</:actions>
</.header>
<.form
for={@theme_form}
id="theme-workspace-form"
phx-change="select_theme"
class="mb-6 max-w-md"
>
<.input
field={@theme_form[:theme_id]}
type="select"
label="Technique theme"
options={@theme_options}
/>
</.form>
<div class="mb-6 flex flex-wrap gap-6 text-sm">
<span>
<span class="font-semibold" id="tagged-count">{@tagged_count}</span> tagged
</span>
<span>
<span class="font-semibold" id="candidate-count">{@candidate_count}</span> candidates
</span>
</div>
<div
:if={MapSet.size(@selected) > 0}
id="selection-bar"
class="sticky top-0 z-10 mb-6 flex flex-wrap items-center gap-3 rounded-lg border border-primary/30 bg-base-100 p-3 text-sm"
>
<span class="font-semibold">{MapSet.size(@selected)} selected</span>
<button
type="button"
id="apply-theme"
phx-click="apply"
class="font-semibold text-primary-text"
>
Apply “{@theme.name}”
</button>
<button type="button" phx-click="clear_selection" class="text-base-content/70">
Clear selection
</button>
</div>
<section class="mb-12">
<h2 class="mb-3 text-lg font-semibold">Candidates</h2>
<p :if={@candidate_groups == []} class="text-base-content/70">
Every endgame already carries this theme.
</p>
<table :if={@candidate_groups != []} class={table_class()}>
<thead>
<tr>
<th>Key</th>
<th>Endgames</th>
<th><span class="sr-only">Actions</span></th>
</tr>
</thead>
<tbody>
<tr :for={{key, count} <- @candidate_groups} id={"candidates-#{group_id(key)}"}>
<td class="font-mono">{key}</td>
<td>{count}</td>
<td class="w-0">
<button
type="button"
id={"toggle-candidates-#{group_id(key)}"}
phx-click="toggle_group"
phx-value-key={key}
phx-value-view="candidates"
class="font-semibold text-primary-text"
>
{open_label(@open, key, "candidates")}
</button>
</td>
</tr>
</tbody>
</table>
<.group_panel
:if={@open && @open.view == "candidates"}
view="candidates"
group={@open.key}
items={@items}
selected={@selected}
page={@page}
pages={@pages}
/>
</section>
<section>
<h2 class="mb-3 text-lg font-semibold">Curated links</h2>
<p :if={@tagged_groups == []} class="text-base-content/70">
No endgame carries this theme yet.
</p>
<table :if={@tagged_groups != []} class={table_class()}>
<thead>
<tr>
<th>Key</th>
<th>Endgames</th>
<th><span class="sr-only">Actions</span></th>
</tr>
</thead>
<tbody>
<tr :for={{key, count} <- @tagged_groups} id={"tagged-#{group_id(key)}"}>
<td class="font-mono">{key}</td>
<td>{count}</td>
<td class="w-0">
<button
type="button"
id={"toggle-tagged-#{group_id(key)}"}
phx-click="toggle_group"
phx-value-key={key}
phx-value-view="tagged"
class="font-semibold text-primary-text"
>
{open_label(@open, key, "tagged")}
</button>
</td>
</tr>
</tbody>
</table>
<.group_panel
:if={@open && @open.view == "tagged"}
view="tagged"
group={@open.key}
items={@items}
selected={@selected}
page={@page}
pages={@pages}
/>
</section>
</Layouts.app>
"""
end
attr :view, :string, required: true
attr :group, :string, required: true
attr :items, :list, required: true
attr :selected, :any, required: true
attr :page, :integer, required: true
attr :pages, :integer, required: true
defp group_panel(assigns) do
~H"""
<div id="group-panel" class="mt-4">
<div :if={@view == "candidates"} class="mb-3 flex gap-3 text-sm">
<button
type="button"
id="select-page"
phx-click="select_page"
class="font-semibold text-primary-text"
>
Select this page
</button>
<span class="text-base-content/60">{@group}</span>
</div>
<p :if={@items == []} class="text-base-content/70">No endgames on this page.</p>
<div class="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
<div
:for={endgame <- @items}
id={"endgame-#{endgame.id}"}
class="rounded-lg border border-base-300 p-3"
>
<.board
game={endgame.game}
myself={nil}
interactive={false}
class="mb-2 w-full max-w-[240px]"
/>
<p class="break-all font-mono text-xs text-base-content/60">{endgame.fen}</p>
<label :if={@view == "candidates"} class="mt-2 flex items-center gap-2 text-sm">
<input
type="checkbox"
id={"select-#{endgame.id}"}
checked={MapSet.member?(@selected, endgame.id)}
phx-click="toggle_select"
phx-value-id={endgame.id}
/> Select
</label>
<button
:if={@view == "tagged"}
type="button"
id={"remove-#{endgame.id}"}
phx-click="remove"
phx-value-id={endgame.id}
class="mt-2 text-sm font-semibold text-error"
>
Remove
</button>
</div>
</div>
<div :if={@pages > 1} class="mt-4 flex items-center gap-3 text-sm">
<button
type="button"
phx-click="page"
phx-value-page={@page - 1}
disabled={@page <= 1}
class="font-semibold disabled:opacity-40"
>
Previous
</button>
<span>Page {@page} of {@pages}</span>
<button
type="button"
phx-click="page"
phx-value-page={@page + 1}
disabled={@page >= @pages}
class="font-semibold disabled:opacity-40"
>
Next
</button>
</div>
</div>
"""
end
@impl true
def mount(%{"id" => id}, _session, socket) do
theme = Themes.get_theme!(id)
if theme.category == :endgame and theme.kind == :technique do
{:ok,
socket
|> assign(:page_title, "Tag #{theme.name}")
|> assign(:theme, theme)
|> assign(:selected, MapSet.new())
|> assign(:open, nil)
|> assign(:items, [])
|> assign(:page, 1)
|> assign(:pages, 1)
|> assign_theme_options()
|> load_counts()}
else
{:ok,
socket
|> put_flash(
:error,
"Only technique themes can be tagged by hand; material themes are derived."
)
|> push_navigate(to: ~p"/admin/themes")}
end
end
@impl true
def handle_event("select_theme", %{"theme_id" => id}, socket) do
if to_string(socket.assigns.theme.id) == id do
{:noreply, socket}
else
{:noreply, push_navigate(socket, to: ~p"/admin/themes/#{id}/tag")}
end
end
def handle_event("toggle_group", %{"key" => key, "view" => view}, socket) do
case socket.assigns.open do
%{key: ^key, view: ^view} ->
{:noreply, assign(socket, open: nil, items: [], page: 1, pages: 1)}
_ ->
{:noreply, open_group(socket, key, view, 1)}
end
end
def handle_event("page", %{"page" => page}, socket) do
case socket.assigns.open do
nil ->
{:noreply, socket}
%{key: key, view: view} ->
{:noreply, open_group(socket, key, view, parse_page(page))}
end
end
def handle_event("toggle_select", %{"id" => id}, socket) do
selected =
if MapSet.member?(socket.assigns.selected, id) do
MapSet.delete(socket.assigns.selected, id)
else
MapSet.put(socket.assigns.selected, id)
end
{:noreply, assign(socket, :selected, selected)}
end
def handle_event("select_page", _params, socket) do
page_ids = Enum.map(socket.assigns.items, & &1.id)
selected = Enum.reduce(page_ids, socket.assigns.selected, &MapSet.put(&2, &1))
{:noreply, assign(socket, :selected, selected)}
end
def handle_event("clear_selection", _params, socket) do
{:noreply, assign(socket, :selected, MapSet.new())}
end
def handle_event("apply", _params, socket) do
selected = MapSet.to_list(socket.assigns.selected)
if selected == [] do
{:noreply, put_flash(socket, :error, "Select at least one endgame.")}
else
{:ok, count} = Themes.tag_endgames(socket.assigns.theme, selected, :curated)
{:noreply,
socket
|> put_flash(:info, "Tagged #{count} endgame(s) with “#{socket.assigns.theme.name}”.")
|> assign(:selected, MapSet.new())
|> assign(open: nil, items: [], page: 1, pages: 1)
|> load_counts()}
end
end
def handle_event("remove", %{"id" => id}, socket) do
{:ok, removed} = Themes.untag_endgame(socket.assigns.theme, id, :curated)
socket =
socket
|> put_flash(:info, removal_message(removed, socket.assigns.theme))
|> load_counts()
|> refresh_open()
{:noreply, socket}
end
defp removal_message(0, theme), do: "That endgame had no curated “#{theme.name}” link."
defp removal_message(_, theme), do: "Removed “#{theme.name}” from the endgame."
defp refresh_open(%{assigns: %{open: nil}} = socket), do: socket
defp refresh_open(%{assigns: %{open: %{key: key, view: view}, page: page}} = socket) do
open_group(socket, key, view, page)
end
defp open_group(socket, key, view, page) do
count = group_count(socket, key, view)
pages = max(ceil_div(count, @page_size), 1)
page = page |> max(1) |> min(pages)
endgames =
Endgames.list_endgames_for_key(key, filters_for(socket.assigns.theme, view),
limit: @page_size,
offset: (page - 1) * @page_size
)
|> Enum.map(&Map.put(&1, :game, board_game(&1.fen)))
assign(socket,
open: %{key: key, view: view},
items: endgames,
page: page,
pages: pages
)
end
defp filters_for(%{id: theme_id}, "tagged"), do: %{with_theme: {theme_id, :curated}}
defp filters_for(%{id: theme_id}, "candidates"), do: %{without_theme: theme_id}
defp group_count(socket, key, view) do
groups =
if view == "tagged", do: socket.assigns.tagged_groups, else: socket.assigns.candidate_groups
Enum.find_value(groups, 0, fn
{^key, count} -> count
_ -> nil
end)
end
defp parse_page(page) when is_integer(page), do: page
defp parse_page(page) when is_binary(page) do
case Integer.parse(page) do
{value, _} -> value
:error -> 1
end
end
defp ceil_div(0, _), do: 0
defp ceil_div(count, size), do: div(count + size - 1, size)
defp load_counts(socket) do
theme = socket.assigns.theme
tagged = Endgames.list_key_groups(%{with_theme: {theme.id, :curated}})
candidates = Endgames.list_key_groups(%{without_theme: theme.id})
assign(socket,
tagged_groups: tagged,
candidate_groups: candidates,
tagged_count: total(tagged),
candidate_count: total(candidates)
)
end
defp total(groups), do: Enum.reduce(groups, 0, fn {_key, count}, acc -> acc + count end)
defp assign_theme_options(socket) do
options =
Themes.list_themes()
|> Enum.filter(&(&1.category == :endgame and &1.kind == :technique))
|> Enum.sort_by(& &1.name)
|> Enum.map(&{&1.name, &1.id})
assign(socket,
theme_options: options,
theme_form: to_form(%{"theme_id" => to_string(socket.assigns.theme.id)})
)
end
defp board_game(fen) do
case Game.game_from_fen(fen, :endgame) do
{:ok, game} -> game
{:error, :invalid_fen, game} -> game
end
end
defp open_label(%{key: key, view: view}, key, view), do: "Hide"
defp open_label(_open, _key, _view), do: "Show"
defp group_id(key), do: String.replace(key, ~r/[^A-Za-z0-9]+/, "-")
end
@@ -135,7 +135,10 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
@impl true @impl true
def mount(_params, _session, socket) do def mount(_params, _session, socket) do
socket = assign(socket, :limit, GuestLimits.limit()) socket =
socket
|> assign(:limit, GuestLimits.limit())
|> assign(:served_ids, [])
cond do cond do
signed_in?(socket) -> signed_in?(socket) ->
@@ -217,11 +220,7 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
|> assign(:limit_reached, retry_ms) |> assign(:limit_reached, retry_ms)
{:ok, _remaining} -> {:ok, _remaining} ->
endgame = case random_unserved(socket) do
Endgames.random_endgame(exclude_ids: [socket.assigns.endgame.id]) ||
Endgames.random_endgame()
case endgame do
nil -> assign(socket, :empty, :exhausted) nil -> assign(socket, :empty, :exhausted)
endgame -> start_guest_puzzle(socket, socket.assigns.guest_address, endgame) endgame -> start_guest_puzzle(socket, socket.assigns.guest_address, endgame)
end end
@@ -234,13 +233,21 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
{:ok, limit_wall(socket, address, retry_ms)} {:ok, limit_wall(socket, address, retry_ms)}
{:ok, _remaining} -> {:ok, _remaining} ->
case Endgames.random_endgame() do case random_unserved(socket) do
nil -> {:ok, empty_pool(socket, address)} nil -> {:ok, empty_pool(socket, address)}
endgame -> {:ok, start_guest_puzzle(socket, address, endgame)} endgame -> {:ok, start_guest_puzzle(socket, address, endgame)}
end end
end end
end end
# Prefer an endgame this visitor has not seen in this session. Once the whole
# pool is served — only possible on a very long guest session — start over
# rather than dead-end.
defp random_unserved(socket) do
Endgames.random_endgame(exclude_ids: socket.assigns.served_ids) ||
Endgames.random_endgame()
end
defp start_guest_puzzle(socket, address, endgame) do defp start_guest_puzzle(socket, address, endgame) do
case GuestLimits.take(address) do case GuestLimits.take(address) do
{:ok, remaining} -> {:ok, remaining} ->
@@ -250,6 +257,7 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
|> assign(:guest_remaining, remaining) |> assign(:guest_remaining, remaining)
|> assign(:limit_reached, nil) |> assign(:limit_reached, nil)
|> assign(:empty, nil) |> assign(:empty, nil)
|> assign(:served_ids, [endgame.id | socket.assigns.served_ids])
|> PlayCore.init(endgame, page_title: "Train") |> PlayCore.init(endgame, page_title: "Train")
{:limit_reached, retry_ms} -> {:limit_reached, retry_ms} ->
+13 -11
View File
@@ -106,7 +106,7 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
id="pool-exhausted" id="pool-exhausted"
class="rounded-xl border border-hairline bg-canvas-raised p-6" class="rounded-xl border border-hairline bg-canvas-raised p-6"
> >
<h2 class="text-lg font-semibold">You've finished every puzzle at this difficulty</h2> <h2 class="text-lg font-semibold">You've played every puzzle available right now</h2>
<p class="mt-1 text-sm text-muted"> <p class="mt-1 text-sm text-muted">
There are no more {difficulty_label(@session.difficulty)} puzzles right now. There are no more {difficulty_label(@session.difficulty)} puzzles right now.
Try again, or pick another difficulty. Try again, or pick another difficulty.
@@ -161,7 +161,7 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
<div> <div>
<h2 class="text-lg font-semibold">Choose a difficulty</h2> <h2 class="text-lg font-semibold">Choose a difficulty</h2>
<p class="mt-1 text-sm text-muted"> <p class="mt-1 text-sm text-muted">
Difficulty bands are ±{Puzzles.band_width()} around your rating. Easy draws easier endgames, hard draws harder ones — your rating sets the centre.
</p> </p>
</div> </div>
<.link <.link
@@ -190,7 +190,7 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
</.button> </.button>
</div> </div>
<div class="mt-4 grid gap-2"> <div class="mt-4 grid gap-2">
<%= for {difficulty, label, description} <- difficulty_options(@user_rating) do %> <%= for {difficulty, label, description} <- difficulty_options() do %>
<.button <.button
id={"difficulty-#{difficulty}"} id={"difficulty-#{difficulty}"}
phx-click="start_session" phx-click="start_session"
@@ -315,7 +315,8 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
started_at_ms: System.system_time(:millisecond), started_at_ms: System.system_time(:millisecond),
baseline: socket.assigns.user_rating, baseline: socket.assigns.user_rating,
count: 0, count: 0,
sum_ms: 0 sum_ms: 0,
served_ids: [endgame.id]
} }
socket socket
@@ -333,13 +334,16 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
if session do if session do
case Puzzles.next_endgame(selection_user(socket), session.difficulty, case Puzzles.next_endgame(selection_user(socket), session.difficulty,
exclude_ids: [socket.assigns.endgame.id] exclude_ids: session.served_ids
) do ) do
nil -> nil ->
assign(socket, :pool, %{difficulty: session.difficulty}) assign(socket, :pool, %{difficulty: session.difficulty})
endgame -> endgame ->
session = %{session | served_ids: [endgame.id | session.served_ids]}
socket socket
|> assign(:session, session)
|> assign(:pool, nil) |> assign(:pool, nil)
|> assign(:puzzle_started_mono, System.monotonic_time(:millisecond)) |> assign(:puzzle_started_mono, System.monotonic_time(:millisecond))
|> assign(:puzzle_counted, false) |> assign(:puzzle_counted, false)
@@ -395,13 +399,11 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
defp parse_difficulty(_value), do: :medium defp parse_difficulty(_value), do: :medium
defp difficulty_options(rating) do defp difficulty_options do
width = Puzzles.band_width()
[ [
{:easy, "Easy", "below #{round(rating - width)}"}, {:easy, "Easy", "easier than your rating"},
{:medium, "Medium", "#{round(rating - width)}–#{round(rating + width)}"}, {:medium, "Medium", "around your rating"},
{:hard, "Hard", "above #{round(rating + width)}"} {:hard, "Hard", "harder than your rating"}
] ]
end end
+2 -7
View File
@@ -27,7 +27,7 @@ defmodule ChesstrainerWeb.UserLive.Login do
:let={f} :let={f}
for={@form} for={@form}
id="login_form_password" id="login_form_password"
action={@login_action} action={~p"/users/log-in"}
phx-submit="submit_password" phx-submit="submit_password"
phx-trigger-action={@trigger_submit} phx-trigger-action={@trigger_submit}
> >
@@ -75,17 +75,12 @@ defmodule ChesstrainerWeb.UserLive.Login do
get_in(socket.assigns, [:current_scope, Access.key(:user), Access.key(:email)]) get_in(socket.assigns, [:current_scope, Access.key(:user), Access.key(:email)])
form = to_form(%{"email" => email}, as: "user") form = to_form(%{"email" => email}, as: "user")
prelaunch = ChesstrainerWeb.prelaunch?()
login_action =
if prelaunch, do: ~p"/admin/log-in", else: ~p"/users/log-in"
{:ok, {:ok,
assign(socket, assign(socket,
form: form, form: form,
trigger_submit: false, trigger_submit: false,
prelaunch: prelaunch, prelaunch: ChesstrainerWeb.prelaunch?()
login_action: login_action
)} )}
end end
+1 -1
View File
@@ -19,6 +19,7 @@ defmodule ChesstrainerWeb.Plugs.Prelaunch do
/health /health
/robots.txt /robots.txt
/sitemap.xml /sitemap.xml
/users/log-in
/favicon.ico /favicon.ico
/favicon.svg /favicon.svg
/favicon-16x16.png /favicon-16x16.png
@@ -40,7 +41,6 @@ defmodule ChesstrainerWeb.Plugs.Prelaunch do
/assets /assets
/fonts /fonts
/images /images
/dev
) )
def init(opts), do: opts def init(opts), do: opts
+4 -5
View File
@@ -36,8 +36,6 @@ defmodule ChesstrainerWeb.Router do
get "/terms-conditions", PageController, :terms_conditions get "/terms-conditions", PageController, :terms_conditions
get "/mentions-legales", PageController, :mentions_legales get "/mentions-legales", PageController, :mentions_legales
post "/mailing-list", MailingListController, :create post "/mailing-list", MailingListController, :create
get "/mailing-list/confirm/:token", MailingListController, :confirm
post "/admin/log-in", UserSessionController, :create_admin
end end
scope "/admin", ChesstrainerWeb do scope "/admin", ChesstrainerWeb do
@@ -57,6 +55,7 @@ defmodule ChesstrainerWeb.Router do
live "/themes", Admin.ThemeLive.Index, :index live "/themes", Admin.ThemeLive.Index, :index
live "/themes/new", Admin.ThemeLive.Form, :new live "/themes/new", Admin.ThemeLive.Form, :new
live "/themes/:id/edit", Admin.ThemeLive.Form, :edit live "/themes/:id/edit", Admin.ThemeLive.Form, :edit
live "/themes/:id/tag", Admin.ThemeLive.Tag, :tag
live "/users", Admin.UserLive.Index, :index live "/users", Admin.UserLive.Index, :index
live "/users/new", Admin.UserLive.New, :new live "/users/new", Admin.UserLive.New, :new
@@ -89,7 +88,7 @@ defmodule ChesstrainerWeb.Router do
## Authentication routes ## Authentication routes
scope "/", ChesstrainerWeb do scope "/", ChesstrainerWeb do
pipe_through [:browser, :require_authenticated_user] pipe_through [:browser, :noindex, :require_authenticated_user]
live_session :require_authenticated_user, live_session :require_authenticated_user,
on_mount: [ on_mount: [
@@ -124,12 +123,12 @@ defmodule ChesstrainerWeb.Router do
live "/endgames/:public_code/play", EndgameLive.Play, :play live "/endgames/:public_code/play", EndgameLive.Play, :play
live "/users/register", UserLive.Registration, :new live "/users/register", UserLive.Registration, :new
live "/users/log-in", UserLive.Login, :new live "/users/log-in", UserLive.Login, :new
live "/admin/log-in", UserLive.Login, :new
live "/users/reset-password", UserLive.ResetPassword, :new live "/users/reset-password", UserLive.ResetPassword, :new
live "/users/reset-password/:token", UserLive.ResetPassword, :edit live "/users/reset-password/:token", UserLive.ResetPassword, :edit
end end
get "/users/confirm/:token", UserConfirmationController, :edit get "/users/confirm/:token", UserConfirmationController, :edit
get "/mailing-list/confirm/:token", MailingListController, :confirm
post "/users/log-in", UserSessionController, :create post "/users/log-in", UserSessionController, :create
delete "/users/log-out", UserSessionController, :delete delete "/users/log-out", UserSessionController, :delete
@@ -148,7 +147,7 @@ defmodule ChesstrainerWeb.Router do
# Keep this last: routes match in definition order. It gives unmatched paths a # Keep this last: routes match in definition order. It gives unmatched paths a
# branded 404 page with the site chrome instead of Phoenix's bare status page. # branded 404 page with the site chrome instead of Phoenix's bare status page.
scope "/", ChesstrainerWeb do scope "/", ChesstrainerWeb do
pipe_through :browser pipe_through [:browser, :noindex]
match :*, "/*path", PageController, :not_found match :*, "/*path", PageController, :not_found
end end
+31
View File
@@ -0,0 +1,31 @@
defmodule Mix.Tasks.Themes.DeriveMaterial do
use Mix.Task
@shortdoc "Tags every endgame with its material family theme"
@moduledoc """
Derives each endgame's material family from its Key and stores the result as
a derived theme.
mix themes.derive_material
Every endgame belongs to exactly one family, so the themes partition the
library. Re-running is idempotent: only derived links are replaced, and
curated or community links are untouched.
Positions that are kings only, or that have no Key, are reported as skipped.
"""
@impl Mix.Task
def run(_args) do
Mix.Task.run("app.start")
%{tagged: tagged, skipped: skipped, themes: themes} =
Chesstrainer.Endgames.MaterialThemes.derive()
Mix.shell().info(
"Material themes: #{themes} themes, #{tagged} endgames tagged, " <>
"#{skipped} skipped (kings only or no Key)."
)
end
end
+32
View File
@@ -0,0 +1,32 @@
defmodule Mix.Tasks.Themes.DeriveMotifs do
use Mix.Task
@shortdoc "Tags every endgame with its tablebase-proved motifs"
@moduledoc """
Derives only-move, underpromotion and 50-move-draw motifs from the local
Syzygy tablebase.
mix themes.derive_motifs
The pass never calls the remote tablebase. Positions the local files cannot
answer are skipped and reported. Re-running is idempotent: only links to the
motif themes are replaced, so material, curated and community links survive.
"""
@impl Mix.Task
def run(_args) do
Mix.Task.run("app.start")
%{links: links, skipped: skipped, by_motif: by_motif, themes: themes} =
Chesstrainer.Endgames.MotifThemes.derive()
Mix.shell().info(
"Motif themes: #{themes} themes, #{links} link(s) written, #{skipped} endgame(s) skipped."
)
for {motif, count} <- Enum.sort(by_motif) do
Mix.shell().info(" #{motif}: #{count}")
end
end
end
@@ -0,0 +1,90 @@
defmodule Chesstrainer.Repo.Migrations.ThemeProvenanceKindsAndCoverage do
use Ecto.Migration
import Ecto.Query
def up do
alter table(:themes) do
add :slug, :string
add :description, :string
add :kind, :string, null: false, default: "technique"
end
alter table(:endgames_themes) do
add :source, :string, null: false, default: "curated"
add :inserted_at, :utc_datetime, null: false, default: fragment("now()")
end
flush()
backfill_slugs()
alter table(:themes) do
modify :slug, :string, null: false
end
create unique_index(:themes, [:slug])
create constraint(:themes, :kind_in_allowed,
check: "kind in ('material', 'motif', 'technique')"
)
create constraint(:endgames_themes, :source_in_allowed,
check: "source in ('derived', 'curated', 'community')"
)
end
def down do
drop constraint(:endgames_themes, :source_in_allowed)
drop constraint(:themes, :kind_in_allowed)
drop unique_index(:themes, [:slug])
alter table(:endgames_themes) do
remove :inserted_at
remove :source
end
alter table(:themes) do
remove :kind
remove :description
remove :slug
end
end
# Themes were created without a slug, so every existing row needs one before
# the column can become mandatory. Names are unique per category but not
# globally, so collisions get a numeric suffix.
defp backfill_slugs do
themes = repo().all(from(t in "themes", select: {t.id, t.name}))
Enum.reduce(themes, MapSet.new(), fn {id, name}, used ->
slug = unique_slug(slugify(name), used)
repo().update_all(from(t in "themes", where: t.id == ^id), set: [slug: slug])
MapSet.put(used, slug)
end)
end
defp unique_slug(base, used) do
if MapSet.member?(used, base) do
Enum.find_value(2..1_000, base, fn suffix ->
candidate = "#{base}-#{suffix}"
if MapSet.member?(used, candidate), do: nil, else: candidate
end)
else
base
end
end
defp slugify(name) do
slug =
name
|> to_string()
|> :unicode.characters_to_nfd_binary()
|> String.replace(~r/[\x{0300}-\x{036F}]/u, "")
|> String.downcase()
|> String.replace(~r/[^a-z0-9]+/u, "-")
|> String.trim("-")
if slug == "", do: "theme", else: slug
end
end
+8 -1
View File
@@ -59,7 +59,14 @@ theme_names =
Repo.insert_all( Repo.insert_all(
Theme, Theme,
Enum.map(theme_names, fn name -> Enum.map(theme_names, fn name ->
%{name: name, category: :endgame, inserted_at: now, updated_at: now} %{
name: name,
slug: Theme.slugify(name),
kind: :technique,
category: :endgame,
inserted_at: now,
updated_at: now
}
end), end),
on_conflict: :nothing on_conflict: :nothing
) )
+1 -2
View File
@@ -6,8 +6,7 @@ defmodule Chesstrainer.Repo.Seeds.Endgames.Win do
color: :white, color: :white,
message: "Rook vs king endgame", message: "Rook vs king endgame",
notes: "Basic rook endgame", notes: "Basic rook endgame",
result: :win, result: :win
themes: ["rook endgame"]
}, },
%{ %{
fen: "8/8/8/1P4p1/5k2/5p2/P6K/8 b - - 0 0", fen: "8/8/8/1P4p1/5k2/5p2/P6K/8 b - - 0 0",
+4
View File
@@ -8,6 +8,10 @@ defmodule Chesstrainer.Repo.Seeds.Themes do
"Lucena", "Lucena",
"Philidor", "Philidor",
"opposition", "opposition",
"key squares",
"triangulation",
"shouldering",
"king activity",
"promotion", "promotion",
"stalemate" "stalemate"
] ]
@@ -1,8 +1,6 @@
defmodule Chesstrainer.AccountsAdminTest do defmodule Chesstrainer.AccountsAdminTest do
use Chesstrainer.DataCase, async: false use Chesstrainer.DataCase, async: false
require Logger
import Chesstrainer.AccountsFixtures import Chesstrainer.AccountsFixtures
import ExUnit.CaptureLog import ExUnit.CaptureLog
import Swoosh.TestAssertions import Swoosh.TestAssertions
+15
View File
@@ -276,6 +276,21 @@ defmodule Chesstrainer.AccountsTest do
end end
end end
describe "update_user_plan/2" do
test "changes the user's plan" do
user = user_fixture()
assert {:ok, %User{plan: :premium}} = Accounts.update_user_plan(user, :premium)
end
test "rejects a plan that is not in the enum" do
user = user_fixture()
assert {:error, changeset} = Accounts.update_user_plan(user, :platinum)
assert %{plan: ["is invalid"]} = errors_on(changeset)
end
end
describe "sudo_mode?/2" do describe "sudo_mode?/2" do
test "validates the authenticated_at time" do test "validates the authenticated_at time" do
now = DateTime.utc_now() now = DateTime.utc_now()
+39
View File
@@ -0,0 +1,39 @@
defmodule Chesstrainer.BrandingTest do
use ExUnit.Case, async: false
alias Chesstrainer.Branding
describe "discord_invite_url/0" do
setup do
previous = Application.get_env(:chesstrainer, :branding)
on_exit(fn -> restore(:branding, previous) end)
:ok
end
test "passes a full URL through" do
put_branding(discord_invite: "https://discord.gg/abc123")
assert Branding.discord_invite_url() == "https://discord.gg/abc123"
end
test "expands a bare invite code" do
put_branding(discord_invite: " abc123 ")
assert Branding.discord_invite_url() == "https://discord.gg/abc123"
end
test "returns nil when the invite is blank" do
put_branding(discord_invite: "")
assert Branding.discord_invite_url() == nil
end
end
defp put_branding(overrides) do
config = Application.get_env(:chesstrainer, :branding, [])
Application.put_env(:chesstrainer, :branding, Keyword.merge(config, overrides))
end
defp restore(key, nil), do: Application.delete_env(:chesstrainer, key)
defp restore(key, value), do: Application.put_env(:chesstrainer, key, value)
end
@@ -0,0 +1,173 @@
defmodule Chesstrainer.Endgames.MaterialThemesTest do
use Chesstrainer.DataCase
import Ecto.Query
alias Chesstrainer.Endgames
alias Chesstrainer.Endgames.MaterialThemes
alias Chesstrainer.Repo
alias Chesstrainer.Themes
@kr_v_k "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
@kp_v_k "8/8/3k4/8/8/3KP3/8/8 w - - 0 1"
@kbn_v_k "8/8/3k4/8/8/3KBN2/8/8 w - - 0 1"
@krp_v_k "8/8/3k4/8/8/3KR2P/8/8 w - - 0 1"
@kp_v_kp "4k3/8/8/8/8/4p3/4P3/4K3 w - - 0 1"
@kq_v_kp "8/8/3k4/8/8/3K1Q1p/8/8 w - - 0 1"
@kq_v_kq "3q4/8/3k4/8/8/3K1Q2/8/8 w - - 0 1"
@kn_v_kp "8/8/3k4/8/8/3KN2p/8/8 w - - 0 1"
@kb_v_kb "8/8/3k1b2/8/8/3K1B2/8/8 w - - 0 1"
@krp_v_kr "8/8/3k4/8/8/3KR2P/8/5r2 w - - 0 1"
@kr_v_kr "8/8/3k4/8/8/3K1R2/8/5r2 b - - 0 1"
@k_v_k "8/8/3k4/8/8/3K4/8/8 w - - 0 1"
describe "family/1" do
test "classifies a lone king against heavy or pawn material" do
assert MaterialThemes.family("KQ v K") == :basic_mate
assert MaterialThemes.family("KR v K") == :basic_mate
assert MaterialThemes.family("KP v K") == :king_and_pawn
assert MaterialThemes.family("KPP v K") == :king_and_pawn
assert MaterialThemes.family("KBN v K") == :bare_king_other
assert MaterialThemes.family("KRP v K") == :bare_king_other
end
test "classifies material presence into one family" do
assert MaterialThemes.family("KP v KP") == :pawn_endgame
assert MaterialThemes.family("KQ v KP") == :queen_and_pawn
assert MaterialThemes.family("KQ v KQ") == :queen_endgame
assert MaterialThemes.family("KRP v KR") == :rook_and_pawn
assert MaterialThemes.family("KR v KR") == :rook_endgame
assert MaterialThemes.family("KN v KP") == :minor_piece_and_pawn
assert MaterialThemes.family("KB v KB") == :minor_piece_endgame
end
test "flags content-free and malformed keys" do
assert MaterialThemes.family("K v K") == :kings_only
assert MaterialThemes.family(nil) == :unknown
assert MaterialThemes.family("not a key") == :unknown
end
end
describe "derive/0" do
test "creates every material family as a material theme" do
MaterialThemes.derive()
themes = Themes.list_themes()
assert length(themes) == length(MaterialThemes.families())
assert Enum.all?(themes, &(&1.kind == :material))
assert Enum.all?(themes, &(&1.description not in [nil, ""]))
end
test "tags every endgame with exactly one family" do
pawn = create_endgame!(@kp_v_kp)
rook = create_endgame!(@kr_v_kr)
rook_and_pawn = create_endgame!(@krp_v_kr)
queen_and_pawn = create_endgame!(@kq_v_kp)
queen = create_endgame!(@kq_v_kq)
minor_and_pawn = create_endgame!(@kn_v_kp)
minor = create_endgame!(@kb_v_kb)
mate = create_endgame!(@kr_v_k)
promotion = create_endgame!(@kp_v_k)
bare_minor = create_endgame!(@kbn_v_k)
bare_other = create_endgame!(@krp_v_k)
kings_only = create_endgame!(@k_v_k)
assert %{tagged: 11, skipped: 1} = MaterialThemes.derive()
assert ["pawn endgame"] = theme_names(pawn)
assert ["rook endgame"] = theme_names(rook)
assert ["rook and pawn"] = theme_names(rook_and_pawn)
assert ["queen and pawn"] = theme_names(queen_and_pawn)
assert ["queen endgame"] = theme_names(queen)
assert ["minor piece and pawn"] = theme_names(minor_and_pawn)
assert ["minor piece endgame"] = theme_names(minor)
assert ["basic mate"] = theme_names(mate)
assert ["king and pawn"] = theme_names(promotion)
assert ["bare king other"] = theme_names(bare_minor)
assert ["bare king other"] = theme_names(bare_other)
assert [] = theme_names(kings_only)
end
test "corrects an existing technique theme and claims its links as derived" do
{:ok, existing} = Themes.create_theme(%{name: "rook endgame", category: :endgame})
endgame = create_endgame!(@kr_v_kr, [existing])
MaterialThemes.derive()
theme = Themes.get_theme!(existing.id)
assert theme.kind == :material
assert theme.description =~ "Rooks"
assert [{theme_id, "derived"}] = link_rows(endgame.id)
assert theme_id == existing.id
end
test "removes a curated link to a material theme that contradicts the family" do
{:ok, rook} = Themes.create_theme(%{name: "rook endgame", category: :endgame})
mate = create_endgame!(@kr_v_k, [rook])
MaterialThemes.derive()
assert ["basic mate"] = theme_names(mate)
end
test "is idempotent" do
endgame = create_endgame!(@kq_v_kp)
MaterialThemes.derive()
first = link_rows(endgame.id)
MaterialThemes.derive()
assert link_rows(endgame.id) == first
assert length(first) == 1
end
test "leaves curated and community links to other themes alone" do
{:ok, lucena} = Themes.create_theme(%{name: "Lucena", category: :endgame})
endgame = create_endgame!(@kr_v_kr)
insert_link(endgame.id, lucena.id, "community")
MaterialThemes.derive()
rows = link_rows(endgame.id)
assert {lucena.id, "community"} in rows
assert length(rows) == 2
end
end
defp create_endgame!(fen, themes \\ []) do
{:ok, endgame} =
Endgames.create_endgame(%{fen: fen, color: :white, result: :win, rating: 1500}, themes)
endgame
end
defp theme_names(endgame) do
endgame
|> Map.fetch!(:id)
|> link_rows()
|> Enum.map(fn {theme_id, _source} -> Themes.get_theme!(theme_id).name end)
|> Enum.sort()
end
defp link_rows(endgame_id) do
Repo.all(
from l in "endgames_themes",
where: l.endgame_id == type(^endgame_id, :binary_id),
select: {l.theme_id, l.source},
order_by: l.theme_id
)
end
defp insert_link(endgame_id, theme_id, source) do
Repo.insert_all("endgames_themes", [
%{
endgame_id: Ecto.UUID.dump!(endgame_id),
theme_id: theme_id,
source: source,
inserted_at: DateTime.utc_now() |> DateTime.truncate(:second)
}
])
end
end
@@ -0,0 +1,170 @@
defmodule Chesstrainer.Endgames.MotifThemesTest.Stub do
@moduledoc false
def probe_local_detail(fen), do: Map.fetch!(Process.get(:motif_stub), fen)
end
defmodule Chesstrainer.Endgames.MotifThemesTest do
use Chesstrainer.DataCase
import Ecto.Query
alias Chesstrainer.Endgames
alias Chesstrainer.Endgames.MotifThemes
alias Chesstrainer.Repo
alias Chesstrainer.Themes
setup do
previous = Application.get_env(:chesstrainer, :motif_probe)
Application.put_env(:chesstrainer, :motif_probe, __MODULE__.Stub)
on_exit(fn ->
if previous,
do: Application.put_env(:chesstrainer, :motif_probe, previous),
else: Application.delete_env(:chesstrainer, :motif_probe)
end)
:ok
end
describe "motifs_for/4" do
test "detects an only move for wins and draws" do
assert [:only_move] = MotifThemes.motifs_for(:win, 5, [move(:win), move(:draw)], 0)
assert [:only_move] =
MotifThemes.motifs_for(:draw, 5, [move(:draw), move(:loss), move(:loss)], 0)
end
test "does not report an only move when several moves preserve the result" do
assert [] = MotifThemes.motifs_for(:win, 5, [move(:win), move(:win)], 0)
end
test "does not report an only move for a forced single move or a lost position" do
assert [] = MotifThemes.motifs_for(:win, 5, [move(:win)], 0)
assert [] = MotifThemes.motifs_for(:loss, 5, [move(:loss), move(:loss)], 0)
end
test "requires an underpromotion while no queen promotion preserves the result" do
assert [:underpromotion] =
MotifThemes.motifs_for(:win, 5, [move(:win, 4), move(:win), move(:draw, 1)], 0)
assert [] = MotifThemes.motifs_for(:win, 5, [move(:win, 4), move(:win, 1)], 0)
assert [] = MotifThemes.motifs_for(:win, 5, [move(:draw, 4), move(:win), move(:win)], 0)
end
test "detects the 50-move rule from the raw WDL" do
assert [:fifty_move_draw] =
MotifThemes.motifs_for(:cursed_win, 120, [move(:cursed_win)], 0)
assert [:fifty_move_draw] =
MotifThemes.motifs_for(:blessed_loss, 120, [move(:blessed_loss)], 0)
end
test "detects the 50-move rule when the clock runs out before the next zeroing move" do
assert [:fifty_move_draw] = MotifThemes.motifs_for(:win, 60, [move(:win)], 50)
assert [] = MotifThemes.motifs_for(:win, 40, [move(:win)], 50)
assert [] = MotifThemes.motifs_for(:win, 100, [move(:win)], 0)
end
test "a position can carry several motifs" do
assert [:underpromotion, :only_move] =
MotifThemes.motifs_for(:win, 5, [move(:win, 4), move(:draw)], 0)
end
end
describe "derive/0" do
@win_fen "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
@draw_fen "4k3/8/8/8/8/4p3/4P3/4K3 w - - 0 1"
@loss_fen "8/8/3k4/8/8/3K4/8/6q1 w - - 0 1"
test "links the motifs reported for each endgame and skips losses" do
win = create_endgame!(@win_fen, :win)
draw = create_endgame!(@draw_fen, :draw)
loss = create_endgame!(@loss_fen, :loss)
stub(%{
win.fen => {:ok, %{wdl: :win, dtz: 5, moves: [move(:win), move(:draw)]}},
draw.fen => {:ok, %{wdl: :cursed_win, dtz: 120, moves: [move(:cursed_win)]}}
})
assert %{links: 2, skipped: 0, themes: 3} = MotifThemes.derive()
assert theme_names(win) == ["only move"]
assert theme_names(draw) == ["50-move draw"]
assert theme_names(loss) == []
assert Enum.all?(Themes.list_themes(), &(&1.kind == :motif))
assert Enum.all?(Themes.list_themes(), &(&1.description not in [nil, ""]))
end
test "reports endgames the local tables cannot answer" do
endgame = create_endgame!(@win_fen, :win)
stub(%{endgame.fen => {:error, :unsupported}})
assert %{links: 0, skipped: 1} = MotifThemes.derive()
assert theme_names(endgame) == []
end
test "is idempotent and leaves material, curated and community links alone" do
win = create_endgame!(@win_fen, :win)
stub(%{win.fen => {:ok, %{wdl: :win, dtz: 5, moves: [move(:win), move(:draw)]}}})
{:ok, lucena} = Themes.create_theme(%{name: "Lucena", category: :endgame})
{:ok, rook_endgame} =
Themes.create_theme(%{name: "rook endgame", kind: :material, category: :endgame})
{:ok, _} = Themes.tag_endgames(lucena, [win.id], :curated)
:ok = Themes.sync_derived_themes(win.id, [rook_endgame.id])
MotifThemes.derive()
first = link_rows(win.id)
MotifThemes.derive()
assert link_rows(win.id) == first
assert {lucena.id, "curated"} in first
assert {rook_endgame.id, "derived"} in first
assert length(first) == 3
end
test "corrects an existing technique theme into a motif theme" do
{:ok, existing} = Themes.create_theme(%{name: "only move", category: :endgame})
endgame = create_endgame!(@win_fen, :win)
stub(%{endgame.fen => {:ok, %{wdl: :win, dtz: 5, moves: [move(:win), move(:draw)]}}})
MotifThemes.derive()
theme = Themes.get_theme!(existing.id)
assert theme.kind == :motif
assert theme.description =~ "Exactly one legal move"
end
end
defp stub(responses), do: Process.put(:motif_stub, responses)
defp move(wdl, promotes \\ 0, dtz \\ 0), do: {wdl, 0, 0, promotes, 0, dtz}
defp create_endgame!(fen, result) do
{:ok, endgame} =
Endgames.create_endgame(%{fen: fen, color: :white, result: result, rating: 1500})
endgame
end
defp theme_names(endgame) do
endgame
|> Map.fetch!(:id)
|> link_rows()
|> Enum.map(fn {theme_id, _source} -> Themes.get_theme!(theme_id).name end)
|> Enum.sort()
end
defp link_rows(endgame_id) do
Repo.all(
from l in "endgames_themes",
where: l.endgame_id == type(^endgame_id, :binary_id),
select: {l.theme_id, l.source},
order_by: l.theme_id
)
end
end
@@ -6,6 +6,11 @@ defmodule Chesstrainer.Endgames.Tablebase.Backend.FathomTest.Stub do
def probe(_fen), do: {:ok, %Tablebase{category: :draw, checkmate: false, moves: []}} def probe(_fen), do: {:ok, %Tablebase{category: :draw, checkmate: false, moves: []}}
end end
defmodule Chesstrainer.Endgames.Tablebase.Backend.FathomTest.ExplodingFallback do
@moduledoc false
def probe(_fen), do: raise("the remote tablebase must not be called")
end
defmodule Chesstrainer.Endgames.Tablebase.Backend.FathomTest do defmodule Chesstrainer.Endgames.Tablebase.Backend.FathomTest do
# Not async: the local backend reads app config and Fathom keeps global state. # Not async: the local backend reads app config and Fathom keeps global state.
use ExUnit.Case, async: false use ExUnit.Case, async: false
@@ -18,6 +23,7 @@ defmodule Chesstrainer.Endgames.Tablebase.Backend.FathomTest do
@krk "4k3/8/8/8/8/8/8/R3K3 w - - 0 1" @krk "4k3/8/8/8/8/8/8/R3K3 w - - 0 1"
@mate "7k/6Q1/5K2/8/8/8/8/8 b - - 0 1" @mate "7k/6Q1/5K2/8/8/8/8/8 b - - 0 1"
@kpk "8/8/3k4/8/8/3KP3/8/8 w - - 0 1"
test "probes a KRvK position locally" do test "probes a KRvK position locally" do
assert {:ok, %Tablebase{} = tablebase} = FathomBackend.probe(@krk) assert {:ok, %Tablebase{} = tablebase} = FathomBackend.probe(@krk)
@@ -82,4 +88,37 @@ defmodule Chesstrainer.Endgames.Tablebase.Backend.FathomTest do
assert {:ok, %Tablebase{category: :draw}} = FathomBackend.probe(@krk) assert {:ok, %Tablebase{category: :draw}} = FathomBackend.probe(@krk)
end end
end end
describe "probe_local_detail/1" do
test "returns the raw root WDL, DTZ and every legal move" do
assert {:ok, %{wdl: :win, dtz: dtz, moves: moves}} =
FathomBackend.probe_local_detail(@krk)
assert is_integer(dtz)
assert length(moves) == 15
assert Enum.all?(moves, &(elem(&1, 0) in [:win, :cursed_win, :draw, :blessed_loss, :loss]))
end
test "returns terminal for a finished position" do
assert {:error, :terminal} = FathomBackend.probe_local_detail(@mate)
end
test "returns unsupported when the local files cannot answer the position" do
assert {:error, :unsupported} = FathomBackend.probe_local_detail(@kpk)
end
test "never calls the remote backend" do
previous = Application.get_env(:chesstrainer, :tablebase_fallback)
on_exit(fn ->
if previous,
do: Application.put_env(:chesstrainer, :tablebase_fallback, previous),
else: Application.delete_env(:chesstrainer, :tablebase_fallback)
end)
Application.put_env(:chesstrainer, :tablebase_fallback, __MODULE__.ExplodingFallback)
assert {:error, :unsupported} = FathomBackend.probe_local_detail(@kpk)
end
end
end end
+28
View File
@@ -1,6 +1,8 @@
defmodule Chesstrainer.EndgamesTest do defmodule Chesstrainer.EndgamesTest do
use Chesstrainer.DataCase use Chesstrainer.DataCase
import Chesstrainer.EndgamesFixtures
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Endgames.Endgame alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Themes alias Chesstrainer.Themes
@@ -387,4 +389,30 @@ defmodule Chesstrainer.EndgamesTest do
assert Endgames.curated_endgames() == [] assert Endgames.curated_endgames() == []
end end
end end
describe "theme filters and pagination" do
test "groups endgames by whether they carry a theme" do
{:ok, theme} = Themes.create_theme(%{name: "Lucena", category: :endgame})
tagged = create_endgame!(@kr)
create_endgame!(@kq)
{:ok, _} = Endgames.update_endgame(tagged, %{}, [theme])
assert Endgames.list_key_groups(%{with_theme: {theme.id, :curated}}) == [{"KR v K", 1}]
assert Endgames.list_key_groups(%{without_theme: theme.id}) == [{"KQ v K", 1}]
end
test "paginates the endgames in one key group" do
endgames = for _ <- 1..3, do: endgame_fixture()
first = Endgames.list_endgames_for_key("K v K", %{}, limit: 2, offset: 0)
second = Endgames.list_endgames_for_key("K v K", %{}, limit: 2, offset: 2)
assert length(first) == 2
assert length(second) == 1
ids = Enum.map(first ++ second, & &1.id)
assert Enum.sort(ids) == Enum.sort(Enum.map(endgames, & &1.id))
assert length(Enum.uniq(ids)) == 3
end
end
end end
+60 -27
View File
@@ -7,6 +7,7 @@ defmodule Chesstrainer.PuzzlesTest do
alias Chesstrainer.Accounts.Scope alias Chesstrainer.Accounts.Scope
alias Chesstrainer.Attempts alias Chesstrainer.Attempts
alias Chesstrainer.Puzzles alias Chesstrainer.Puzzles
alias Chesstrainer.Repo
# The shared `endgame_fixture/1` picks one of six FENs at random-ish, which # The shared `endgame_fixture/1` picks one of six FENs at random-ish, which
# can collide when one test creates several endgames under async load. Pin # can collide when one test creates several endgames under async load. Pin
@@ -22,71 +23,103 @@ defmodule Chesstrainer.PuzzlesTest do
endgame_fixture(fen: Enum.fetch!(@fens, index), rating: rating) endgame_fixture(fen: Enum.fetch!(@fens, index), rating: rating)
end end
describe "difficulty_range/2" do defp attempt_days_ago(user, endgame, days) do
test "is centred on the rating and open-ended at the extremes" do {:ok, attempt} = Attempts.record_attempt(Scope.for_user(user), endgame, :solved)
assert Puzzles.difficulty_range(1500, :medium) == {1400, 1600}
assert Puzzles.difficulty_range(1500, :easy) == {nil, 1400} attempt
assert Puzzles.difficulty_range(1500, :hard) == {1600, nil} |> Ecto.Changeset.change(
inserted_at: DateTime.utc_now() |> DateTime.add(-days, :day) |> DateTime.truncate(:second)
)
|> Repo.update!()
end
describe "difficulty_target/2" do
test "centres on the rating and offsets easy and hard" do
assert Puzzles.difficulty_target(1500, :medium) == 1500
assert Puzzles.difficulty_target(1500, :easy) == 1300
assert Puzzles.difficulty_target(1500, :hard) == 1700
end
end
describe "selection settings" do
test "uses the configured spread and repeat window" do
assert Puzzles.spread() == 150
assert Puzzles.repeat_window_days() == 30
end end
end end
describe "next_endgame/3" do describe "next_endgame/3" do
test "medium picks an endgame within the band" do test "draws far more often from near the user's rating" do
user = user_fixture() user = user_fixture()
in_band = endgame_at(1550, 0) near = endgame_at(1500, 0)
_out_of_band = endgame_at(1900, 1) _far = endgame_at(4000, 1)
assert Puzzles.next_endgame(user, :medium).id == in_band.id for _ <- 1..50 do
assert Puzzles.next_endgame(user, :medium).id == near.id
end
end end
test "easy picks an endgame below the user's rating" do test "easy never serves above the user's rating plus the spread" do
user = user_fixture() user = user_fixture()
easy = endgame_at(1300, 0) easy = endgame_at(1300, 0)
_medium = endgame_at(1500, 1) _too_hard = endgame_at(3000, 1)
assert Puzzles.next_endgame(user, :easy).id == easy.id assert Puzzles.next_endgame(user, :easy).id == easy.id
end end
test "hard picks an endgame above the user's rating" do test "hard never serves below the user's rating minus the spread" do
user = user_fixture() user = user_fixture()
hard = endgame_at(1700, 0) hard = endgame_at(1700, 0)
_medium = endgame_at(1500, 1) _too_easy = endgame_at(100, 1)
assert Puzzles.next_endgame(user, :hard).id == hard.id assert Puzzles.next_endgame(user, :hard).id == hard.id
end end
test "falls back to the nearest endgame when the band is empty" do test "prefers endgames not attempted inside the repeat window" do
user = user_fixture()
only = endgame_at(2200, 0)
assert Puzzles.next_endgame(user, :medium).id == only.id
end
test "prefers endgames not attempted in the last 30 days" do
user = user_fixture() user = user_fixture()
attempted = endgame_at(1500, 0) attempted = endgame_at(1500, 0)
fresh = endgame_at(1500, 1) fresh = endgame_at(1500, 1)
{:ok, _} = Attempts.record_attempt(Scope.for_user(user), attempted, :solved) attempt_days_ago(user, attempted, 1)
assert Puzzles.next_endgame(user, :medium).id == fresh.id assert Puzzles.next_endgame(user, :medium).id == fresh.id
end end
test "falls back to a recent endgame once the fresh pool is empty" do test "serves an endgame again once its attempt is outside the repeat window" do
user = user_fixture() user = user_fixture()
only = endgame_at(1500, 0) only = endgame_at(1500, 0)
{:ok, _} = Attempts.record_attempt(Scope.for_user(user), only, :solved) attempt_days_ago(user, only, 31)
assert Puzzles.next_endgame(user, :medium).id == only.id assert Puzzles.next_endgame(user, :medium).id == only.id
end end
test "skips excluded ids" do test "falls back to the least recently attempted endgame when all are excluded" do
user = user_fixture() user = user_fixture()
excluded = endgame_at(1500, 0) older = endgame_at(1500, 0)
newer = endgame_at(1500, 1)
attempt_days_ago(user, older, 20)
attempt_days_ago(user, newer, 10)
assert Puzzles.next_endgame(user, :medium).id == older.id
end
test "skips endgames already served in the session" do
user = user_fixture()
served = endgame_at(1500, 0)
other = endgame_at(1500, 1) other = endgame_at(1500, 1)
assert Puzzles.next_endgame(user, :medium, exclude_ids: [excluded.id]).id == other.id assert Puzzles.next_endgame(user, :medium, exclude_ids: [served.id]).id == other.id
end
test "returns nil when every endgame has been served and attempted" do
user = user_fixture()
only = endgame_at(1500, 0)
attempt_days_ago(user, only, 1)
assert Puzzles.next_endgame(user, :medium, exclude_ids: [only.id]) == nil
end end
test "returns nil when no endgames exist" do test "returns nil when no endgames exist" do
+206 -2
View File
@@ -1,13 +1,21 @@
defmodule Chesstrainer.ThemesTest do defmodule Chesstrainer.ThemesTest do
use Chesstrainer.DataCase use Chesstrainer.DataCase
import Ecto.Query
import Chesstrainer.AccountsFixtures
import Chesstrainer.EndgamesFixtures
import Chesstrainer.ThemesFixtures
alias Chesstrainer.Accounts
alias Chesstrainer.Accounts.Scope
alias Chesstrainer.Endgames
alias Chesstrainer.Repo
alias Chesstrainer.Themes alias Chesstrainer.Themes
describe "themes" do describe "themes" do
alias Chesstrainer.Themes.Theme alias Chesstrainer.Themes.Theme
import Chesstrainer.ThemesFixtures
@invalid_attrs %{name: nil, category: nil} @invalid_attrs %{name: nil, category: nil}
test "list_themes/0 returns all themes" do test "list_themes/0 returns all themes" do
@@ -76,4 +84,200 @@ defmodule Chesstrainer.ThemesTest do
assert changeset.errors[:name] assert changeset.errors[:name]
end end
end end
describe "theme identity" do
test "generates a slug from the name" do
assert {:ok, theme} = Themes.create_theme(%{name: " Mate in 2! ", category: :endgame})
assert theme.slug == "mate-in-2"
end
test "normalises an explicit slug" do
assert {:ok, theme} =
Themes.create_theme(%{
name: "Lucena",
slug: " Lucena-Position ",
category: :endgame
})
assert theme.slug == "lucena-position"
end
test "keeps the slug stable when the name changes" do
theme = theme_fixture(%{name: "Lucena"})
assert {:ok, updated} = Themes.update_theme(theme, %{name: "Lucena position"})
assert updated.slug == "lucena"
end
test "rejects a slug that is already taken, even in another category" do
assert {:ok, _theme} = Themes.create_theme(%{name: "Lucena", category: :endgame})
assert {:error, changeset} = Themes.create_theme(%{name: "Lucena", category: :tactic})
assert changeset.errors[:slug]
end
test "defaults the kind to technique" do
assert {:ok, theme} = Themes.create_theme(%{name: "Opposition", category: :endgame})
assert theme.kind == :technique
end
test "accepts a material kind" do
assert {:ok, theme} =
Themes.create_theme(%{
name: "Rook endgame",
kind: :material,
category: :endgame
})
assert theme.kind == :material
end
test "rejects an unknown kind" do
assert {:error, changeset} =
Themes.create_theme(%{
name: "Zugzwang",
kind: :bogus,
category: :endgame
})
assert changeset.errors[:kind]
end
test "get_theme_by_slug/1 finds an endgame theme and ignores other categories" do
theme = theme_fixture(%{name: "Philidor"})
tactic = theme_fixture(%{name: "Philidor's pin", category: :tactic})
assert Themes.get_theme_by_slug("philidor").id == theme.id
assert Themes.get_theme_by_slug(tactic.slug) == nil
assert Themes.get_theme_by_slug("unknown") == nil
end
end
describe "create_theme/2 authorization" do
test "an admin scope may create a theme" do
{:ok, admin} = Accounts.update_user_role(user_fixture(), :admin)
scope = Scope.for_user(admin)
assert {:ok, %Themes.Theme{}} =
Themes.create_theme(scope, %{name: "Opposition", category: :endgame})
end
test "a member scope cannot create a theme" do
scope = user_scope_fixture()
assert {:error, :unauthorized} =
Themes.create_theme(scope, %{name: "Opposition", category: :endgame})
assert Themes.list_themes() == []
end
end
describe "theme link provenance" do
test "links created from the endgame context default to curated" do
theme = theme_fixture()
endgame = endgame_fixture()
assert {:ok, _endgame} = Endgames.update_endgame(endgame, %{}, [theme])
assert [%{theme_id: theme_id, source: "curated"}] = link_rows(endgame.id)
assert theme_id == theme.id
end
test "sync_derived_themes/2 adds derived links and leaves curated and community links alone" do
curated = theme_fixture(%{name: "Lucena"})
community = theme_fixture(%{name: "Philidor"})
derived = theme_fixture(%{name: "Rook endgame"})
endgame = endgame_fixture()
{:ok, _} = Endgames.update_endgame(endgame, %{}, [curated])
insert_link(endgame.id, community.id, "community")
assert :ok = Themes.sync_derived_themes(endgame.id, [derived.id, curated.id])
sources = link_sources(endgame.id)
assert sources[curated.id] == "curated"
assert sources[community.id] == "community"
assert sources[derived.id] == "derived"
end
test "sync_derived_themes/2 replaces only its own derived links" do
curated = theme_fixture(%{name: "Lucena"})
old_derived = theme_fixture(%{name: "Rook endgame"})
new_derived = theme_fixture(%{name: "Two pawns"})
endgame = endgame_fixture()
{:ok, _} = Endgames.update_endgame(endgame, %{}, [curated])
Themes.sync_derived_themes(endgame.id, [old_derived.id])
assert :ok = Themes.sync_derived_themes(endgame.id, [new_derived.id])
sources = link_sources(endgame.id)
assert sources[curated.id] == "curated"
refute Map.has_key?(sources, old_derived.id)
assert sources[new_derived.id] == "derived"
end
end
describe "tag_endgames/3 and untag_endgame/3" do
test "adds curated links without duplicating them" do
theme = theme_fixture()
first = endgame_fixture()
second = endgame_fixture()
assert {:ok, 2} = Themes.tag_endgames(theme, [first.id, second.id])
assert {:ok, 2} = Themes.tag_endgames(theme, [first.id, second.id])
assert link_sources(first.id) == %{theme.id => "curated"}
assert link_sources(second.id) == %{theme.id => "curated"}
end
test "never overwrites a derived link" do
theme = theme_fixture()
endgame = endgame_fixture()
:ok = Themes.sync_derived_themes(endgame.id, [theme.id])
assert {:ok, 1} = Themes.tag_endgames(theme, [endgame.id])
assert link_sources(endgame.id) == %{theme.id => "derived"}
end
test "removes only the requested source" do
theme = theme_fixture()
curated = endgame_fixture()
community = endgame_fixture()
{:ok, _} = Themes.tag_endgames(theme, [curated.id], :curated)
{:ok, _} = Themes.tag_endgames(theme, [community.id], :community)
assert {:ok, 1} = Themes.untag_endgame(theme, curated.id, :curated)
assert link_sources(curated.id) == %{}
assert link_sources(community.id) == %{theme.id => "community"}
end
end
defp link_rows(endgame_id) do
Repo.all(
from l in "endgames_themes",
where: l.endgame_id == type(^endgame_id, :binary_id),
select: %{theme_id: l.theme_id, source: l.source},
order_by: l.theme_id
)
end
defp link_sources(endgame_id) do
endgame_id
|> link_rows()
|> Map.new(&{&1.theme_id, &1.source})
end
defp insert_link(endgame_id, theme_id, source) do
Repo.insert_all("endgames_themes", [
%{
endgame_id: Ecto.UUID.dump!(endgame_id),
theme_id: theme_id,
source: source,
inserted_at: DateTime.utc_now() |> DateTime.truncate(:second)
}
])
end
end end
@@ -5,6 +5,7 @@ defmodule ChesstrainerWeb.LayoutsTest do
alias Chesstrainer.Accounts.Scope alias Chesstrainer.Accounts.Scope
alias Chesstrainer.Accounts.User alias Chesstrainer.Accounts.User
alias Chesstrainer.Branding
alias ChesstrainerWeb.Layouts alias ChesstrainerWeb.Layouts
describe "navbar/1" do describe "navbar/1" do
@@ -28,6 +29,53 @@ defmodule ChesstrainerWeb.LayoutsTest do
assert html =~ ~p"/users/register" assert html =~ ~p"/users/register"
refute html =~ ~s(class="nav-user-menu") refute html =~ ~s(class="nav-user-menu")
end end
test "renders the utility controls in both the bar and the mobile menu" do
html = render_component(&Layouts.navbar/1, %{current_scope: nil})
assert html =~ ~s(class="nav-menu-tools")
# One copy for the bar, one for the collapsible menu; CSS shows one.
assert length(String.split(html, ~s(role="radiogroup"))) == 3
assert length(String.split(html, ~s(class="discord-link"))) == 3
end
end
describe "discord_link/1" do
setup do
previous = Application.get_env(:chesstrainer, :branding)
on_exit(fn -> restore_env(:branding, previous) end)
:ok
end
test "renders an icon-only link to the configured invite" do
html = render_component(&Layouts.discord_link/1, %{})
assert html =~ ~s(href="#{Branding.discord_invite_url()}")
assert html =~ ~s(aria-label="Join the #{Branding.name()} Discord")
assert html =~ ~s(target="_blank")
assert html =~ "noopener noreferrer"
assert html =~ ~r/<a[^>]*class="discord-link"[^>]*>\s*<svg/
end
test "is rendered by the navbar and the footer" do
navbar = render_component(&Layouts.navbar/1, %{current_scope: nil})
assert navbar =~ ~s(class="discord-link")
footer = render_component(&Layouts.footer/1, %{})
assert footer =~ ~s(class="discord-link")
end
test "renders nothing when no invite is configured" do
Application.put_env(
:chesstrainer,
:branding,
Keyword.put(Application.get_env(:chesstrainer, :branding, []), :discord_invite, "")
)
html = render_component(&Layouts.discord_link/1, %{})
refute html =~ "discord-link"
end
end end
describe "colour_mode_toggle/1" do describe "colour_mode_toggle/1" do
@@ -10,7 +10,7 @@ defmodule ChesstrainerWeb.HealthControllerTest do
assert body["db"] == "ok" assert body["db"] == "ok"
assert body["tablebase"] == "local" assert body["tablebase"] == "local"
assert body["process"] == "ok" assert body["process"] == "ok"
assert get_resp_header(conn, "x-robots-tag") == ["noindex"] assert get_resp_header(conn, "x-robots-tag") == ["noindex, nofollow"]
end end
test "returns degraded when local tablebases are not configured", %{conn: conn} do test "returns degraded when local tablebases are not configured", %{conn: conn} do
@@ -53,7 +53,7 @@ defmodule ChesstrainerWeb.HealthControllerTest do
assert body["db"] == "down" assert body["db"] == "down"
assert body["tablebase"] == "local" assert body["tablebase"] == "local"
assert body["process"] == "ok" assert body["process"] == "ok"
assert get_resp_header(conn, "x-robots-tag") == ["noindex"] assert get_resp_header(conn, "x-robots-tag") == ["noindex, nofollow"]
end end
end end
@@ -68,10 +68,17 @@ defmodule ChesstrainerWeb.PageControllerTest do
assert LazyHTML.text(LazyHTML.query(document, "title")) =~ Branding.home_title() assert LazyHTML.text(LazyHTML.query(document, "title")) =~ Branding.home_title()
refute html =~ "Phoenix Framework" refute html =~ "Phoenix Framework"
eyebrow = LazyHTML.query(document, ".eyebrow") eyebrow = LazyHTML.query(document, ".hero .eyebrow")
assert LazyHTML.text(eyebrow) =~ "Endgames, simplified" assert LazyHTML.text(eyebrow) =~ "Endgames, simplified"
assert LazyHTML.attribute(LazyHTML.query(eyebrow, "svg"), "aria-hidden") == ["true"] assert LazyHTML.attribute(LazyHTML.query(eyebrow, "svg"), "aria-hidden") == ["true"]
assert LazyHTML.text(LazyHTML.query(document, ".puzzle-coming-soon")) =~ "Coming soon"
assert LazyHTML.text(LazyHTML.query(document, ".learning-quote")) =~
"The hardest game to win is a won game."
assert html =~ "Emmanuel Lasker"
assert LazyHTML.attribute(LazyHTML.query(document, ~s(meta[name="description"])), "content") == assert LazyHTML.attribute(LazyHTML.query(document, ~s(meta[name="description"])), "content") ==
[@description] [@description]
@@ -381,7 +388,7 @@ defmodule ChesstrainerWeb.PageControllerTest do
refute html =~ "Browse puzzles" refute html =~ "Browse puzzles"
assert html =~ ~s(class="site-footer") assert html =~ ~s(class="site-footer")
assert html =~ "/assets/js/marketing.js" assert html =~ "/assets/js/marketing.js"
assert html =~ ~s(name="robots") assert html =~ ~s(<meta name="robots" content="noindex, nofollow")
end end
test "premium users see the puzzles link on the 404 page", %{conn: conn} do test "premium users see the puzzles link on the 404 page", %{conn: conn} do
@@ -11,17 +11,16 @@ defmodule ChesstrainerWeb.SitemapControllerTest do
assert body =~ ~s(<?xml version="1.0" encoding="UTF-8"?>) assert body =~ ~s(<?xml version="1.0" encoding="UTF-8"?>)
assert body =~ ~s(<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">) assert body =~ ~s(<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">)
assert body =~ "<loc>#{base_url}/</loc>" assert body =~ "<loc>#{base_url}/</loc>"
assert body =~ "<lastmod>#{Date.utc_today() |> Date.to_iso8601()}</lastmod>"
assert body =~ "<loc>#{base_url}/privacy</loc>" assert body =~ "<loc>#{base_url}/privacy</loc>"
assert body =~ "<loc>#{base_url}/terms-conditions</loc>" assert body =~ "<loc>#{base_url}/terms-conditions</loc>"
assert body =~ "<loc>#{base_url}/mentions-legales</loc>" assert body =~ "<loc>#{base_url}/mentions-legales</loc>"
assert length(:binary.matches(body, "<url>")) == 4 assert length(:binary.matches(body, "<url>")) == 4
end end
test "only dates the landing page", %{conn: conn} do test "does not invent modification dates", %{conn: conn} do
body = conn |> get(~p"/sitemap.xml") |> response(200) body = conn |> get(~p"/sitemap.xml") |> response(200)
assert length(:binary.matches(body, "<lastmod>")) == 1 refute body =~ "<lastmod>"
end end
test "is served as XML", %{conn: conn} do test "is served as XML", %{conn: conn} do
@@ -186,22 +186,6 @@ defmodule ChesstrainerWeb.UserSessionControllerTest do
assert get_session(conn, :user_token) assert get_session(conn, :user_token)
end end
test "the admin login uses the same throttle", %{conn: conn, user: user} do
for _ <- 1..LoginThrottle.max_per_login() do
post(conn, ~p"/admin/log-in", %{
"user" => %{"email" => user.email, "password" => "wrong password"}
})
end
conn =
post(conn, ~p"/admin/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
refute get_session(conn, :user_token)
assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Too many attempts."
end
test "log events contain no raw address or password", %{conn: conn, user: user} do test "log events contain no raw address or password", %{conn: conn, user: user} do
log = log =
capture_log( capture_log(
@@ -0,0 +1,45 @@
defmodule ChesstrainerWeb.CrawlerDirectivesTest do
use ChesstrainerWeb.ConnCase, async: true
@noindex "noindex, nofollow"
describe "X-Robots-Tag" do
test "authenticated routes are noindex even when redirecting to log in", %{conn: conn} do
conn = get(conn, ~p"/train")
assert redirected_to(conn) == ~p"/users/log-in"
assert get_resp_header(conn, "x-robots-tag") == [@noindex]
end
test "the branded 404 page is noindex", %{conn: conn} do
conn = get(conn, "/this-page-does-not-exist")
assert html_response(conn, 404)
assert get_resp_header(conn, "x-robots-tag") == [@noindex]
end
test "the mailing-list confirmation redirect is noindex", %{conn: conn} do
conn = get(conn, "/mailing-list/confirm/oops")
assert redirected_to(conn) == "/#mailing-list"
assert get_resp_header(conn, "x-robots-tag") == [@noindex]
end
test "public pages are not marked noindex", %{conn: conn} do
for path <- [~p"/", ~p"/privacy", ~p"/terms-conditions", ~p"/mentions-legales"] do
conn = get(conn, path)
html = html_response(conn, 200)
assert get_resp_header(conn, "x-robots-tag") == []
refute html =~ ~s(name="robots")
refute html =~ "nofollow"
end
end
test "pages that assign :noindex carry the same policy as the header", %{conn: conn} do
html = conn |> get("/this-page-does-not-exist") |> html_response(404)
assert html =~ ~s(<meta name="robots" content="#{@noindex}")
end
end
end
@@ -17,7 +17,30 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.FormTest do
assert_redirect(view, ~p"/admin/themes") assert_redirect(view, ~p"/admin/themes")
assert [%{name: "Lucena", category: :endgame}] = Themes.search("Lucena", "endgame") assert [%{name: "Lucena", slug: "lucena", kind: :technique, category: :endgame}] =
Themes.search("Lucena", "endgame")
end
test "creates a theme with a kind and description", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/themes/new")
view
|> form("#theme-form",
theme: %{
name: "Rook endgame",
kind: "material",
category: "endgame",
description: "Positions where a rook and pawn face a rook."
}
)
|> render_submit()
assert_redirect(view, ~p"/admin/themes")
assert [theme] = Themes.search("Rook endgame", "endgame")
assert theme.slug == "rook-endgame"
assert theme.kind == :material
assert theme.description == "Positions where a rook and pawn face a rook."
end end
test "renames and recategorises a theme", %{conn: conn} do test "renames and recategorises a theme", %{conn: conn} do
@@ -11,8 +11,8 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.IndexTest do
setup :register_and_log_in_admin setup :register_and_log_in_admin
test "lists themes with their usage count", %{conn: conn} do test "lists themes with their kind and coverage", %{conn: conn} do
used_theme = theme_fixture(%{name: "Lucena"}) used_theme = theme_fixture(%{name: "Lucena", kind: :technique})
unused_theme = theme_fixture(%{name: "Philidor"}) unused_theme = theme_fixture(%{name: "Philidor"})
endgame = endgame_fixture() endgame = endgame_fixture()
{:ok, _} = Endgames.update_endgame(endgame, %{}, [used_theme]) {:ok, _} = Endgames.update_endgame(endgame, %{}, [used_theme])
@@ -20,8 +20,9 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.IndexTest do
{:ok, view, _html} = live(conn, ~p"/admin/themes") {:ok, view, _html} = live(conn, ~p"/admin/themes")
assert has_element?(view, "#theme-#{used_theme.id}") assert has_element?(view, "#theme-#{used_theme.id}")
assert has_element?(view, "#theme-usage-#{used_theme.id}", "1 endgame") assert has_element?(view, "#theme-#{used_theme.id}", "technique")
assert has_element?(view, "#theme-usage-#{unused_theme.id}", "0 endgames") assert has_element?(view, "#theme-usage-#{used_theme.id}", "1 of 1 endgame")
assert has_element?(view, "#theme-usage-#{unused_theme.id}", "0 of 1 endgame")
end end
test "filters by name and category", %{conn: conn} do test "filters by name and category", %{conn: conn} do
@@ -57,7 +58,7 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.IndexTest do
{:ok, view, html} = live(conn, ~p"/admin/themes") {:ok, view, html} = live(conn, ~p"/admin/themes")
assert html =~ "Used by 1 endgame" assert html =~ "Used by 1 of 1 endgame"
assert html =~ "The endgames will be kept" assert html =~ "The endgames will be kept"
view |> element("#theme-#{theme.id} a", "Delete") |> render_click() view |> element("#theme-#{theme.id} a", "Delete") |> render_click()
@@ -0,0 +1,144 @@
defmodule ChesstrainerWeb.Admin.ThemeLive.TagTest do
use ChesstrainerWeb.ConnCase
import Ecto.Query
import Phoenix.LiveViewTest
import Chesstrainer.AccountsFixtures
import Chesstrainer.ThemesFixtures
alias Chesstrainer.Endgames
alias Chesstrainer.Repo
alias Chesstrainer.Themes
setup :register_and_log_in_admin
@kp_v_kp_1 "4k3/8/8/8/8/4p3/4P3/4K3 w - - 0 1"
@kp_v_kp_2 "3k4/8/8/8/8/4p3/4P3/4K3 w - - 0 1"
@kr_v_kr "8/8/3k4/8/8/3K1R2/8/5r2 b - - 0 1"
test "lists candidate groups with counts and previews boards", %{conn: conn} do
theme = technique_theme()
kp_1 = create_endgame!(@kp_v_kp_1)
kp_2 = create_endgame!(@kp_v_kp_2)
kr = create_endgame!(@kr_v_kr)
{:ok, view, _html} = live(conn, ~p"/admin/themes/#{theme.id}/tag")
assert has_element?(view, "#candidate-count", "3")
assert has_element?(view, "#candidates-KP-v-KP", "2")
view |> element("#toggle-candidates-KP-v-KP") |> render_click()
assert has_element?(view, "#endgame-#{kp_1.id}")
assert has_element?(view, "#endgame-#{kp_2.id}")
refute has_element?(view, "#endgame-#{kr.id}")
assert render(view) =~ "Chess position"
end
test "applies the theme in bulk and updates coverage", %{conn: conn} do
theme = technique_theme()
kp_1 = create_endgame!(@kp_v_kp_1)
kp_2 = create_endgame!(@kp_v_kp_2)
_kr = create_endgame!(@kr_v_kr)
{:ok, view, _html} = live(conn, ~p"/admin/themes/#{theme.id}/tag")
view |> element("#toggle-candidates-KP-v-KP") |> render_click()
view |> element("#select-#{kp_1.id}") |> render_click()
view |> element("#select-#{kp_2.id}") |> render_click()
view |> element("#apply-theme") |> render_click()
assert render(view) =~ "Tagged 2 endgame(s)"
assert has_element?(view, "#tagged-count", "2")
assert has_element?(view, "#candidate-count", "1")
assert Enum.sort(curated_endgame_ids(theme)) == Enum.sort([kp_1.id, kp_2.id])
{:ok, _index, html} = live(conn, ~p"/admin/themes")
assert html =~ "2 of 3 endgames"
end
test "removes a curated link but leaves a community link alone", %{conn: conn} do
theme = technique_theme()
curated = create_endgame!(@kp_v_kp_1)
community = create_endgame!(@kr_v_kr)
{:ok, _} = Themes.tag_endgames(theme, [curated.id], :curated)
{:ok, _} = Themes.tag_endgames(theme, [community.id], :community)
{:ok, view, _html} = live(conn, ~p"/admin/themes/#{theme.id}/tag")
view |> element("#toggle-tagged-KP-v-KP") |> render_click()
view |> element("#remove-#{curated.id}") |> render_click()
assert render(view) =~ "Removed"
assert curated_endgame_ids(theme) == []
assert {Ecto.UUID.dump!(community.id), "community"} in link_rows(theme.id)
end
test "refuses a material theme", %{conn: conn} do
{:ok, theme} =
Themes.create_theme(%{name: "Rook endgame", kind: :material, category: :endgame})
assert {:error, {:live_redirect, %{to: "/admin/themes"}}} =
live(conn, ~p"/admin/themes/#{theme.id}/tag")
end
test "switching the theme navigates to its workspace", %{conn: conn} do
first = technique_theme(%{name: "Lucena"})
second = technique_theme(%{name: "Philidor"})
{:ok, view, _html} = live(conn, ~p"/admin/themes/#{first.id}/tag")
assert {:error, {:live_redirect, %{to: path}}} =
view
|> form("#theme-workspace-form", %{theme_id: to_string(second.id)})
|> render_change()
assert path == "/admin/themes/#{second.id}/tag"
end
test "members cannot open the workspace", %{conn: conn} do
theme = technique_theme()
conn = log_in_user(conn, user_fixture())
assert redirected_to(get(conn, ~p"/admin/themes/#{theme.id}/tag")) == ~p"/"
end
defp technique_theme(attrs \\ %{}) do
attrs =
Map.merge(
%{name: unique_theme_name(), kind: :technique, category: :endgame},
attrs
)
{:ok, theme} = Themes.create_theme(attrs)
theme
end
defp create_endgame!(fen) do
{:ok, endgame} =
Endgames.create_endgame(%{fen: fen, color: :white, result: :win, rating: 1500})
endgame
end
defp curated_endgame_ids(theme) do
Repo.all(
from l in "endgames_themes",
where: l.theme_id == ^theme.id and l.source == "curated",
select: l.endgame_id
)
|> Enum.map(&Ecto.UUID.load!/1)
end
defp link_rows(theme_id) do
Repo.all(
from l in "endgames_themes",
where: l.theme_id == ^theme_id,
select: {l.endgame_id, l.source}
)
end
end
@@ -170,6 +170,18 @@ defmodule ChesstrainerWeb.EndgameLive.TrainTest do
assert Enum.any?(endgames, &(&1.id == second.id)) assert Enum.any?(endgames, &(&1.id == second.id))
end end
test "does not serve the same puzzle twice in a session", %{conn: conn} do
{view, [only]} = start_medium_session(conn, 1)
solve_current(view)
view |> element("#next-puzzle-button") |> render_click()
assigns = :sys.get_state(view.pid).socket.assigns
assert has_element?(view, "#pool-exhausted")
assert assigns.endgame.id == only.id
assert assigns.session.served_ids == [only.id]
end
test "keeps next puzzle available while reviewing", %{conn: conn} do test "keeps next puzzle available while reviewing", %{conn: conn} do
{view, endgames} = start_medium_session(conn, 2) {view, endgames} = start_medium_session(conn, 2)
first = :sys.get_state(view.pid).socket.assigns.endgame first = :sys.get_state(view.pid).socket.assigns.endgame
+12 -15
View File
@@ -14,12 +14,12 @@ defmodule ChesstrainerWeb.Plugs.PrelaunchTest do
:ok :ok
end end
test "allows the public pages, legal pages, health, and admin login", %{conn: conn} do test "allows the public pages, legal pages, health, and login", %{conn: conn} do
assert conn |> get(~p"/") |> html_response(200) assert conn |> get(~p"/") |> html_response(200)
assert conn |> get(~p"/privacy") |> html_response(200) assert conn |> get(~p"/privacy") |> html_response(200)
assert conn |> get(~p"/terms-conditions") |> html_response(200) assert conn |> get(~p"/terms-conditions") |> html_response(200)
assert conn |> get(~p"/health") |> response(200) assert conn |> get(~p"/health") |> response(200)
assert conn |> get(~p"/admin/log-in") |> html_response(200) assert conn |> get(~p"/users/log-in") |> html_response(200)
end end
test "hides public auth links and start training", %{conn: conn} do test "hides public auth links and start training", %{conn: conn} do
@@ -30,29 +30,26 @@ defmodule ChesstrainerWeb.Plugs.PrelaunchTest do
refute html =~ "Start training" refute html =~ "Start training"
end end
test "the hidden admin login uses the admin form action", %{conn: conn} do test "the prelaunch login form posts to the public login route", %{conn: conn} do
html = conn |> get(~p"/admin/log-in") |> html_response(200) html = conn |> get(~p"/users/log-in") |> html_response(200)
assert html =~ ~s(action="/admin/log-in") assert html =~ ~s(action="/users/log-in")
refute html =~ "Sign up" refute html =~ "Sign up"
end end
test "pauses the public login route", %{conn: conn} do test "an admin can log in through the public login route", %{conn: conn} do
assert conn |> get(~p"/users/log-in") |> redirected_to() == "/" admin =
end
test "admin login redirects to the admin area", %{conn: conn} do
user =
user_fixture() user_fixture()
|> Ecto.Changeset.change(role: :admin) |> Ecto.Changeset.change(role: :admin)
|> Repo.update!() |> Repo.update!()
conn = conn =
post(conn, ~p"/admin/log-in", post(conn, ~p"/users/log-in",
user: %{email: user.email, password: "hello world!", remember_me: "true"} user: %{email: admin.email, password: "hello world!", remember_me: "true"}
) )
assert redirected_to(conn) == "/admin/endgames" assert get_session(conn, :user_token)
assert get_resp_header(conn, "x-robots-tag") == ["noindex, nofollow"]
end end
test "redirects blocked routes to the home page", %{conn: conn} do test "redirects blocked routes to the home page", %{conn: conn} do
@@ -84,7 +81,7 @@ defmodule ChesstrainerWeb.Plugs.PrelaunchTest do
end end
test "blocks registration reached through LiveView navigation", %{conn: conn} do test "blocks registration reached through LiveView navigation", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/log-in") {:ok, view, _html} = live(conn, ~p"/users/log-in")
assert {:error, {:redirect, %{to: "/"}}} = assert {:error, {:redirect, %{to: "/"}}} =
live_redirect(view, to: ~p"/users/register") live_redirect(view, to: ~p"/users/register")
@@ -0,0 +1,28 @@
defmodule ChesstrainerWeb.StaticCacheTest do
use ChesstrainerWeb.ConnCase, async: true
# One year, matching `Plug.Static` in the endpoint when code reloading is off.
# A missing max-age here lets the CDN fall back to its own short default.
@one_year "public, max-age=31536000, immutable"
# Piece art is committed already hashed, so it is shaped like digested build
# output without requiring `mix assets.build` first (CI's test job does not
# build assets). The endpoint sets one cache option for every static file.
@digested_piece "/images/pieces/white/king-27fd3307056d10dae685faf4ca8f4488.svg"
test "digested assets are cached for a year", %{conn: conn} do
conn = get(conn, @digested_piece)
assert conn.status == 200
assert get_resp_header(conn, "cache-control") == [@one_year]
end
test "stable-name assets are cached for a year", %{conn: conn} do
for path <- ["/fonts/dm-sans-variable.woff2", "/images/og.png", "/favicon.svg"] do
conn = get(conn, path)
assert conn.status == 200
assert get_resp_header(conn, "cache-control") == [@one_year]
end
end
end