mirror of
https://github.com/TheRealOwenRees/chess-endgame-trainer.git
synced 2026-11-18 11:42:07 +00:00
Compare commits
9
Commits
37e0ac8e56
...
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2759b34296 | ||
|
|
e6f08e0ca6 | ||
|
|
946fc38756 | ||
|
|
80cb033077 | ||
|
|
7209923de7
|
||
|
|
f4ff1e00fb
|
||
|
|
514c6ac924
|
||
|
|
e0b446bbfb | ||
|
|
fa1fef7b62 |
@@ -11,6 +11,8 @@ SES_CONFIGURATION_SET=my-first-configuration-set
|
||||
# Optional: override the sender or send everything to one address while testing.
|
||||
# MAIL_FROM=no-reply@mail.innersquare.app
|
||||
# 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=
|
||||
|
||||
MATOMO_URL=https://analytics.owenrees.eu/
|
||||
|
||||
+15
-5
@@ -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.
|
||||
_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
|
||||
|
||||
**Rating**:
|
||||
@@ -128,11 +136,13 @@ systems; the trainer deliberately does not track it.
|
||||
_Avoid_: Variance, inconsistency
|
||||
|
||||
**Difficulty**:
|
||||
A choice — `easy`, `medium` or `hard` — that selects which puzzles to serve
|
||||
relative to the current user's rating: `medium` is near the user's rating,
|
||||
`easy` below it, `hard` above it. The band width 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.
|
||||
A choice — `easy`, `medium` or `hard` — that biases which puzzles are served
|
||||
relative to the current user's rating: `medium` centres on the user's rating,
|
||||
`easy` below it, `hard` above it. Candidates are weighted by how close their
|
||||
rating is to that centre, so a session draws mostly from near the target but the
|
||||
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
|
||||
|
||||
## Infrastructure
|
||||
|
||||
@@ -43,6 +43,10 @@
|
||||
.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-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: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); }
|
||||
@@ -69,6 +73,7 @@ html[data-theme="dark"] .learning-strip { box-shadow: inset 0 1px 0 var(--color-
|
||||
@media (max-width: 650px) {
|
||||
.puzzle-section { width: calc(100% - 36px); padding: 80px 0; }
|
||||
.puzzle-grid { grid-template-columns: 1fr; }
|
||||
.puzzle-coming-soon { min-height: 255px; padding: 38px 22px; }
|
||||
.puzzle-card { min-height: 255px; }
|
||||
.progress-banner { width: calc(100% - 36px); padding: 48px 28px; flex-direction: column; align-items: flex-start; gap: 34px; }
|
||||
}
|
||||
|
||||
@@ -43,6 +43,13 @@
|
||||
/* Play board */
|
||||
#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
|
||||
aspect-ratio container so the board scales with the viewport. */
|
||||
#endgame-board .cg-wrap { width: 100%; height: 100%; }
|
||||
@@ -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 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; }
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
.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 strong { display: block; font-family: 'DM Serif Display', serif; font-size: 28px; font-weight: 400; }
|
||||
@@ -15,7 +17,7 @@
|
||||
|
||||
@media (max-width: 650px) {
|
||||
.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:last-child { grid-column: 1 / -1; }
|
||||
}
|
||||
@@ -14,6 +14,9 @@
|
||||
.nav-links a { transition: opacity .2s; }
|
||||
.nav-links a:hover { opacity: .55; }
|
||||
.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 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; }
|
||||
@@ -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-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-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; }
|
||||
html[data-theme="dark"] .nav-links { box-shadow: 0 18px 40px rgba(0, 0, 0, .45); }
|
||||
}
|
||||
+12
-6
@@ -15,7 +15,8 @@ config :chesstrainer, :branding,
|
||||
wordmark: "INNERSQUARE",
|
||||
tagline: "Endgame Trainer",
|
||||
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
|
||||
# MAILING_LIST_ENABLED; dev and test use these defaults.
|
||||
@@ -61,11 +62,16 @@ config :chesstrainer, :ratings,
|
||||
window_days: 7,
|
||||
rd_inflation_c: 10.0
|
||||
|
||||
# Difficulty bands for puzzle sessions. An endgame is "medium" when its rating
|
||||
# falls within `band_width` of the user's rating, "easy" below that band and
|
||||
# "hard" above it. Tweak to widen or narrow the served difficulty (e.g. 150 or
|
||||
# 200).
|
||||
config :chesstrainer, :puzzles, band_width: 100
|
||||
# Puzzle selection. Difficulty is a weighted bias towards a target rating —
|
||||
# `medium` targets the user's rating, `easy` 200 below it and `hard` 200 above
|
||||
# it — and `spread` is how many rating points it takes for a puzzle's chance to
|
||||
# fall off by a factor of e. `repeat_window_days` is how long an attempted
|
||||
# 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
|
||||
# display order. When empty (or short) the grid is topped up with a date-seeded
|
||||
|
||||
+6
-2
@@ -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
|
||||
# .rtbw/.rtbz files. When unset, the local backend stays disabled and lookups
|
||||
# fall back to Lichess.
|
||||
if tablebase_path = System.get_env("TABLEBASE_PATH") do
|
||||
# fall back to Lichess. Tests are always pinned to the committed 3-piece
|
||||
# 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
|
||||
end
|
||||
end
|
||||
|
||||
# Tablebase cache: size and the UTC time of the daily backup. Environment
|
||||
|
||||
@@ -168,6 +168,18 @@ defmodule Chesstrainer.Accounts do
|
||||
|> Repo.update()
|
||||
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
|
||||
|
||||
@doc """
|
||||
|
||||
@@ -55,6 +55,17 @@ defmodule Chesstrainer.Accounts.User do
|
||||
|> validate_required([:role])
|
||||
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 """
|
||||
A user changeset for an admin-created invitation.
|
||||
|
||||
|
||||
@@ -106,8 +106,8 @@ defmodule Chesstrainer.Attempts do
|
||||
@doc """
|
||||
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
|
||||
attempt, even though the rating window leaves it unrated.
|
||||
Used by puzzle selection to skip puzzles inside the repeat window; a retry
|
||||
still counts as an attempt, even though the rating window leaves it unrated.
|
||||
"""
|
||||
def recent_endgame_ids(user_id, days \\ 30) do
|
||||
cutoff = DateTime.add(DateTime.utc_now(), -days, :day)
|
||||
|
||||
@@ -12,7 +12,8 @@ defmodule Chesstrainer.Branding do
|
||||
wordmark: "INNERSQUARE",
|
||||
tagline: "Endgame Trainer",
|
||||
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\"`."
|
||||
@@ -30,6 +31,26 @@ defmodule Chesstrainer.Branding do
|
||||
@doc "The From address used for outgoing mail."
|
||||
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\"`."
|
||||
def home_title, do: "#{name()} — #{tagline()}"
|
||||
|
||||
|
||||
@@ -111,8 +111,13 @@ defmodule Chesstrainer.Endgames do
|
||||
@doc """
|
||||
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
|
||||
carry any one of them) and `:key` (an exact Key).
|
||||
Filters is a map with optional:
|
||||
|
||||
* `: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
|
||||
Endgame
|
||||
@@ -125,20 +130,31 @@ defmodule Chesstrainer.Endgames do
|
||||
|
||||
@doc """
|
||||
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
|
||||
|> apply_filters(filters)
|
||||
|> where([e], e.key == ^key)
|
||||
|> 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()
|
||||
end
|
||||
|
||||
defp limit_query(query, nil), do: query
|
||||
defp limit_query(query, limit), do: limit(query, ^limit)
|
||||
|
||||
defp apply_filters(query, filters) do
|
||||
query
|
||||
|> filter_themes(Map.get(filters, :themes, []))
|
||||
|> filter_key(Map.get(filters, :key))
|
||||
|> filter_with_theme(Map.get(filters, :with_theme))
|
||||
|> filter_without_theme(Map.get(filters, :without_theme))
|
||||
end
|
||||
|
||||
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), 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 """
|
||||
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
|
||||
@@ -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
|
||||
|
||||
@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
|
||||
(Application.get_env(:chesstrainer, :tablebase_fallback) || Lichess).probe(fen)
|
||||
end
|
||||
|
||||
+85
-58
@@ -2,14 +2,21 @@ defmodule Chesstrainer.Puzzles do
|
||||
@moduledoc """
|
||||
Selects endgames to serve as puzzles.
|
||||
|
||||
A puzzle is played at one of three difficulties — `:easy`, `:medium` or
|
||||
`:hard` — defined relative to the current user's rating: `:medium` is within
|
||||
a configurable band of the user's rating, `:easy` below it and `:hard` above
|
||||
it. The same endgame is therefore easy for one player and hard for another.
|
||||
Difficulty is a bias, not a filter. Every endgame is weighted by how close its
|
||||
rating is to a target derived from the user's rating — the user's own rating
|
||||
for `:medium`, below it for `:easy` and above it for `:hard` — and one
|
||||
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.
|
||||
When that pool is empty it falls back to any endgame in the band; the rating
|
||||
window keeps a recent replay unrated until it expires.
|
||||
Endgames the user has attempted inside the repeat window are skipped, as is
|
||||
anything passed in `:exclude_ids` (the puzzles already served in a session).
|
||||
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
|
||||
@@ -17,95 +24,115 @@ defmodule Chesstrainer.Puzzles do
|
||||
alias Chesstrainer.Repo
|
||||
alias Chesstrainer.Accounts.User
|
||||
alias Chesstrainer.Attempts
|
||||
alias Chesstrainer.Attempts.Attempt
|
||||
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]
|
||||
|
||||
@doc "The difficulties a session can be played at."
|
||||
def difficulties, do: @difficulties
|
||||
|
||||
@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
|
||||
:chesstrainer
|
||||
|> Application.get_env(:puzzles, [])
|
||||
|> Keyword.get(:band_width, @default_band_width)
|
||||
end
|
||||
def spread, do: setting(:spread, @default_spread)
|
||||
|
||||
@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
|
||||
width = band_width()
|
||||
def repeat_window_days, do: setting(:repeat_window_days, @default_repeat_window_days)
|
||||
|
||||
case difficulty do
|
||||
:easy -> {nil, rating - width}
|
||||
:medium -> {rating - width, rating + width}
|
||||
:hard -> {rating + width, nil}
|
||||
end
|
||||
@doc """
|
||||
The rating `difficulty` aims at, given the player's `rating`.
|
||||
|
||||
The offsets are configured under `:chesstrainer, :puzzles, :targets`.
|
||||
"""
|
||||
def difficulty_target(rating, difficulty) when difficulty in @difficulties do
|
||||
rating + Keyword.fetch!(setting(:targets, @default_targets), difficulty)
|
||||
end
|
||||
|
||||
@doc """
|
||||
Picks the next puzzle for `user` at `difficulty`, using `user.rating` as the
|
||||
baseline.
|
||||
|
||||
`:exclude_ids` (default `[]`) skips endgames by id — used to avoid repeating
|
||||
the puzzle just played. Returns `nil` when no endgame exists at all.
|
||||
`:exclude_ids` (default `[]`) skips endgames by id — used for the puzzles
|
||||
already served in this session. Returns `nil` when no endgame exists at all.
|
||||
"""
|
||||
def next_endgame(%User{} = user, difficulty, opts \\ [])
|
||||
when difficulty in @difficulties do
|
||||
exclude_ids = Keyword.get(opts, :exclude_ids, [])
|
||||
band = difficulty_range(user.rating, difficulty)
|
||||
recent_ids = Attempts.recent_endgame_ids(user.id)
|
||||
recent_ids = Attempts.recent_endgame_ids(user.id, repeat_window_days())
|
||||
target = difficulty_target(user.rating, difficulty)
|
||||
|
||||
fresh =
|
||||
Endgame
|
||||
|> in_band(band)
|
||||
|> skip_ids(exclude_ids)
|
||||
|> skip_ids(recent_ids)
|
||||
|> 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()
|
||||
|> on_side_of(user.rating, difficulty)
|
||||
|> skip_ids(exclude_ids ++ recent_ids)
|
||||
|> weighted_one(target)
|
||||
|> case do
|
||||
nil -> nearest(rating, exclude_ids)
|
||||
nil -> least_recently_attempted(user.id, exclude_ids)
|
||||
endgame -> endgame
|
||||
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
|
||||
|> 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)
|
||||
|> Repo.one()
|
||||
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, 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
|
||||
|
||||
@@ -18,6 +18,28 @@ defmodule Chesstrainer.Release do
|
||||
{:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
|
||||
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
|
||||
Application.fetch_env!(@app, :ecto_repos)
|
||||
end
|
||||
|
||||
+184
-3
@@ -4,6 +4,8 @@ defmodule Chesstrainer.Themes do
|
||||
"""
|
||||
|
||||
import Ecto.Query, warn: false
|
||||
alias Chesstrainer.Accounts.Policy
|
||||
alias Chesstrainer.Accounts.Scope
|
||||
alias Chesstrainer.Repo
|
||||
|
||||
alias Chesstrainer.Themes.Theme
|
||||
@@ -74,9 +76,26 @@ defmodule Chesstrainer.Themes do
|
||||
"""
|
||||
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 """
|
||||
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
|
||||
|
||||
iex> create_theme(%{field: value})
|
||||
@@ -92,6 +111,21 @@ defmodule Chesstrainer.Themes do
|
||||
|> Repo.insert()
|
||||
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 """
|
||||
Updates a theme.
|
||||
|
||||
@@ -160,20 +194,167 @@ defmodule Chesstrainer.Themes do
|
||||
@doc """
|
||||
Finds a theme by name (trimmed and case-insensitive) for a category, creating it
|
||||
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)
|
||||
|
||||
if name == "" do
|
||||
{:error, :blank_name}
|
||||
else
|
||||
case find_by_name(name, category) do
|
||||
nil -> create_theme(%{name: name, category: category})
|
||||
theme -> {:ok, theme}
|
||||
nil ->
|
||||
create_theme(%{
|
||||
name: name,
|
||||
category: category,
|
||||
kind: Keyword.get(opts, :kind, :technique)
|
||||
})
|
||||
|
||||
theme ->
|
||||
{:ok, theme}
|
||||
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
|
||||
downcased = String.downcase(name)
|
||||
|
||||
|
||||
@@ -1,29 +1,106 @@
|
||||
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
|
||||
import Ecto.Changeset
|
||||
|
||||
@type t :: %__MODULE__{}
|
||||
|
||||
@kinds [material: "material", motif: "motif", technique: "technique"]
|
||||
|
||||
schema "themes" do
|
||||
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"]
|
||||
|
||||
timestamps(type: :utc_datetime)
|
||||
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
|
||||
def changeset(theme, attrs) do
|
||||
theme
|
||||
|> cast(attrs, [:name, :category])
|
||||
|> update_change(:name, fn
|
||||
name when is_binary(name) -> String.trim(name)
|
||||
name -> name
|
||||
end)
|
||||
|> validate_required([:name, :category])
|
||||
|> cast(attrs, [:name, :slug, :description, :kind, :category])
|
||||
|> update_change(:name, &trim/1)
|
||||
|> update_change(:description, &trim/1)
|
||||
|> put_slug()
|
||||
|> validate_required([:name, :slug, :kind, :category])
|
||||
|> 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,
|
||||
name: :themes_name_category_lower_index,
|
||||
message: "already exists"
|
||||
)
|
||||
|> unique_constraint(:slug, message: "is already taken")
|
||||
|> check_constraint(:kind, name: :themes_kind_in_allowed)
|
||||
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
|
||||
|
||||
@@ -126,8 +126,15 @@ defmodule ChesstrainerWeb.Layouts do
|
||||
Start training <.icon_arrow />
|
||||
</.pill_button>
|
||||
<% end %>
|
||||
|
||||
<div class="nav-menu-tools">
|
||||
<.colour_mode_toggle />
|
||||
<.discord_link />
|
||||
</div>
|
||||
</div>
|
||||
<% end %>
|
||||
|
||||
<.discord_link />
|
||||
</div>
|
||||
</nav>
|
||||
</header>
|
||||
@@ -225,6 +232,7 @@ defmodule ChesstrainerWeb.Layouts do
|
||||
<a href="/terms-conditions">Terms & Conditions</a>
|
||||
<a href="/mentions-legales">Mentions légales</a>
|
||||
<a href="/sitemap.xml">Sitemap</a>
|
||||
<.discord_link />
|
||||
</nav>
|
||||
|
||||
<small>© {@year} {Branding.name()}</small>
|
||||
@@ -232,6 +240,35 @@ defmodule ChesstrainerWeb.Layouts do
|
||||
"""
|
||||
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 """
|
||||
Shows the flash group with standard titles and content.
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
<head>
|
||||
<meta charset="utf-8" />
|
||||
<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()} />
|
||||
<.live_title
|
||||
|
||||
@@ -65,7 +65,10 @@
|
||||
if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
|
||||
|
||||
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 index = (buttons.indexOf(button) + offset + buttons.length) % buttons.length;
|
||||
const next = buttons[index];
|
||||
|
||||
@@ -10,7 +10,7 @@ defmodule ChesstrainerWeb.HealthController do
|
||||
status = if health.status == "down", do: :service_unavailable, else: :ok
|
||||
|
||||
conn
|
||||
|> put_resp_header("x-robots-tag", "noindex")
|
||||
|> put_resp_header("x-robots-tag", "noindex, nofollow")
|
||||
|> put_status(status)
|
||||
|> json(health)
|
||||
end
|
||||
|
||||
@@ -40,8 +40,11 @@
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<%!-- <section class="learning-strip" id="method">
|
||||
<p>Built for the part of chess that decides everything.</p>
|
||||
<section class="learning-strip" id="method">
|
||||
<figure class="learning-quote">
|
||||
<blockquote>“The hardest game to win is a won game.”</blockquote>
|
||||
<figcaption>— Emmanuel Lasker</figcaption>
|
||||
</figure>
|
||||
<div class="stat">
|
||||
<strong>{count_label(@puzzle_count)}</strong>
|
||||
<span>puzzles</span>
|
||||
@@ -50,9 +53,9 @@
|
||||
<strong>{@user_count}</strong>
|
||||
<span>Players improving their endgame</span>
|
||||
</div>
|
||||
</section> --%>
|
||||
</section>
|
||||
|
||||
<%!-- <section class="puzzle-section" id="puzzles">
|
||||
<section class="puzzle-section" id="puzzles">
|
||||
<div class="section-heading">
|
||||
<div>
|
||||
<span class="section-kicker">Choose your lesson</span>
|
||||
@@ -65,16 +68,16 @@
|
||||
that you’ll recognise over the board.
|
||||
</p>
|
||||
</div>
|
||||
<div class="puzzle-grid">
|
||||
<%= for {endgame, index} <- Enum.with_index(@endgames) do %>
|
||||
<.puzzle_card
|
||||
endgame={endgame}
|
||||
index={index}
|
||||
active={@active_endgame && endgame.id == @active_endgame.id}
|
||||
/>
|
||||
<% end %>
|
||||
<div class="puzzle-coming-soon">
|
||||
<div class="eyebrow">
|
||||
<.icon_spark /> Coming soon
|
||||
</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} />
|
||||
|
||||
|
||||
@@ -6,19 +6,20 @@ defmodule ChesstrainerWeb.SitemapController do
|
||||
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
|
||||
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
|
||||
|
||||
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 = [
|
||||
{url(conn, ~p"/"), Date.utc_today()},
|
||||
{url(conn, ~p"/privacy"), nil},
|
||||
{url(conn, ~p"/terms-conditions"), nil},
|
||||
{url(conn, ~p"/mentions-legales"), nil}
|
||||
url(conn, ~p"/"),
|
||||
url(conn, ~p"/privacy"),
|
||||
url(conn, ~p"/terms-conditions"),
|
||||
url(conn, ~p"/mentions-legales")
|
||||
]
|
||||
|
||||
conn
|
||||
@@ -28,8 +29,8 @@ defmodule ChesstrainerWeb.SitemapController do
|
||||
|
||||
defp render_sitemap(entries) do
|
||||
urls =
|
||||
Enum.map_join(entries, fn {loc, lastmod} ->
|
||||
" <url><loc>#{escape(loc)}</loc>#{lastmod_entry(lastmod)}</url>\n"
|
||||
Enum.map_join(entries, fn loc ->
|
||||
" <url><loc>#{escape(loc)}</loc></url>\n"
|
||||
end)
|
||||
|
||||
"""
|
||||
@@ -39,9 +40,6 @@ defmodule ChesstrainerWeb.SitemapController do
|
||||
"""
|
||||
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,
|
||||
# so XML-significant characters must be escaped here.
|
||||
defp escape(value) do
|
||||
|
||||
@@ -12,14 +12,6 @@ defmodule ChesstrainerWeb.UserSessionController do
|
||||
authenticate(conn, user_params, ~p"/users/log-in", nil)
|
||||
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
|
||||
%{"email" => login} = user_params
|
||||
address = ClientAddress.from_conn(conn)
|
||||
|
||||
@@ -19,12 +19,18 @@ defmodule ChesstrainerWeb.Endpoint do
|
||||
#
|
||||
# When code reloading is disabled (e.g., in production),
|
||||
# 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,
|
||||
at: "/",
|
||||
from: :chesstrainer,
|
||||
gzip: not code_reloading?,
|
||||
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?
|
||||
|
||||
# Code reloading can be explicitly enabled under the
|
||||
|
||||
@@ -11,6 +11,12 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
|
||||
{"Tactic", "tactic"}
|
||||
]
|
||||
|
||||
@kind_options [
|
||||
{"Technique", "technique"},
|
||||
{"Motif", "motif"},
|
||||
{"Material", "material"}
|
||||
]
|
||||
|
||||
@impl true
|
||||
def render(assigns) do
|
||||
~H"""
|
||||
@@ -21,18 +27,31 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
|
||||
{@page_title}
|
||||
<:subtitle>
|
||||
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>
|
||||
</.header>
|
||||
|
||||
<.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[:kind]}
|
||||
type="select"
|
||||
label="Kind"
|
||||
options={@kind_options}
|
||||
/>
|
||||
<.input
|
||||
field={@form[:category]}
|
||||
type="select"
|
||||
label="Category"
|
||||
options={@category_options}
|
||||
/>
|
||||
<.input
|
||||
field={@form[:description]}
|
||||
type="textarea"
|
||||
label="Description"
|
||||
rows="3"
|
||||
/>
|
||||
|
||||
<footer>
|
||||
<.button phx-disable-with="Saving..." variant="primary">Save theme</.button>
|
||||
@@ -54,6 +73,7 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
|
||||
socket
|
||||
|> assign(:page_title, "New theme")
|
||||
|> assign(:theme, theme)
|
||||
|> assign(:kind_options, @kind_options)
|
||||
|> assign(:category_options, @category_options)
|
||||
|> assign(:form, to_form(Themes.change_theme(theme)))
|
||||
end
|
||||
@@ -64,6 +84,7 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
|
||||
socket
|
||||
|> assign(:page_title, "Edit theme")
|
||||
|> assign(:theme, theme)
|
||||
|> assign(:kind_options, @kind_options)
|
||||
|> assign(:category_options, @category_options)
|
||||
|> assign(:form, to_form(Themes.change_theme(theme)))
|
||||
end
|
||||
@@ -87,13 +108,16 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
|
||||
end
|
||||
|
||||
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} ->
|
||||
{:noreply,
|
||||
socket
|
||||
|> put_flash(:info, "Theme created successfully.")
|
||||
|> push_navigate(to: ~p"/admin/themes")}
|
||||
|
||||
{:error, :unauthorized} ->
|
||||
{:noreply, put_flash(socket, :error, "You are not authorized to manage themes.")}
|
||||
|
||||
{:error, %Ecto.Changeset{} = changeset} ->
|
||||
{:noreply, assign(socket, :form, to_form(changeset, action: :insert))}
|
||||
end
|
||||
|
||||
@@ -2,6 +2,7 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
|
||||
use ChesstrainerWeb, :live_view
|
||||
|
||||
alias Chesstrainer.Accounts.Policy
|
||||
alias Chesstrainer.Endgames
|
||||
alias Chesstrainer.Themes
|
||||
|
||||
@category_options [
|
||||
@@ -20,7 +21,8 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
|
||||
<.header>
|
||||
Themes
|
||||
<: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.
|
||||
</:subtitle>
|
||||
<:actions>
|
||||
@@ -69,26 +71,36 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Name</th>
|
||||
<th>Kind</th>
|
||||
<th>Category</th>
|
||||
<th>Used by</th>
|
||||
<th>Coverage</th>
|
||||
<th><span class="sr-only">Actions</span></th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody id="themes">
|
||||
<tr :for={{theme, usage_count} <- @themes} id={"theme-#{theme.id}"}>
|
||||
<td>{theme.name}</td>
|
||||
<td>{theme.kind}</td>
|
||||
<td>{theme.category}</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 class="w-0 font-semibold">
|
||||
<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
|
||||
phx-click="delete"
|
||||
phx-value-id={theme.id}
|
||||
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."
|
||||
}
|
||||
>
|
||||
@@ -152,9 +164,10 @@ defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
|
||||
category: socket.assigns.category
|
||||
)
|
||||
|
||||
assign(socket, :themes, themes)
|
||||
assign(socket, themes: themes, total_endgames: Endgames.count_endgames())
|
||||
end
|
||||
|
||||
defp usage_label(1), do: "1 endgame"
|
||||
defp usage_label(count), do: "#{count} endgames"
|
||||
defp coverage_label(count, total) do
|
||||
"#{count} of #{total} #{if total == 1, do: "endgame", else: "endgames"}"
|
||||
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
|
||||
def mount(_params, _session, socket) do
|
||||
socket = assign(socket, :limit, GuestLimits.limit())
|
||||
socket =
|
||||
socket
|
||||
|> assign(:limit, GuestLimits.limit())
|
||||
|> assign(:served_ids, [])
|
||||
|
||||
cond do
|
||||
signed_in?(socket) ->
|
||||
@@ -217,11 +220,7 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
|
||||
|> assign(:limit_reached, retry_ms)
|
||||
|
||||
{:ok, _remaining} ->
|
||||
endgame =
|
||||
Endgames.random_endgame(exclude_ids: [socket.assigns.endgame.id]) ||
|
||||
Endgames.random_endgame()
|
||||
|
||||
case endgame do
|
||||
case random_unserved(socket) do
|
||||
nil -> assign(socket, :empty, :exhausted)
|
||||
endgame -> start_guest_puzzle(socket, socket.assigns.guest_address, endgame)
|
||||
end
|
||||
@@ -234,13 +233,21 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
|
||||
{:ok, limit_wall(socket, address, retry_ms)}
|
||||
|
||||
{:ok, _remaining} ->
|
||||
case Endgames.random_endgame() do
|
||||
case random_unserved(socket) do
|
||||
nil -> {:ok, empty_pool(socket, address)}
|
||||
endgame -> {:ok, start_guest_puzzle(socket, address, endgame)}
|
||||
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
|
||||
case GuestLimits.take(address) do
|
||||
{:ok, remaining} ->
|
||||
@@ -250,6 +257,7 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
|
||||
|> assign(:guest_remaining, remaining)
|
||||
|> assign(:limit_reached, nil)
|
||||
|> assign(:empty, nil)
|
||||
|> assign(:served_ids, [endgame.id | socket.assigns.served_ids])
|
||||
|> PlayCore.init(endgame, page_title: "Train")
|
||||
|
||||
{:limit_reached, retry_ms} ->
|
||||
|
||||
@@ -106,7 +106,7 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
|
||||
id="pool-exhausted"
|
||||
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">
|
||||
There are no more {difficulty_label(@session.difficulty)} puzzles right now.
|
||||
Try again, or pick another difficulty.
|
||||
@@ -161,7 +161,7 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
|
||||
<div>
|
||||
<h2 class="text-lg font-semibold">Choose a difficulty</h2>
|
||||
<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>
|
||||
</div>
|
||||
<.link
|
||||
@@ -190,7 +190,7 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
|
||||
</.button>
|
||||
</div>
|
||||
<div class="mt-4 grid gap-2">
|
||||
<%= for {difficulty, label, description} <- difficulty_options(@user_rating) do %>
|
||||
<%= for {difficulty, label, description} <- difficulty_options() do %>
|
||||
<.button
|
||||
id={"difficulty-#{difficulty}"}
|
||||
phx-click="start_session"
|
||||
@@ -315,7 +315,8 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
|
||||
started_at_ms: System.system_time(:millisecond),
|
||||
baseline: socket.assigns.user_rating,
|
||||
count: 0,
|
||||
sum_ms: 0
|
||||
sum_ms: 0,
|
||||
served_ids: [endgame.id]
|
||||
}
|
||||
|
||||
socket
|
||||
@@ -333,13 +334,16 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
|
||||
|
||||
if session do
|
||||
case Puzzles.next_endgame(selection_user(socket), session.difficulty,
|
||||
exclude_ids: [socket.assigns.endgame.id]
|
||||
exclude_ids: session.served_ids
|
||||
) do
|
||||
nil ->
|
||||
assign(socket, :pool, %{difficulty: session.difficulty})
|
||||
|
||||
endgame ->
|
||||
session = %{session | served_ids: [endgame.id | session.served_ids]}
|
||||
|
||||
socket
|
||||
|> assign(:session, session)
|
||||
|> assign(:pool, nil)
|
||||
|> assign(:puzzle_started_mono, System.monotonic_time(:millisecond))
|
||||
|> assign(:puzzle_counted, false)
|
||||
@@ -395,13 +399,11 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
|
||||
|
||||
defp parse_difficulty(_value), do: :medium
|
||||
|
||||
defp difficulty_options(rating) do
|
||||
width = Puzzles.band_width()
|
||||
|
||||
defp difficulty_options do
|
||||
[
|
||||
{:easy, "Easy", "below #{round(rating - width)}"},
|
||||
{:medium, "Medium", "#{round(rating - width)}–#{round(rating + width)}"},
|
||||
{:hard, "Hard", "above #{round(rating + width)}"}
|
||||
{:easy, "Easy", "easier than your rating"},
|
||||
{:medium, "Medium", "around your rating"},
|
||||
{:hard, "Hard", "harder than your rating"}
|
||||
]
|
||||
end
|
||||
|
||||
|
||||
@@ -27,7 +27,7 @@ defmodule ChesstrainerWeb.UserLive.Login do
|
||||
:let={f}
|
||||
for={@form}
|
||||
id="login_form_password"
|
||||
action={@login_action}
|
||||
action={~p"/users/log-in"}
|
||||
phx-submit="submit_password"
|
||||
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)])
|
||||
|
||||
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,
|
||||
assign(socket,
|
||||
form: form,
|
||||
trigger_submit: false,
|
||||
prelaunch: prelaunch,
|
||||
login_action: login_action
|
||||
prelaunch: ChesstrainerWeb.prelaunch?()
|
||||
)}
|
||||
end
|
||||
|
||||
|
||||
@@ -19,6 +19,7 @@ defmodule ChesstrainerWeb.Plugs.Prelaunch do
|
||||
/health
|
||||
/robots.txt
|
||||
/sitemap.xml
|
||||
/users/log-in
|
||||
/favicon.ico
|
||||
/favicon.svg
|
||||
/favicon-16x16.png
|
||||
@@ -40,7 +41,6 @@ defmodule ChesstrainerWeb.Plugs.Prelaunch do
|
||||
/assets
|
||||
/fonts
|
||||
/images
|
||||
/dev
|
||||
)
|
||||
|
||||
def init(opts), do: opts
|
||||
|
||||
@@ -36,8 +36,6 @@ defmodule ChesstrainerWeb.Router do
|
||||
get "/terms-conditions", PageController, :terms_conditions
|
||||
get "/mentions-legales", PageController, :mentions_legales
|
||||
post "/mailing-list", MailingListController, :create
|
||||
get "/mailing-list/confirm/:token", MailingListController, :confirm
|
||||
post "/admin/log-in", UserSessionController, :create_admin
|
||||
end
|
||||
|
||||
scope "/admin", ChesstrainerWeb do
|
||||
@@ -57,6 +55,7 @@ defmodule ChesstrainerWeb.Router do
|
||||
live "/themes", Admin.ThemeLive.Index, :index
|
||||
live "/themes/new", Admin.ThemeLive.Form, :new
|
||||
live "/themes/:id/edit", Admin.ThemeLive.Form, :edit
|
||||
live "/themes/:id/tag", Admin.ThemeLive.Tag, :tag
|
||||
|
||||
live "/users", Admin.UserLive.Index, :index
|
||||
live "/users/new", Admin.UserLive.New, :new
|
||||
@@ -89,7 +88,7 @@ defmodule ChesstrainerWeb.Router do
|
||||
## Authentication routes
|
||||
|
||||
scope "/", ChesstrainerWeb do
|
||||
pipe_through [:browser, :require_authenticated_user]
|
||||
pipe_through [:browser, :noindex, :require_authenticated_user]
|
||||
|
||||
live_session :require_authenticated_user,
|
||||
on_mount: [
|
||||
@@ -124,12 +123,12 @@ defmodule ChesstrainerWeb.Router do
|
||||
live "/endgames/:public_code/play", EndgameLive.Play, :play
|
||||
live "/users/register", UserLive.Registration, :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/:token", UserLive.ResetPassword, :edit
|
||||
end
|
||||
|
||||
get "/users/confirm/:token", UserConfirmationController, :edit
|
||||
get "/mailing-list/confirm/:token", MailingListController, :confirm
|
||||
|
||||
post "/users/log-in", UserSessionController, :create
|
||||
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
|
||||
# branded 404 page with the site chrome instead of Phoenix's bare status page.
|
||||
scope "/", ChesstrainerWeb do
|
||||
pipe_through :browser
|
||||
pipe_through [:browser, :noindex]
|
||||
|
||||
match :*, "/*path", PageController, :not_found
|
||||
end
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -59,7 +59,14 @@ theme_names =
|
||||
Repo.insert_all(
|
||||
Theme,
|
||||
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),
|
||||
on_conflict: :nothing
|
||||
)
|
||||
|
||||
@@ -6,8 +6,7 @@ defmodule Chesstrainer.Repo.Seeds.Endgames.Win do
|
||||
color: :white,
|
||||
message: "Rook vs king endgame",
|
||||
notes: "Basic rook endgame",
|
||||
result: :win,
|
||||
themes: ["rook endgame"]
|
||||
result: :win
|
||||
},
|
||||
%{
|
||||
fen: "8/8/8/1P4p1/5k2/5p2/P6K/8 b - - 0 0",
|
||||
|
||||
@@ -8,6 +8,10 @@ defmodule Chesstrainer.Repo.Seeds.Themes do
|
||||
"Lucena",
|
||||
"Philidor",
|
||||
"opposition",
|
||||
"key squares",
|
||||
"triangulation",
|
||||
"shouldering",
|
||||
"king activity",
|
||||
"promotion",
|
||||
"stalemate"
|
||||
]
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
defmodule Chesstrainer.AccountsAdminTest do
|
||||
use Chesstrainer.DataCase, async: false
|
||||
|
||||
require Logger
|
||||
|
||||
import Chesstrainer.AccountsFixtures
|
||||
import ExUnit.CaptureLog
|
||||
import Swoosh.TestAssertions
|
||||
|
||||
@@ -276,6 +276,21 @@ defmodule Chesstrainer.AccountsTest do
|
||||
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
|
||||
test "validates the authenticated_at time" do
|
||||
now = DateTime.utc_now()
|
||||
|
||||
@@ -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: []}}
|
||||
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
|
||||
# Not async: the local backend reads app config and Fathom keeps global state.
|
||||
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"
|
||||
@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
|
||||
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)
|
||||
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
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
defmodule Chesstrainer.EndgamesTest do
|
||||
use Chesstrainer.DataCase
|
||||
|
||||
import Chesstrainer.EndgamesFixtures
|
||||
|
||||
alias Chesstrainer.Endgames
|
||||
alias Chesstrainer.Endgames.Endgame
|
||||
alias Chesstrainer.Themes
|
||||
@@ -387,4 +389,30 @@ defmodule Chesstrainer.EndgamesTest do
|
||||
assert Endgames.curated_endgames() == []
|
||||
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
|
||||
|
||||
@@ -7,6 +7,7 @@ defmodule Chesstrainer.PuzzlesTest do
|
||||
alias Chesstrainer.Accounts.Scope
|
||||
alias Chesstrainer.Attempts
|
||||
alias Chesstrainer.Puzzles
|
||||
alias Chesstrainer.Repo
|
||||
|
||||
# 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
|
||||
@@ -22,71 +23,103 @@ defmodule Chesstrainer.PuzzlesTest do
|
||||
endgame_fixture(fen: Enum.fetch!(@fens, index), rating: rating)
|
||||
end
|
||||
|
||||
describe "difficulty_range/2" do
|
||||
test "is centred on the rating and open-ended at the extremes" do
|
||||
assert Puzzles.difficulty_range(1500, :medium) == {1400, 1600}
|
||||
assert Puzzles.difficulty_range(1500, :easy) == {nil, 1400}
|
||||
assert Puzzles.difficulty_range(1500, :hard) == {1600, nil}
|
||||
defp attempt_days_ago(user, endgame, days) do
|
||||
{:ok, attempt} = Attempts.record_attempt(Scope.for_user(user), endgame, :solved)
|
||||
|
||||
attempt
|
||||
|> 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
|
||||
|
||||
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()
|
||||
in_band = endgame_at(1550, 0)
|
||||
_out_of_band = endgame_at(1900, 1)
|
||||
near = endgame_at(1500, 0)
|
||||
_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
|
||||
|
||||
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()
|
||||
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
|
||||
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()
|
||||
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
|
||||
end
|
||||
|
||||
test "falls back to the nearest endgame when the band is empty" 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
|
||||
test "prefers endgames not attempted inside the repeat window" do
|
||||
user = user_fixture()
|
||||
attempted = endgame_at(1500, 0)
|
||||
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
|
||||
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()
|
||||
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
|
||||
end
|
||||
|
||||
test "skips excluded ids" do
|
||||
test "falls back to the least recently attempted endgame when all are excluded" do
|
||||
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)
|
||||
|
||||
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
|
||||
|
||||
test "returns nil when no endgames exist" do
|
||||
|
||||
@@ -1,13 +1,21 @@
|
||||
defmodule Chesstrainer.ThemesTest do
|
||||
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
|
||||
|
||||
describe "themes" do
|
||||
alias Chesstrainer.Themes.Theme
|
||||
|
||||
import Chesstrainer.ThemesFixtures
|
||||
|
||||
@invalid_attrs %{name: nil, category: nil}
|
||||
|
||||
test "list_themes/0 returns all themes" do
|
||||
@@ -76,4 +84,200 @@ defmodule Chesstrainer.ThemesTest do
|
||||
assert changeset.errors[:name]
|
||||
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
|
||||
|
||||
@@ -5,6 +5,7 @@ defmodule ChesstrainerWeb.LayoutsTest do
|
||||
|
||||
alias Chesstrainer.Accounts.Scope
|
||||
alias Chesstrainer.Accounts.User
|
||||
alias Chesstrainer.Branding
|
||||
alias ChesstrainerWeb.Layouts
|
||||
|
||||
describe "navbar/1" do
|
||||
@@ -28,6 +29,53 @@ defmodule ChesstrainerWeb.LayoutsTest do
|
||||
assert html =~ ~p"/users/register"
|
||||
refute html =~ ~s(class="nav-user-menu")
|
||||
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
|
||||
|
||||
describe "colour_mode_toggle/1" do
|
||||
|
||||
@@ -10,7 +10,7 @@ defmodule ChesstrainerWeb.HealthControllerTest do
|
||||
assert body["db"] == "ok"
|
||||
assert body["tablebase"] == "local"
|
||||
assert body["process"] == "ok"
|
||||
assert get_resp_header(conn, "x-robots-tag") == ["noindex"]
|
||||
assert get_resp_header(conn, "x-robots-tag") == ["noindex, nofollow"]
|
||||
end
|
||||
|
||||
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["tablebase"] == "local"
|
||||
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
|
||||
|
||||
|
||||
@@ -68,10 +68,17 @@ defmodule ChesstrainerWeb.PageControllerTest do
|
||||
assert LazyHTML.text(LazyHTML.query(document, "title")) =~ Branding.home_title()
|
||||
refute html =~ "Phoenix Framework"
|
||||
|
||||
eyebrow = LazyHTML.query(document, ".eyebrow")
|
||||
eyebrow = LazyHTML.query(document, ".hero .eyebrow")
|
||||
assert LazyHTML.text(eyebrow) =~ "Endgames, simplified"
|
||||
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") ==
|
||||
[@description]
|
||||
|
||||
@@ -381,7 +388,7 @@ defmodule ChesstrainerWeb.PageControllerTest do
|
||||
refute html =~ "Browse puzzles"
|
||||
assert html =~ ~s(class="site-footer")
|
||||
assert html =~ "/assets/js/marketing.js"
|
||||
assert html =~ ~s(name="robots")
|
||||
assert html =~ ~s(<meta name="robots" content="noindex, nofollow")
|
||||
end
|
||||
|
||||
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(<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">)
|
||||
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}/terms-conditions</loc>"
|
||||
assert body =~ "<loc>#{base_url}/mentions-legales</loc>"
|
||||
assert length(:binary.matches(body, "<url>")) == 4
|
||||
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)
|
||||
|
||||
assert length(:binary.matches(body, "<lastmod>")) == 1
|
||||
refute body =~ "<lastmod>"
|
||||
end
|
||||
|
||||
test "is served as XML", %{conn: conn} do
|
||||
|
||||
@@ -186,22 +186,6 @@ defmodule ChesstrainerWeb.UserSessionControllerTest do
|
||||
assert get_session(conn, :user_token)
|
||||
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
|
||||
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 [%{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
|
||||
|
||||
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
|
||||
|
||||
test "lists themes with their usage count", %{conn: conn} do
|
||||
used_theme = theme_fixture(%{name: "Lucena"})
|
||||
test "lists themes with their kind and coverage", %{conn: conn} do
|
||||
used_theme = theme_fixture(%{name: "Lucena", kind: :technique})
|
||||
unused_theme = theme_fixture(%{name: "Philidor"})
|
||||
endgame = endgame_fixture()
|
||||
{: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")
|
||||
|
||||
assert has_element?(view, "#theme-#{used_theme.id}")
|
||||
assert has_element?(view, "#theme-usage-#{used_theme.id}", "1 endgame")
|
||||
assert has_element?(view, "#theme-usage-#{unused_theme.id}", "0 endgames")
|
||||
assert has_element?(view, "#theme-#{used_theme.id}", "technique")
|
||||
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
|
||||
|
||||
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")
|
||||
|
||||
assert html =~ "Used by 1 endgame"
|
||||
assert html =~ "Used by 1 of 1 endgame"
|
||||
assert html =~ "The endgames will be kept"
|
||||
|
||||
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))
|
||||
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
|
||||
{view, endgames} = start_medium_session(conn, 2)
|
||||
first = :sys.get_state(view.pid).socket.assigns.endgame
|
||||
|
||||
@@ -14,12 +14,12 @@ defmodule ChesstrainerWeb.Plugs.PrelaunchTest do
|
||||
:ok
|
||||
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"/privacy") |> html_response(200)
|
||||
assert conn |> get(~p"/terms-conditions") |> html_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
|
||||
|
||||
test "hides public auth links and start training", %{conn: conn} do
|
||||
@@ -30,29 +30,26 @@ defmodule ChesstrainerWeb.Plugs.PrelaunchTest do
|
||||
refute html =~ "Start training"
|
||||
end
|
||||
|
||||
test "the hidden admin login uses the admin form action", %{conn: conn} do
|
||||
html = conn |> get(~p"/admin/log-in") |> html_response(200)
|
||||
test "the prelaunch login form posts to the public login route", %{conn: conn} do
|
||||
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"
|
||||
end
|
||||
|
||||
test "pauses the public login route", %{conn: conn} do
|
||||
assert conn |> get(~p"/users/log-in") |> redirected_to() == "/"
|
||||
end
|
||||
|
||||
test "admin login redirects to the admin area", %{conn: conn} do
|
||||
user =
|
||||
test "an admin can log in through the public login route", %{conn: conn} do
|
||||
admin =
|
||||
user_fixture()
|
||||
|> Ecto.Changeset.change(role: :admin)
|
||||
|> Repo.update!()
|
||||
|
||||
conn =
|
||||
post(conn, ~p"/admin/log-in",
|
||||
user: %{email: user.email, password: "hello world!", remember_me: "true"}
|
||||
post(conn, ~p"/users/log-in",
|
||||
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
|
||||
|
||||
test "redirects blocked routes to the home page", %{conn: conn} do
|
||||
@@ -84,7 +81,7 @@ defmodule ChesstrainerWeb.Plugs.PrelaunchTest do
|
||||
end
|
||||
|
||||
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: "/"}}} =
|
||||
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
|
||||
Reference in New Issue
Block a user