Compare commits

..
7 Commits
Author SHA1 Message Date
owenrees 7658450573 Full-width list/show pages and trim the admin table
List and show pages now use a wide container (max-w-7xl) while the form and
play pages keep the narrow column. The admin table drops Fen, Message, Notes,
Attempted and Solved — all already shown on the show page — so it fits
without right-overflow.

Closes #16
2026-11-02 11:04:04 +01:00
owenrees 49c3cddffb Group and filter the player endgame picker
The player-facing /endgames list now groups endgames under collapsible Key
headers and supports the same Theme/Key filtering as the admin list, showing
each endgame's Themes. The filter/group state is shared with the admin list
via ChesstrainerWeb.EndgameList.

Closes #14
2026-11-02 10:24:29 +01:00
owenrees d231860f14 Search, filter and group the admin endgames list
The admin list now groups endgames under collapsible Key headers and can be
filtered by Theme (search + tappable chips) and Key. Group counts and
filtering run in SQL, and a group's endgames are fetched only when it is
expanded, so the list stays fast as the dataset grows.

- Add Endgames.list_keys/0, list_key_groups/1 and list_endgames_for_key/2.
- Add the shared ChesstrainerWeb.EndgameList filter bar and grouped list
  component (to be reused by the player picker).
- Rework EndgameLive.Index around server-side group state.

Closes #15
2026-11-02 10:21:22 +01:00
owenrees ca65207baa Derive canonical material Key from the FEN
The Endgame key is now a canonical, colour-agnostic material signature derived
from the FEN instead of a hand-typed field: each side's pieces, strongest side
first by material value (e.g. "KQ v KR"). This fixes the seed ordering
inconsistency and guarantees the key always matches the position.

- Add Chesstrainer.Key.from_fen/1.
- Compute the key in the Endgame changeset; drop the manual input and its
  regex validation.
- Index endgames.key and derive keys in the seeds.
- Document the Key term and the decision (ADR 0003).

Closes #13
2026-11-02 09:22:01 +01:00
owenrees cd2e7f0164 Rename Tag to Theme across code and schema
Rename the endgame-label concept from Tag to Theme to match the glossary:
the context becomes Chesstrainer.Themes, the schema Chesstrainer.Themes.Theme,
and the Endgame association is :themes. The category enum
(endgame/opening/tactic) is preserved.

Rewrite the original migrations in place so themes / endgames_themes
(with theme_id) are created directly, instead of adding a transition
migration.

Closes #12
2026-11-02 09:14:17 +01:00
owenrees 645f65f2a3 Add multi-theme tagging to endgames in the admin
#11: endgames can carry multiple themes (endgame tags) chosen from a
searchable, autocompleting picker with inline creation. Tags are staged
in the form and saved atomically, so they work on both New and Edit.

Tag names are trimmed and case-insensitively unique per category. Admin
Show and Index display themes, and the seeds ship a starter vocabulary.

The theme picker has its own form: LiveView requires phx-change inputs to
live inside a form, and a separate theme form keeps Enter from
submitting the endgame form.
2026-11-01 22:22:09 +01:00
owenrees be23f1d7f8 Play draw endgames and solve on a rule draw
#10: drawn positions are graded against the draw as the target — a move
that keeps it passes, a losing move fails, and a rule draw reported by
chess.js (insufficient material, repetition, or 50-move) solves the
puzzle. The promotion cutoff now applies only to win puzzles.
2026-11-01 22:04:21 +01:00
34 changed files with 1591 additions and 477 deletions
+11
View File
@@ -19,6 +19,17 @@ _Avoid_: Endgame (the stored record), exercise
One playthrough of a puzzle by a user, ending solved or failed. One playthrough of a puzzle by a user, ending solved or failed.
_Avoid_: Run, session, game _Avoid_: Run, session, game
**Theme**:
A label describing an endgame's technique or goal, such as "mate in 2", "Lucena" or
"opposition"; an endgame can carry several.
_Avoid_: Tag, label, category
**Key**:
The canonical material signature of an endgame's starting position — which
pieces each side has, written strongest side first and colour-agnostic
(e.g. "KQ v KR"). Used to group and search endgames by material.
_Avoid_: Material signature, hash
## Play ## Play
**Winning side**: **Winning side**:
+4
View File
@@ -161,6 +161,8 @@ export const ChessBoard = {
fen: this.chess.fen(), fen: this.chess.fen(),
san: move.san, san: move.san,
promotion: promotion || null, promotion: promotion || null,
draw: this.chess.isDraw(),
checkmate: this.chess.isCheckmate(),
}; };
if (isTrainer) { if (isTrainer) {
@@ -204,6 +206,8 @@ export const ChessBoard = {
this.pushEvent("opponent_reply_applied", { this.pushEvent("opponent_reply_applied", {
fen: this.chess.fen(), fen: this.chess.fen(),
san: move.san, san: move.san,
draw: this.chess.isDraw(),
checkmate: this.chess.isCheckmate(),
}); });
}, },
+10
View File
@@ -0,0 +1,10 @@
# Canonical, colour-agnostic material Key for endgames
An endgame's `key` is derived from its FEN rather than typed by hand, as the
material signature of the start position: each side's pieces, strongest side
first by material value (`Q=9, R=5, B=3, N=3, P=1`) and colour-agnostic, so
`KQ v KR` is the same key whichever colour has the queen. Bishop square colour
is not encoded. We chose this over a white-vs-black ordering or a free-text key
so endgames with the same material group together regardless of colour, and so
the key can never drift from the position; side-to-move and outcome stay in the
`color` and `result` fields.
+60 -18
View File
@@ -21,6 +21,61 @@ defmodule Chesstrainer.Endgames do
Repo.all(Endgame) Repo.all(Endgame)
end end
@doc """
Returns the distinct Keys across all endgames, sorted.
"""
def list_keys do
Repo.all(from e in Endgame, distinct: true, select: e.key, order_by: [asc: e.key])
end
@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).
"""
def list_key_groups(filters \\ %{}) do
Endgame
|> apply_filters(filters)
|> group_by([e], e.key)
|> select([e], {e.key, count(e.id)})
|> order_by([e], asc: e.key)
|> Repo.all()
end
@doc """
Returns the endgames for one Key, matching the filters, with themes preloaded.
"""
def list_endgames_for_key(key, filters \\ %{}) do
Endgame
|> apply_filters(filters)
|> where([e], e.key == ^key)
|> preload(:themes)
|> order_by([e], asc: e.fen)
|> Repo.all()
end
defp apply_filters(query, filters) do
query
|> filter_themes(Map.get(filters, :themes, []))
|> filter_key(Map.get(filters, :key))
end
defp filter_themes(query, []), do: query
defp filter_themes(query, theme_ids) do
endgame_ids =
from(t in "endgames_themes",
where: t.theme_id in ^theme_ids,
select: t.endgame_id
)
where(query, [e], e.id in subquery(endgame_ids))
end
defp filter_key(query, key) when key in [nil, ""], do: query
defp filter_key(query, key), do: where(query, [e], e.key == ^key)
@doc """ @doc """
Gets a single endgame. Gets a single endgame.
@@ -49,9 +104,10 @@ defmodule Chesstrainer.Endgames do
{:error, %Ecto.Changeset{}} {:error, %Ecto.Changeset{}}
""" """
def create_endgame(attrs) do def create_endgame(attrs, themes \\ []) do
%Endgame{} %Endgame{}
|> Endgame.changeset(attrs) |> Endgame.changeset(attrs)
|> Ecto.Changeset.put_assoc(:themes, themes)
|> Repo.insert() |> Repo.insert()
end end
@@ -67,12 +123,14 @@ defmodule Chesstrainer.Endgames do
{:error, %Ecto.Changeset{}} {:error, %Ecto.Changeset{}}
""" """
def update_endgame(%Endgame{} = endgame, attrs) do def update_endgame(%Endgame{} = endgame, attrs, themes \\ []) do
# ignore fen on update # ignore fen on update
attrs = Map.delete(attrs, "fen") attrs = Map.delete(attrs, "fen")
endgame endgame
|> Repo.preload(:themes)
|> Endgame.changeset(attrs) |> Endgame.changeset(attrs)
|> Ecto.Changeset.put_assoc(:themes, themes)
|> Repo.update() |> Repo.update()
end end
@@ -120,20 +178,4 @@ defmodule Chesstrainer.Endgames do
{:ok, Repo.get!(Endgame, id)} {:ok, Repo.get!(Endgame, id)}
end end
def add_tag(endgame, tag) do
endgame
|> Repo.preload(:tags)
|> Ecto.Changeset.change()
|> Ecto.Changeset.put_assoc(:tags, [tag | endgame.tags])
|> Repo.update()
end
def remove_tag(endgame, tag) do
endgame
|> Repo.preload(:tags)
|> Ecto.Changeset.change()
|> Ecto.Changeset.put_assoc(:tags, endgame.tags -- [tag])
|> Repo.update()
end
end end
+14 -7
View File
@@ -6,6 +6,8 @@ defmodule Chesstrainer.Endgames.Endgame do
use Ecto.Schema use Ecto.Schema
import Ecto.Changeset import Ecto.Changeset
alias Chesstrainer.Key
@primary_key {:id, :binary_id, autogenerate: true} @primary_key {:id, :binary_id, autogenerate: true}
@foreign_key_type :binary_id @foreign_key_type :binary_id
schema "endgames" do schema "endgames" do
@@ -20,8 +22,8 @@ defmodule Chesstrainer.Endgames.Endgame do
field :times_attempted, :integer field :times_attempted, :integer
field :times_solved, :integer field :times_solved, :integer
many_to_many :tags, Chesstrainer.Tags.Tag, many_to_many :themes, Chesstrainer.Themes.Theme,
join_through: "endgames_tags", join_through: "endgames_themes",
on_replace: :delete on_replace: :delete
timestamps(type: :utc_datetime) timestamps(type: :utc_datetime)
@@ -30,12 +32,9 @@ defmodule Chesstrainer.Endgames.Endgame do
@doc false @doc false
def changeset(endgame, attrs) do def changeset(endgame, attrs) do
endgame endgame
|> cast(normalize_attrs(attrs), [:fen, :key, :message, :notes, :result, :rating, :color]) |> cast(normalize_attrs(attrs), [:fen, :message, :notes, :result, :rating, :color])
|> validate_required([:fen, :color], message: "Invalid FEN") |> validate_required([:fen, :color], message: "Invalid FEN")
|> validate_required([:key, :result, :rating]) |> validate_required([:result, :rating])
|> validate_format(:key, ~r/^(?=.{5,10}$)KQ*R*[NB]*P*\sv\sKQ*R*[NB]*P*$/,
message: "Key must follow pattern KQ.. v KQR.., max pieces 7"
)
|> validate_change(:fen, fn :fen, fen -> |> validate_change(:fen, fn :fen, fen ->
case fen_issues(fen) do case fen_issues(fen) do
[] -> [] [] -> []
@@ -43,6 +42,14 @@ defmodule Chesstrainer.Endgames.Endgame do
end end
end) end)
|> unique_constraint(:fen, message: "FEN already exists") |> unique_constraint(:fen, message: "FEN already exists")
|> put_key()
end
defp put_key(changeset) do
case Key.from_fen(get_field(changeset, :fen)) do
{:ok, key} -> put_change(changeset, :key, key)
{:error, :invalid_fen} -> changeset
end
end end
defp normalize_attrs(%{"fen" => fen} = attrs) when is_binary(fen), defp normalize_attrs(%{"fen" => fen} = attrs) when is_binary(fen),
+124
View File
@@ -0,0 +1,124 @@
defmodule Chesstrainer.Key do
@moduledoc """
Derives an endgame's canonical material Key from its FEN.
The Key is a color-agnostic material signature: each side's pieces, stronger
side first, for example `"KQ v KR"`. It ignores piece placement and bishop
square colour. Within a side the pieces are written `K`, then `Q`, `R`, `B`,
`N`, `P`; the two sides are ordered by material value
(`Q=9, R=5, B=3, N=3, P=1`, kings ignored).
"""
@piece_order [{"q", "Q"}, {"r", "R"}, {"b", "B"}, {"n", "N"}, {"p", "P"}]
@values %{"q" => 9, "r" => 5, "b" => 3, "n" => 3, "p" => 1}
@pieces ~w(p n b r q k P N B R Q K)
@digits ~w(1 2 3 4 5 6 7 8)
@doc """
Returns the canonical material Key for a FEN.
## Examples
iex> Chesstrainer.Key.from_fen("8/8/3k4/8/8/3K1R2/8/8 w - - 0 1")
{:ok, "KR v K"}
iex> Chesstrainer.Key.from_fen("6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1")
{:ok, "KPPP v KPP"}
iex> Chesstrainer.Key.from_fen("not a fen")
{:error, :invalid_fen}
"""
@spec from_fen(String.t() | nil) :: {:ok, String.t()} | {:error, :invalid_fen}
def from_fen(fen) when is_binary(fen) do
with [board | _] <- String.split(fen),
{:ok, white, black} <- parse_board(board) do
{:ok, join_sides(white, black)}
else
_ -> {:error, :invalid_fen}
end
end
def from_fen(_fen), do: {:error, :invalid_fen}
defp parse_board(board) do
ranks = String.split(board, "/")
result =
if length(ranks) == 8 do
Enum.reduce_while(
ranks,
{:ok, %{"w" => new_counts(), "b" => new_counts()}},
fn rank, {:ok, acc} ->
case add_rank(rank, acc) do
{:ok, acc} -> {:cont, {:ok, acc}}
:error -> {:halt, :error}
end
end
)
else
:error
end
case result do
{:ok, %{"w" => white, "b" => black}} -> {:ok, white, black}
:error -> :error
end
end
defp new_counts, do: Map.new(~w(k q r b n p), &{&1, 0})
defp add_rank(rank, acc) do
rank
|> String.graphemes()
|> Enum.reduce_while({0, acc}, fn char, {squares, acc} ->
cond do
char in @digits ->
{:cont, {squares + String.to_integer(char), acc}}
char in @pieces ->
side = if char == String.downcase(char), do: "b", else: "w"
piece = String.downcase(char)
counts =
acc
|> Map.fetch!(side)
|> Map.update!(piece, &(&1 + 1))
{:cont, {squares + 1, Map.put(acc, side, counts)}}
true ->
{:halt, :error}
end
end)
|> case do
{8, acc} -> {:ok, acc}
_ -> :error
end
end
defp join_sides(white, black) do
{first, second} = order_sides(white, black)
"#{side_string(first)} v #{side_string(second)}"
end
defp side_string(counts) do
"K" <>
Enum.map_join(@piece_order, fn {lower, upper} ->
String.duplicate(upper, counts[lower])
end)
end
defp order_sides(white, black) do
if rank(white) >= rank(black), do: {white, black}, else: {black, white}
end
defp rank(counts) do
{value(counts), counts["q"], counts["r"], counts["b"], counts["n"], counts["p"]}
end
defp value(counts) do
Enum.reduce(@values, 0, fn {piece, weight}, total ->
total + counts[piece] * weight
end)
end
end
-123
View File
@@ -1,123 +0,0 @@
defmodule Chesstrainer.Tags do
@moduledoc """
The Tags context.
"""
import Ecto.Query, warn: false
alias Chesstrainer.Repo
alias Chesstrainer.Tags.Tag
@doc """
Returns the list of tags.
## Examples
iex> list_tags()
[%Tag{}, ...]
"""
def list_tags do
Repo.all(Tag)
end
@doc """
Gets a single tag.
Raises `Ecto.NoResultsError` if the Tag does not exist.
## Examples
iex> get_tag!(123)
%Tag{}
iex> get_tag!(456)
** (Ecto.NoResultsError)
"""
def get_tag!(id), do: Repo.get!(Tag, id)
@doc """
Creates a tag.
## Examples
iex> create_tag(%{field: value})
{:ok, %Tag{}}
iex> create_tag(%{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def create_tag(attrs) do
%Tag{}
|> Tag.changeset(attrs)
|> Repo.insert()
end
@doc """
Updates a tag.
## Examples
iex> update_tag(tag, %{field: new_value})
{:ok, %Tag{}}
iex> update_tag(tag, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def update_tag(%Tag{} = tag, attrs) do
tag
|> Tag.changeset(attrs)
|> Repo.update()
end
@doc """
Deletes a tag.
## Examples
iex> delete_tag(tag)
{:ok, %Tag{}}
iex> delete_tag(tag)
{:error, %Ecto.Changeset{}}
"""
def delete_tag(%Tag{} = tag) do
Repo.delete(tag)
end
@doc """
Returns an `%Ecto.Changeset{}` for tracking tag changes.
## Examples
iex> change_tag(tag)
%Ecto.Changeset{data: %Tag{}}
"""
def change_tag(%Tag{} = tag, attrs \\ %{}) do
Tag.changeset(tag, attrs)
end
def search("", _category), do: []
def search(query, category) when is_binary(query) do
pattern = "%#{query}%"
Tag
|> where([t], ilike(t.name, ^pattern) and t.category == ^category)
|> order_by([t], asc: t.name)
|> limit(20)
|> Repo.all()
end
def get_or_create(name, category) when is_binary(name) do
case Repo.get_by(Tag, name: name, category: category) do
nil -> create_tag(%{name: name, category: category})
tag -> {:ok, tag}
end
end
end
-19
View File
@@ -1,19 +0,0 @@
defmodule Chesstrainer.Tags.Tag do
use Ecto.Schema
import Ecto.Changeset
schema "tags" do
field :name, :string
field :category, Ecto.Enum, values: [endgame: "endgame", opening: "opening", tactic: "tactic"]
timestamps(type: :utc_datetime)
end
@doc false
def changeset(tag, attrs) do
tag
|> cast(attrs, [:name, :category])
|> validate_required([:name, :category])
|> unique_constraint(:name)
end
end
+156
View File
@@ -0,0 +1,156 @@
defmodule Chesstrainer.Themes do
@moduledoc """
The Themes context.
"""
import Ecto.Query, warn: false
alias Chesstrainer.Repo
alias Chesstrainer.Themes.Theme
@doc """
Returns the list of themes.
## Examples
iex> list_themes()
[%Theme{}, ...]
"""
def list_themes do
Repo.all(Theme)
end
@doc """
Gets a single theme.
Raises `Ecto.NoResultsError` if the Theme does not exist.
## Examples
iex> get_theme!(123)
%Theme{}
iex> get_theme!(456)
** (Ecto.NoResultsError)
"""
def get_theme!(id), do: Repo.get!(Theme, id)
@doc """
Creates a theme.
## Examples
iex> create_theme(%{field: value})
{:ok, %Theme{}}
iex> create_theme(%{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def create_theme(attrs) do
%Theme{}
|> Theme.changeset(attrs)
|> Repo.insert()
end
@doc """
Updates a theme.
## Examples
iex> update_theme(theme, %{field: new_value})
{:ok, %Theme{}}
iex> update_theme(theme, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def update_theme(%Theme{} = theme, attrs) do
theme
|> Theme.changeset(attrs)
|> Repo.update()
end
@doc """
Deletes a theme.
## Examples
iex> delete_theme(theme)
{:ok, %Theme{}}
iex> delete_theme(theme)
{:error, %Ecto.Changeset{}}
"""
def delete_theme(%Theme{} = theme) do
Repo.delete(theme)
end
@doc """
Returns an `%Ecto.Changeset{}` for tracking theme changes.
## Examples
iex> change_theme(theme)
%Ecto.Changeset{data: %Theme{}}
"""
def change_theme(%Theme{} = theme, attrs \\ %{}) do
Theme.changeset(theme, attrs)
end
def search("", _category), do: []
def search(query, category) when is_binary(query) do
case String.trim(query) do
"" ->
[]
query ->
pattern = "%#{query}%"
Theme
|> where([t], ilike(t.name, ^pattern) and t.category == ^category)
|> order_by([t], asc: t.name)
|> limit(20)
|> Repo.all()
end
end
@doc """
Finds a theme by name (trimmed and case-insensitive) for a category, creating it
if it does not exist.
"""
def get_or_create(name, category) 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}
end
end
end
defp find_by_name(name, category) do
downcased = String.downcase(name)
Repo.one(
from t in Theme,
where: t.category == ^category and fragment("lower(?)", t.name) == ^downcased,
limit: 1
)
end
@doc """
Returns the names of the given themes, sorted.
"""
def names(themes) when is_list(themes) do
themes |> Enum.map(& &1.name) |> Enum.sort()
end
end
+27
View File
@@ -0,0 +1,27 @@
defmodule Chesstrainer.Themes.Theme do
use Ecto.Schema
import Ecto.Changeset
schema "themes" do
field :name, :string
field :category, Ecto.Enum, values: [endgame: "endgame", opening: "opening", tactic: "tactic"]
timestamps(type: :utc_datetime)
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])
|> validate_length(:name, min: 1, max: 60)
|> unique_constraint(:name,
name: :themes_name_category_lower_index,
message: "already exists"
)
end
end
@@ -0,0 +1,227 @@
defmodule ChesstrainerWeb.EndgameList do
@moduledoc """
Shared, server-rendered filter bar and Key-grouped endgame list.
The parent LiveView owns the filter/group state (see `ChesstrainerWeb.EndgameLive.Index`)
and handles the `search_themes`, `add_theme`, `remove_theme`, `filter_key`,
`clear_filters` and `toggle_group` events. Groups are rendered collapsed; the
parent fetches a group's endgames only when it is expanded.
"""
use ChesstrainerWeb, :html
alias Chesstrainer.Endgames
alias Chesstrainer.Themes
@doc """
Initialises the filter/group assigns for a filtered, Key-grouped endgame list.
"""
def init_state(socket) do
socket
|> assign(:selected_themes, [])
|> assign(:theme_query, "")
|> assign(:theme_results, [])
|> assign(:selected_key, nil)
|> assign(:keys, Endgames.list_keys())
|> assign(:groups, build_groups(%{}))
end
@doc """
Handles the filter/group events shared by the admin and player lists.
"""
def handle_filter_event("search_themes", %{"theme_search" => query}, socket) do
results = if String.trim(query) == "", do: [], else: Themes.search(query, "endgame")
{:noreply, assign(socket, theme_query: query, theme_results: results)}
end
def handle_filter_event("add_theme", %{"id" => id}, socket) do
theme = Themes.get_theme!(id)
selected =
if Enum.any?(socket.assigns.selected_themes, &(&1.id == theme.id)) do
socket.assigns.selected_themes
else
socket.assigns.selected_themes ++ [theme]
end
{:noreply,
socket
|> assign(:selected_themes, selected)
|> clear_theme_search()
|> refresh()}
end
def handle_filter_event("remove_theme", %{"id" => id}, socket) do
selected = Enum.reject(socket.assigns.selected_themes, &(Integer.to_string(&1.id) == id))
{:noreply, socket |> assign(:selected_themes, selected) |> refresh()}
end
def handle_filter_event("filter_key", %{"key" => key}, socket) do
{:noreply,
socket
|> assign(:selected_key, if(key == "", do: nil, else: key))
|> refresh()}
end
def handle_filter_event("clear_filters", _params, socket) do
{:noreply,
socket
|> assign(:selected_themes, [])
|> assign(:selected_key, nil)
|> clear_theme_search()
|> refresh()}
end
def handle_filter_event("toggle_group", %{"key" => key}, socket) do
groups =
Enum.map(socket.assigns.groups, fn group ->
cond do
group.key != key ->
group
group.expanded ->
%{group | expanded: false, endgames: nil}
true ->
endgames = Endgames.list_endgames_for_key(key, current_filters(socket.assigns))
%{group | expanded: true, endgames: endgames}
end
end)
{:noreply, assign(socket, :groups, groups)}
end
def handle_filter_event(_event, _params, socket), do: {:noreply, socket}
@doc """
Rebuilds the Key list and groups from the current filters.
"""
def refresh(socket) do
filters = current_filters(socket.assigns)
socket
|> assign(:keys, Endgames.list_keys())
|> assign(:groups, build_groups(filters))
end
defp build_groups(filters) do
Enum.map(
Endgames.list_key_groups(filters),
fn {key, count} -> %{key: key, count: count, expanded: false, endgames: nil} end
)
end
defp current_filters(assigns) do
%{themes: Enum.map(assigns.selected_themes, & &1.id), key: assigns.selected_key}
end
defp clear_theme_search(socket), do: assign(socket, theme_query: "", theme_results: [])
attr :selected_themes, :list, required: true
attr :theme_query, :string, required: true
attr :theme_results, :list, required: true
attr :keys, :list, required: true
attr :selected_key, :string, default: nil
def filter_bar(assigns) do
~H"""
<div class="mb-6 space-y-3">
<div :if={@selected_themes != []} class="flex flex-wrap gap-2">
<span :for={theme <- @selected_themes} class="badge badge-primary gap-1">
{theme.name}
<button
type="button"
phx-click="remove_theme"
phx-value-id={theme.id}
aria-label={"Remove #{theme.name}"}
>
×
</button>
</span>
</div>
<div class="flex flex-col gap-3 sm:flex-row">
<form id="theme-filter-form" phx-change="search_themes" class="flex-1">
<input
type="text"
name="theme_search"
value={@theme_query}
phx-debounce="200"
autocomplete="off"
placeholder="Filter by theme…"
class="input input-bordered w-full"
/>
<ul :if={@theme_results != []} class="menu bg-base-100 rounded-box mt-2">
<li :for={theme <- @theme_results}>
<button type="button" phx-click="add_theme" phx-value-id={theme.id}>
{theme.name}
</button>
</li>
</ul>
</form>
<form id="key-filter-form" phx-change="filter_key" class="flex-1">
<select name="key" class="select w-full">
<option value="" selected={is_nil(@selected_key)}>All keys</option>
<option :for={key <- @keys} value={key} selected={key == @selected_key}>
{key}
</option>
</select>
</form>
</div>
<button
:if={@selected_themes != [] or @selected_key}
type="button"
phx-click="clear_filters"
class="text-sm underline"
>
Clear filters
</button>
</div>
"""
end
attr :groups, :list, required: true
slot :header, required: true
slot :row, required: true
def grouped_list(assigns) do
~H"""
<div class="space-y-3">
<section :for={group <- @groups} id={"key-group-" <> String.replace(group.key, " ", "-")}>
<button
type="button"
phx-click="toggle_group"
phx-value-key={group.key}
aria-expanded={to_string(group.expanded)}
class="flex w-full items-center justify-between gap-3 rounded bg-base-200 px-3 py-2 text-left"
>
<span class="font-semibold">{group.key}</span>
<span class="flex items-center gap-2 text-sm">
<span class="badge">{group.count}</span>
<.icon
name={if group.expanded, do: "hero-chevron-down", else: "hero-chevron-right"}
class="size-4"
/>
</span>
</button>
<table :if={group.expanded} class="table table-zebra">
<thead>
{render_slot(@header)}
</thead>
<tbody>
<%= for endgame <- group.endgames do %>
{render_slot(@row, endgame)}
<% end %>
</tbody>
</table>
</section>
</div>
"""
end
end
+5 -1
View File
@@ -31,12 +31,16 @@ defmodule ChesstrainerWeb.Layouts do
default: nil, default: nil,
doc: "the current [scope](https://phoenix.hexdocs.pm/scopes.html)" doc: "the current [scope](https://phoenix.hexdocs.pm/scopes.html)"
attr :wide, :boolean,
default: false,
doc: "use a wide container instead of the default narrow column"
slot :inner_block, required: true slot :inner_block, required: true
def app(assigns) do def app(assigns) do
~H""" ~H"""
<main class="px-4 py-20 sm:px-6 lg:px-8"> <main class="px-4 py-20 sm:px-6 lg:px-8">
<div class="mx-auto max-w-2xl space-y-4"> <div class={["mx-auto space-y-4", if(@wide, do: "max-w-7xl", else: "max-w-2xl")]}>
{render_slot(@inner_block)} {render_slot(@inner_block)}
</div> </div>
</main> </main>
+118 -81
View File
@@ -2,7 +2,7 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
use ChesstrainerWeb, :live_view use ChesstrainerWeb, :live_view
alias Chesstrainer.Repo alias Chesstrainer.Repo
alias Chesstrainer.Tags alias Chesstrainer.Themes
alias Chesstrainer.FEN alias Chesstrainer.FEN
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Endgames.Endgame alias Chesstrainer.Endgames.Endgame
@@ -16,51 +16,64 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
<:subtitle>Use this form to manage endgame records in your database.</:subtitle> <:subtitle>Use this form to manage endgame records in your database.</:subtitle>
</.header> </.header>
<.form for={@form} id="endgame-form" phx-change="validate" phx-submit="save"> <div class="field mb-6">
<.input field={@form[:fen]} type="text" label="Fen" disabled={@live_action == :edit} /> <label class="label">
<.input field={@form[:color]} type="text" label="Color" disabled /> <span class="label-text">Themes</span>
<.input field={@form[:key]} type="text" label="Key" /> </label>
<.input field={@form[:rating]} type="number" label="Rating" />
<!-- ✅ TAG SELECTOR --> <div class="flex flex-wrap gap-2 mb-2">
<div class="field"> <%= for theme <- @selected_themes do %>
<label>Tags</label> <span class="badge badge-primary gap-1">
{theme.name}
<button
type="button"
phx-click="remove_theme"
phx-value-id={theme.id}
aria-label={"Remove #{theme.name}"}
>
×
</button>
</span>
<% end %>
</div>
<!-- Search box --> <form
id="theme-form"
phx-change="search_themes"
phx-submit="create_theme_from_search"
>
<input <input
type="text" type="text"
name="tag_search" name="theme_search"
value={@tag_query} value={@theme_query}
phx-change="search_tags" phx-debounce="200"
autocomplete="off" autocomplete="off"
placeholder="Search or create a theme…"
class="input input-bordered w-full"
/> />
<!-- Search results --> <ul class="menu bg-base-100 rounded-box mt-2">
<ul class="tag-results"> <%= for theme <- @theme_results do %>
<%= for tag <- @tag_results do %> <li>
<li phx-click="add_tag" phx-value-id={tag.id}> <button type="button" phx-click="add_theme" phx-value-id={theme.id}>{theme.name}</button>
{tag.name}
</li> </li>
<% end %> <% end %>
<%= if @tag_query != "" and @tag_results == [] do %> <%= if @can_create do %>
<li phx-click="create_tag" phx-value-name={@tag_query}> <li>
Create tag "{@tag_query}" <button type="button" phx-click="create_theme" phx-value-name={@theme_query}>
Create theme "{String.trim(@theme_query)}"
</button>
</li> </li>
<% end %> <% end %>
</ul> </ul>
</form>
</div>
<!-- Selected tags --> <.form for={@form} id="endgame-form" phx-change="validate" phx-submit="save">
<div class="selected-tags"> <.input field={@form[:fen]} type="text" label="Fen" disabled={@live_action == :edit} />
<%= for tag <- @endgame.tags do %> <.input field={@form[:color]} type="text" label="Color" disabled />
<span class="tag"> <.input field={@form[:rating]} type="number" label="Rating" />
{tag.name}
<button type="button" phx-click="remove_tag" phx-value-id={tag.id}>×</button>
</span>
<% end %>
</div>
</div>
<.input field={@form[:message]} type="textarea" label="Message" /> <.input field={@form[:message]} type="textarea" label="Message" />
<.input field={@form[:notes]} type="textarea" label="Notes" /> <.input field={@form[:notes]} type="textarea" label="Notes" />
<.input <.input
@@ -94,14 +107,15 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
defp return_to(_), do: "index" defp return_to(_), do: "index"
defp apply_action(socket, :edit, %{"id" => id}) do defp apply_action(socket, :edit, %{"id" => id}) do
endgame = Endgames.get_endgame!(id) endgame = Endgames.get_endgame!(id) |> Repo.preload(:themes)
socket socket
|> assign(:page_title, "Edit Endgame") |> assign(:page_title, "Edit Endgame")
|> assign(:endgame, endgame) |> assign(:endgame, endgame)
|> assign(:tag_query, "") |> assign(:selected_themes, endgame.themes)
|> assign(:tag_results, []) |> assign(:theme_query, "")
|> assign(:endgame, Repo.preload(endgame, :tags)) |> assign(:theme_results, [])
|> assign(:can_create, false)
|> assign(:form, to_form(Endgames.change_endgame(endgame))) |> assign(:form, to_form(Endgames.change_endgame(endgame)))
end end
@@ -111,67 +125,46 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
socket socket
|> assign(:page_title, "New Endgame") |> assign(:page_title, "New Endgame")
|> assign(:endgame, endgame) |> assign(:endgame, endgame)
|> assign(:tag_query, "") |> assign(:selected_themes, [])
|> assign(:tag_results, []) |> assign(:theme_query, "")
|> assign(:endgame, Repo.preload(endgame, :tags)) |> assign(:theme_results, [])
|> assign(:can_create, false)
|> assign(:form, to_form(Endgames.change_endgame(endgame))) |> assign(:form, to_form(Endgames.change_endgame(endgame)))
end end
@impl true @impl true
def handle_event("search_tags", %{"tag_search" => query}, socket) do def handle_event("search_themes", %{"theme_search" => query}, socket) do
tags = Tags.search(query, "endgame") {:noreply, assign_search(socket, query)}
{:noreply,
socket
|> assign(:tag_query, query)
|> assign(:tag_results, tags)}
end end
def handle_event("add_tag", %{"id" => id}, socket) do def handle_event("add_theme", %{"id" => id}, socket) do
tag = Tags.get_tag!(id) theme = Themes.get_theme!(id)
{:ok, endgame} = Endgames.add_tag(socket.assigns.endgame, tag) {:noreply, socket |> add_selected_theme(theme) |> clear_search()}
{:noreply,
socket
|> assign(:endgame, Repo.preload(endgame, :tags))
|> assign(:tag_query, "")
|> assign(:tag_results, [])}
end end
def handle_event("create_tag", %{"name" => name}, socket) do def handle_event("create_theme", %{"name" => name}, socket) do
{:ok, tag} = Tags.get_or_create(name, "endgame") {:noreply, create_theme(socket, name)}
{:ok, endgame} = Endgames.add_tag(socket.assigns.endgame, tag)
{:noreply,
socket
|> assign(:endgame, Repo.preload(endgame, :tags))
|> assign(:tag_query, "")
|> assign(:tag_results, [])}
end end
def handle_event("remove_tag", %{"id" => id}, socket) do def handle_event("create_theme_from_search", %{"theme_search" => name}, socket) do
tag = Tags.get_tag!(id) {:noreply, create_theme(socket, name)}
{:ok, endgame} = Endgames.remove_tag(socket.assigns.endgame, tag) end
{:noreply, def handle_event("remove_theme", %{"id" => id}, socket) do
socket selected = Enum.reject(socket.assigns.selected_themes, &(Integer.to_string(&1.id) == id))
|> assign(:endgame, Repo.preload(endgame, :tags))} {:noreply, assign(socket, :selected_themes, selected)}
end end
def handle_event("validate", %{"endgame" => endgame_params}, socket) do def handle_event("validate", %{"endgame" => endgame_params}, socket) do
# Compute color from the incoming FEN fen = endgame_params["fen"] || socket.assigns.endgame.fen
color = FEN.color_from_fen(endgame_params["fen"]) color = FEN.color_from_fen(fen)
# Update the struct
endgame = %{socket.assigns.endgame | color: color}
# Build the changeset *from the updated struct*
changeset = changeset =
endgame socket.assigns.endgame
|> Endgames.change_endgame() |> Endgames.change_endgame(endgame_params)
|> Ecto.Changeset.put_change(:color, color) |> Ecto.Changeset.put_change(:color, color)
{:noreply, assign(socket, endgame: endgame, form: to_form(changeset, action: :validate))} {:noreply, assign(socket, form: to_form(changeset, action: :validate))}
end end
def handle_event("save", %{"endgame" => endgame_params}, socket) do def handle_event("save", %{"endgame" => endgame_params}, socket) do
@@ -179,7 +172,11 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
end end
defp save_endgame(socket, :edit, endgame_params) do defp save_endgame(socket, :edit, endgame_params) do
case Endgames.update_endgame(socket.assigns.endgame, endgame_params) do case Endgames.update_endgame(
socket.assigns.endgame,
endgame_params,
socket.assigns.selected_themes
) do
{:ok, endgame} -> {:ok, endgame} ->
{:noreply, {:noreply,
socket socket
@@ -195,7 +192,7 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
color = FEN.color_from_fen(endgame_params["fen"]) color = FEN.color_from_fen(endgame_params["fen"])
params = Map.put(endgame_params, "color", color) params = Map.put(endgame_params, "color", color)
case Endgames.create_endgame(params) do case Endgames.create_endgame(params, socket.assigns.selected_themes) do
{:ok, endgame} -> {:ok, endgame} ->
{:noreply, {:noreply,
socket socket
@@ -207,6 +204,46 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
end end
end end
defp assign_search(socket, query) do
trimmed = String.trim(query)
results = Themes.search(query, "endgame")
can_create =
trimmed != "" and
not Enum.any?(results, &(String.downcase(&1.name) == String.downcase(trimmed)))
socket
|> assign(:theme_query, query)
|> assign(:theme_results, results)
|> assign(:can_create, can_create)
end
defp create_theme(socket, name) do
if String.trim(name) == "" do
socket
else
case Themes.get_or_create(name, "endgame") do
{:ok, theme} -> socket |> add_selected_theme(theme) |> clear_search()
{:error, _reason} -> put_flash(socket, :error, "Could not create that theme.")
end
end
end
defp clear_search(socket) do
socket
|> assign(:theme_query, "")
|> assign(:theme_results, [])
|> assign(:can_create, false)
end
defp add_selected_theme(socket, theme) do
if Enum.any?(socket.assigns.selected_themes, &(&1.id == theme.id)) do
socket
else
assign(socket, :selected_themes, socket.assigns.selected_themes ++ [theme])
end
end
defp return_path("index", _endgame), do: ~p"/admin/endgames" defp return_path("index", _endgame), do: ~p"/admin/endgames"
defp return_path("show", endgame), do: ~p"/admin/endgames/#{endgame}" defp return_path("show", endgame), do: ~p"/admin/endgames/#{endgame}"
end end
+69 -35
View File
@@ -3,10 +3,12 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
import ChesstrainerWeb.EndgameList
@impl true @impl true
def render(assigns) do def render(assigns) do
~H""" ~H"""
<Layouts.app flash={@flash}> <Layouts.app flash={@flash} wide>
<.header> <.header>
Listing Endgames Listing Endgames
<:actions> <:actions>
@@ -16,36 +18,68 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
</:actions> </:actions>
</.header> </.header>
<.table <.filter_bar
id="endgames" selected_themes={@selected_themes}
rows={@streams.endgames} theme_query={@theme_query}
row_click={fn {_id, endgame} -> JS.navigate(~p"/admin/endgames/#{endgame}") end} theme_results={@theme_results}
> keys={@keys}
<:col :let={{_id, endgame}} label="Fen">{endgame.fen}</:col> selected_key={@selected_key}
<:col :let={{_id, endgame}} label="Color">{endgame.color}</:col> />
<:col :let={{_id, endgame}} label="Key">{endgame.key}</:col>
<:col :let={{_id, endgame}} label="Rating">{endgame.rating}</:col> <.grouped_list :if={@groups != []} groups={@groups}>
<:col :let={{_id, endgame}} label="Message">{endgame.message}</:col> <:header>
<:col :let={{_id, endgame}} label="Notes">{endgame.notes}</:col> <tr>
<:col :let={{_id, endgame}} label="Result">{endgame.result}</:col> <th>Key</th>
<:col :let={{_id, endgame}} label="Attempted">{endgame.times_attempted}</:col> <th>Color</th>
<:col :let={{_id, endgame}} label="Solved">{endgame.times_solved}</:col> <th>Result</th>
<:action :let={{_id, endgame}}> <th>Themes</th>
<div class="sr-only"> <th>Rating</th>
<.link navigate={~p"/admin/endgames/#{endgame}"}>Show</.link> <th><span class="sr-only">Actions</span></th>
</div> </tr>
<.link navigate={~p"/endgames/#{endgame}/play"}>Play</.link> </:header>
<.link navigate={~p"/admin/endgames/#{endgame}/edit"}>Edit</.link>
</:action> <:row :let={endgame}>
<:action :let={{id, endgame}}> <tr id={"endgame-" <> endgame.id}>
<.link <td phx-click={JS.navigate(~p"/admin/endgames/#{endgame}")} class="hover:cursor-pointer">
phx-click={JS.push("delete", value: %{id: endgame.id}) |> hide("##{id}")} {endgame.key}
data-confirm="Are you sure?" </td>
> <td phx-click={JS.navigate(~p"/admin/endgames/#{endgame}")} class="hover:cursor-pointer">
Delete {endgame.color}
</.link> </td>
</:action> <td phx-click={JS.navigate(~p"/admin/endgames/#{endgame}")} class="hover:cursor-pointer">
</.table> {endgame.result}
</td>
<td>
<span :for={theme <- endgame.themes} class="badge badge-sm">
<button type="button" phx-click="add_theme" phx-value-id={theme.id}>
{theme.name}
</button>
</span>
<span :if={endgame.themes == []} class="text-base-content/50">None</span>
</td>
<td phx-click={JS.navigate(~p"/admin/endgames/#{endgame}")} class="hover:cursor-pointer">
{endgame.rating}
</td>
<td class="w-0 font-semibold">
<div class="flex gap-4">
<.link navigate={~p"/admin/endgames/#{endgame}"}>Show</.link>
<.link navigate={~p"/endgames/#{endgame}/play"}>Play</.link>
<.link navigate={~p"/admin/endgames/#{endgame}/edit"}>Edit</.link>
<.link
phx-click={JS.push("delete", value: %{id: endgame.id})}
data-confirm="Are you sure?"
>
Delete
</.link>
</div>
</td>
</tr>
</:row>
</.grouped_list>
<p :if={@groups == []} class="text-base-content/70">
No endgames match these filters.
</p>
</Layouts.app> </Layouts.app>
""" """
end end
@@ -55,7 +89,7 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
{:ok, {:ok,
socket socket
|> assign(:page_title, "Listing Endgames") |> assign(:page_title, "Listing Endgames")
|> stream(:endgames, list_endgames())} |> init_state()}
end end
@impl true @impl true
@@ -63,10 +97,10 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
endgame = Endgames.get_endgame!(id) endgame = Endgames.get_endgame!(id)
{:ok, _} = Endgames.delete_endgame(endgame) {:ok, _} = Endgames.delete_endgame(endgame)
{:noreply, stream_delete(socket, :endgames, endgame)} {:noreply, refresh(socket)}
end end
defp list_endgames() do def handle_event(event, params, socket) do
Endgames.list_endgames() handle_filter_event(event, params, socket)
end end
end end
+50 -29
View File
@@ -40,10 +40,16 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
<p class="font-semibold text-red-600">Tablebase unavailable</p> <p class="font-semibold text-red-600">Tablebase unavailable</p>
<p class="text-red-500">{@blocked_reason}</p> <p class="text-red-500">{@blocked_reason}</p>
<% @status == :solved -> %> <% @status == :solved -> %>
<p class="font-semibold text-emerald-600">Solved!</p> <p class="font-semibold text-emerald-600">
{if @endgame.result == :draw, do: "Draw held!", else: "Solved!"}
</p>
<% @status == :failed -> %> <% @status == :failed -> %>
<p class="font-semibold text-red-600">Failed</p> <p class="font-semibold text-red-600">Failed</p>
<p class="text-red-500">That move throws away the win.</p> <p class="text-red-500">
{if @endgame.result == :draw,
do: "That move loses the draw.",
else: "That move throws away the win."}
</p>
<%= if @best_move do %> <%= if @best_move do %>
<p class="text-gray-600">Best was: {@best_move}</p> <p class="text-gray-600">Best was: {@best_move}</p>
<% end %> <% end %>
@@ -119,6 +125,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
def handle_event("endgame_move_played", params, socket) do def handle_event("endgame_move_played", params, socket) do
%{"from" => from, "to" => to, "san" => san} = params %{"from" => from, "to" => to, "san" => san} = params
promotion = params["promotion"] promotion = params["promotion"]
draw = params["draw"] || false
prev_fen = params["prev_fen"] || socket.assigns.fen prev_fen = params["prev_fen"] || socket.assigns.fen
fen_after = params["fen"] || socket.assigns.fen fen_after = params["fen"] || socket.assigns.fen
@@ -135,32 +142,40 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
put_flash(socket, :error, "That move is out of sequence. Press Reset to try again.")} put_flash(socket, :error, "That move is out of sequence. Press Reset to try again.")}
true -> true ->
grade_and_record(socket, from, to, promotion, san, fen_after) grade_and_record(socket, from, to, promotion, san, fen_after, draw)
end end
end end
def handle_event("opponent_reply_applied", %{"fen" => fen}, socket) do def handle_event("opponent_reply_applied", params, socket) do
if socket.assigns.awaiting_reply do %{"fen" => fen} = params
case Tablebase.new(fen) do draw = params["draw"] || false
{:ok, tablebase} ->
{:noreply,
socket
|> assign(:fen, fen)
|> assign(:tablebase, tablebase)
|> assign(:awaiting_reply, false)
|> assign(:status, :playing)
|> assign(:blocked_reason, nil)
|> push_event("resume_board", %{})}
other -> cond do
{:noreply, not socket.assigns.awaiting_reply ->
socket {:noreply, socket}
|> assign(:awaiting_reply, false)
|> assign(:status, :blocked) draw and socket.assigns.endgame.result == :draw ->
|> assign(:blocked_reason, blocked_reason(other))} solve_attempt(socket)
end
else true ->
{:noreply, socket} case Tablebase.new(fen) do
{:ok, tablebase} ->
{:noreply,
socket
|> assign(:fen, fen)
|> assign(:tablebase, tablebase)
|> assign(:awaiting_reply, false)
|> assign(:status, :playing)
|> assign(:blocked_reason, nil)
|> push_event("resume_board", %{})}
other ->
{:noreply,
socket
|> assign(:awaiting_reply, false)
|> assign(:status, :blocked)
|> assign(:blocked_reason, blocked_reason(other))}
end
end end
end end
@@ -251,7 +266,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
"The tablebase is unavailable (#{inspect(reason)})." "The tablebase is unavailable (#{inspect(reason)})."
end end
defp grade_and_record(socket, from, to, promotion, san, fen_after) do defp grade_and_record(socket, from, to, promotion, san, fen_after, draw) do
case find_move(socket.assigns.tablebase, from, to, promotion) do case find_move(socket.assigns.tablebase, from, to, promotion) do
nil -> nil ->
{:noreply, put_flash(socket, :error, "Could not identify that move in the tablebase.")} {:noreply, put_flash(socket, :error, "Could not identify that move in the tablebase.")}
@@ -270,12 +285,18 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
grade == :losing -> grade == :losing ->
fail_attempt(socket) fail_attempt(socket)
grade in [:optimal, :winning] and not is_nil(promotion) -> grade not in [:optimal, :winning] ->
# Conversion cutoff: a promotion that keeps the win ends the puzzle. {:noreply, socket}
draw and socket.assigns.endgame.result == :draw ->
# A drawn-by-rule position is the goal of a draw puzzle.
solve_attempt(socket) solve_attempt(socket)
grade in [:optimal, :winning] and socket.assigns.endgame.result == :win and not is_nil(promotion) ->
not same_position?(fen_after, socket.assigns.fen) -> # Conversion cutoff: a promotion that keeps the win ends a win puzzle.
solve_attempt(socket)
not same_position?(fen_after, socket.assigns.fen) ->
start_opponent_reply(socket, fen_after) start_opponent_reply(socket, fen_after)
true -> true ->
@@ -1,29 +1,65 @@
defmodule ChesstrainerWeb.EndgameLive.PlayerIndex do defmodule ChesstrainerWeb.EndgameLive.PlayerIndex do
use ChesstrainerWeb, :live_view use ChesstrainerWeb, :live_view
alias Chesstrainer.Endgames import ChesstrainerWeb.EndgameList
@impl true @impl true
def render(assigns) do def render(assigns) do
~H""" ~H"""
<Layouts.app flash={@flash}> <Layouts.app flash={@flash} wide>
<.header> <.header>
Endgames Endgames
<:subtitle>Pick an endgame to play.</:subtitle> <:subtitle>Pick an endgame to play.</:subtitle>
</.header> </.header>
<.table <.filter_bar
id="player-endgames" selected_themes={@selected_themes}
rows={@streams.endgames} theme_query={@theme_query}
> theme_results={@theme_results}
<:col :let={{_id, endgame}} label="Key">{endgame.key}</:col> keys={@keys}
<:col :let={{_id, endgame}} label="Color">{endgame.color}</:col> selected_key={@selected_key}
<:col :let={{_id, endgame}} label="Result">{endgame.result}</:col> />
<:col :let={{_id, endgame}} label="Rating">{endgame.rating}</:col>
<:action :let={{_id, endgame}}> <.grouped_list :if={@groups != []} groups={@groups}>
<.link navigate={~p"/endgames/#{endgame}/play"}>Play</.link> <:header>
</:action> <tr>
</.table> <th>Color</th>
<th>Result</th>
<th>Rating</th>
<th>Themes</th>
<th><span class="sr-only">Actions</span></th>
</tr>
</:header>
<:row :let={endgame}>
<tr id={"endgame-" <> endgame.id}>
<td phx-click={JS.navigate(~p"/endgames/#{endgame}/play")} class="hover:cursor-pointer">
{endgame.color}
</td>
<td phx-click={JS.navigate(~p"/endgames/#{endgame}/play")} class="hover:cursor-pointer">
{endgame.result}
</td>
<td phx-click={JS.navigate(~p"/endgames/#{endgame}/play")} class="hover:cursor-pointer">
{endgame.rating}
</td>
<td>
<span :for={theme <- endgame.themes} class="badge badge-sm">
<button type="button" phx-click="add_theme" phx-value-id={theme.id}>
{theme.name}
</button>
</span>
<span :if={endgame.themes == []} class="text-base-content/50">None</span>
</td>
<td class="w-0 font-semibold">
<.link navigate={~p"/endgames/#{endgame}/play"}>Play</.link>
</td>
</tr>
</:row>
</.grouped_list>
<p :if={@groups == []} class="text-base-content/70">
No endgames match these filters.
</p>
</Layouts.app> </Layouts.app>
""" """
end end
@@ -33,6 +69,11 @@ defmodule ChesstrainerWeb.EndgameLive.PlayerIndex do
{:ok, {:ok,
socket socket
|> assign(:page_title, "Endgames") |> assign(:page_title, "Endgames")
|> stream(:endgames, Endgames.list_endgames())} |> init_state()}
end
@impl true
def handle_event(event, params, socket) do
handle_filter_event(event, params, socket)
end end
end end
@@ -3,6 +3,8 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Game alias Chesstrainer.Game
alias Chesstrainer.Repo
alias Chesstrainer.Themes
import ChesstrainerWeb.Board.BoardComponent import ChesstrainerWeb.Board.BoardComponent
@@ -23,7 +25,7 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
|> assign(:game_type, :endgame) |> assign(:game_type, :endgame)
~H""" ~H"""
<Layouts.app flash={@flash}> <Layouts.app flash={@flash} wide>
<.header> <.header>
Endgame {@endgame.id} Endgame {@endgame.id}
<:subtitle>This is a endgame record from your database.</:subtitle> <:subtitle>This is a endgame record from your database.</:subtitle>
@@ -50,6 +52,7 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
<:item title="Message">{@endgame.message}</:item> <:item title="Message">{@endgame.message}</:item>
<:item title="Notes">{@endgame.notes}</:item> <:item title="Notes">{@endgame.notes}</:item>
<:item title="Result">{@endgame.result}</:item> <:item title="Result">{@endgame.result}</:item>
<:item title="Themes">{Enum.join(Themes.names(@endgame.themes), ", ")}</:item>
<:item title="Attempted">{@endgame.times_attempted}</:item> <:item title="Attempted">{@endgame.times_attempted}</:item>
<:item title="Solved">{@endgame.times_solved}</:item> <:item title="Solved">{@endgame.times_solved}</:item>
</.list> </.list>
@@ -62,6 +65,6 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
{:ok, {:ok,
socket socket
|> assign(:page_title, "Show Endgame") |> assign(:page_title, "Show Endgame")
|> assign(:endgame, Endgames.get_endgame!(id))} |> assign(:endgame, Endgames.get_endgame!(id) |> Repo.preload(:themes))}
end end
end end
@@ -1,14 +1,14 @@
defmodule Chesstrainer.Repo.Migrations.CreateTags do defmodule Chesstrainer.Repo.Migrations.CreateThemes do
use Ecto.Migration use Ecto.Migration
def change do def change do
create table(:tags) do create table(:themes) do
add :name, :string add :name, :string
add :category, :string add :category, :string
timestamps(type: :utc_datetime) timestamps(type: :utc_datetime)
end end
create unique_index(:tags, [:name, :category]) create unique_index(:themes, [:name, :category])
end end
end end
@@ -19,5 +19,6 @@ defmodule Chesstrainer.Repo.Migrations.CreateEndgames do
end end
create unique_index(:endgames, [:fen]) create unique_index(:endgames, [:fen])
create index(:endgames, [:key])
end end
end end
@@ -1,12 +0,0 @@
defmodule Chesstrainer.Repo.Migrations.CreateEndgamesTags do
use Ecto.Migration
def change do
create table(:endgames_tags, primary_key: false) do
add :endgame_id, references(:endgames, type: :binary_id, on_delete: :delete_all)
add :tag_id, references(:tags, on_delete: :delete_all)
end
create unique_index(:endgames_tags, [:endgame_id, :tag_id])
end
end
@@ -0,0 +1,12 @@
defmodule Chesstrainer.Repo.Migrations.CreateEndgamesThemes do
use Ecto.Migration
def change do
create table(:endgames_themes, primary_key: false) do
add :endgame_id, references(:endgames, type: :binary_id, on_delete: :delete_all)
add :theme_id, references(:themes, on_delete: :delete_all)
end
create unique_index(:endgames_themes, [:endgame_id, :theme_id])
end
end
@@ -0,0 +1,17 @@
defmodule Chesstrainer.Repo.Migrations.CaseInsensitiveThemeNames do
use Ecto.Migration
def up do
drop index(:themes, [:name, :category])
create unique_index(:themes, ["lower(name)", :category],
name: :themes_name_category_lower_index
)
end
def down do
drop index(:themes, ["lower(name)", :category], name: :themes_name_category_lower_index)
create unique_index(:themes, [:name, :category])
end
end
+37 -29
View File
@@ -12,54 +12,62 @@
alias Chesstrainer.Repo alias Chesstrainer.Repo
alias Chesstrainer.Endgames.Endgame alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Tags.Tag alias Chesstrainer.Themes.Theme
now = DateTime.utc_now() |> DateTime.truncate(:second) now = DateTime.utc_now() |> DateTime.truncate(:second)
IO.puts("🌱 Seeding basic endgames into DB...") IO.puts("🌱 Seeding basic endgames into DB...")
Repo.insert_all(Endgame, [ endgames = [
%{ %{
id: Ecto.UUID.generate(),
fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1", fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1",
color: :white, color: :white,
key: "KR v K",
message: "Rook vs king endgame", message: "Rook vs king endgame",
notes: "Basic rook endgame", notes: "Basic rook endgame",
result: :win, result: :win
inserted_at: now,
updated_at: now
}, },
%{ %{
id: Ecto.UUID.generate(),
fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1", fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1",
color: :black, color: :black,
key: "KPPP v KPP",
message: "3 pawns vs 2 pawns", message: "3 pawns vs 2 pawns",
notes: "https://www.chessgames.com/perl/chessgame?gid=1017147", notes: "https://www.chessgames.com/perl/chessgame?gid=1017147",
result: :win, result: :win
inserted_at: now,
updated_at: now
} }
]) ]
Repo.insert_all(
Endgame,
Enum.map(endgames, fn endgame ->
{:ok, key} = Chesstrainer.Key.from_fen(endgame.fen)
endgame
|> Map.put(:id, Ecto.UUID.generate())
|> Map.put(:key, key)
|> Map.merge(%{inserted_at: now, updated_at: now})
end),
on_conflict: :nothing
)
IO.puts("✅ Done seeding endgames.") IO.puts("✅ Done seeding endgames.")
IO.puts("🌱 Seeding endgame tags into DB...") IO.puts("🌱 Seeding endgame themes into DB...")
Repo.insert_all(Tag, [ theme_names = [
%{ "mate in 2",
name: "mate in 2", "mate in 3",
category: :endgame, "Lucena",
inserted_at: now, "Philidor",
updated_at: now "opposition",
}, "promotion",
%{ "stalemate"
name: "mate in 3", ]
category: :endgame,
inserted_at: now,
updated_at: now
}
])
IO.puts("✅ Done seeding endgame tags.") Repo.insert_all(
Theme,
Enum.map(theme_names, fn name ->
%{name: name, category: :endgame, inserted_at: now, updated_at: now}
end),
on_conflict: :nothing
)
IO.puts("✅ Done seeding endgame themes.")
+117 -8
View File
@@ -3,25 +3,60 @@ defmodule Chesstrainer.EndgamesTest do
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Endgames.Endgame alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Themes
@kr "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
@kr_other "8/8/4k3/8/8/3K1R2/8/8 w - - 0 1"
@kq "8/8/3k4/8/8/3K1Q2/8/8 w - - 0 1"
defp create_endgame!(fen, themes \\ []) do
attrs = %{fen: fen, color: :white, result: :win, rating: 1500}
{:ok, endgame} = Endgames.create_endgame(attrs, themes)
endgame
end
describe "create_endgame/1 FEN validation" do describe "create_endgame/1 FEN validation" do
test "accepts a standard valid FEN" do test "accepts a standard valid FEN and derives its key" do
attrs = %{ attrs = %{
fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1", fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1",
color: :white, color: :white,
key: "KR v K",
result: :win, result: :win,
rating: 1500 rating: 1500
} }
assert {:ok, %Endgame{}} = Endgames.create_endgame(attrs) assert {:ok, %Endgame{} = endgame} = Endgames.create_endgame(attrs)
assert endgame.key == "KR v K"
end
test "derives the key from the strongest side, colour-agnostically" do
attrs = %{
fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 0",
color: :black,
result: :win,
rating: 1500
}
assert {:ok, endgame} = Endgames.create_endgame(attrs)
assert endgame.key == "KPPP v KPP"
end
test "ignores a supplied key and derives it from the FEN" do
attrs = %{
fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1",
color: :white,
key: "KQ v K",
result: :win,
rating: 1500
}
assert {:ok, endgame} = Endgames.create_endgame(attrs)
assert endgame.key == "KR v K"
end end
test "normalizes fullmove 0 to 1 before inserting" do test "normalizes fullmove 0 to 1 before inserting" do
attrs = %{ attrs = %{
fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 0", fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 0",
color: :black, color: :black,
key: "KPPP v KPP",
result: :win, result: :win,
rating: 1500 rating: 1500
} }
@@ -34,7 +69,6 @@ defmodule Chesstrainer.EndgamesTest do
attrs = %{ attrs = %{
fen: " 8/8/3k4/8/8/3K1R2/8/8 w - - 0 1\t\n", fen: " 8/8/3k4/8/8/3K1R2/8/8 w - - 0 1\t\n",
color: :white, color: :white,
key: "KR v K",
result: :win, result: :win,
rating: 1500 rating: 1500
} }
@@ -47,7 +81,6 @@ defmodule Chesstrainer.EndgamesTest do
attrs = %{ attrs = %{
fen: "4k3/8/8/8/8/8/8/0K7 w - - 0 1", fen: "4k3/8/8/8/8/8/8/0K7 w - - 0 1",
color: :white, color: :white,
key: "KQ v K",
result: :win, result: :win,
rating: 1500 rating: 1500
} }
@@ -61,7 +94,6 @@ defmodule Chesstrainer.EndgamesTest do
attrs = %{ attrs = %{
fen: "8/8/3k4/8/8/3K1R2/8/8", fen: "8/8/3k4/8/8/3K1R2/8/8",
color: :white, color: :white,
key: "KQ v K",
result: :win, result: :win,
rating: 1500 rating: 1500
} }
@@ -75,7 +107,6 @@ defmodule Chesstrainer.EndgamesTest do
attrs = %{ attrs = %{
fen: "8/8/3k4/8/8/3K1R2/8/8 x - - 0 1", fen: "8/8/3k4/8/8/3K1R2/8/8 x - - 0 1",
color: :white, color: :white,
key: "KQ v K",
result: :win, result: :win,
rating: 1500 rating: 1500
} }
@@ -85,4 +116,82 @@ defmodule Chesstrainer.EndgamesTest do
assert msg =~ "active color" assert msg =~ "active color"
end end
end end
describe "themes" do
test "create_endgame/2 associates themes" do
{:ok, theme} = Themes.create_theme(%{name: "Lucena", category: :endgame})
attrs = %{
fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1",
color: :white,
result: :win,
rating: 1500
}
assert {:ok, endgame} = Endgames.create_endgame(attrs, [theme])
assert Enum.map(endgame.themes, & &1.id) == [theme.id]
end
test "update_endgame/3 replaces themes" do
{:ok, lucena} = Themes.create_theme(%{name: "Lucena", category: :endgame})
{:ok, philidor} = Themes.create_theme(%{name: "Philidor", category: :endgame})
attrs = %{
fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1",
color: :black,
result: :win,
rating: 1500
}
assert {:ok, endgame} = Endgames.create_endgame(attrs, [lucena])
assert {:ok, updated} = Endgames.update_endgame(endgame, %{rating: 1600}, [philidor])
assert Enum.map(updated.themes, & &1.id) == [philidor.id]
assert updated.key == "KPPP v KPP"
end
end
describe "listing and filtering" do
test "list_keys/0 returns the distinct keys sorted" do
create_endgame!(@kr)
create_endgame!(@kr_other)
create_endgame!(@kq)
assert Endgames.list_keys() == ["KQ v K", "KR v K"]
end
test "list_key_groups/1 groups by key and counts" do
create_endgame!(@kr)
create_endgame!(@kr_other)
create_endgame!(@kq)
assert Endgames.list_key_groups() == [{"KQ v K", 1}, {"KR v K", 2}]
end
test "list_endgames_for_key/2 returns only that key with themes preloaded" do
{:ok, lucena} = Themes.create_theme(%{name: "Lucena", category: :endgame})
create_endgame!(@kr, [lucena])
create_endgame!(@kq)
assert [endgame] = Endgames.list_endgames_for_key("KR v K")
assert endgame.fen == @kr
assert Enum.map(endgame.themes, & &1.name) == ["Lucena"]
end
test "list_key_groups/1 filters by theme" do
{:ok, lucena} = Themes.create_theme(%{name: "Lucena", category: :endgame})
{:ok, philidor} = Themes.create_theme(%{name: "Philidor", category: :endgame})
create_endgame!(@kr, [lucena])
create_endgame!(@kq, [philidor])
assert Endgames.list_key_groups(%{themes: [lucena.id]}) == [{"KR v K", 1}]
end
test "list_key_groups/1 filters by key" do
create_endgame!(@kr)
create_endgame!(@kq)
assert Endgames.list_key_groups(%{key: "KQ v K"}) == [{"KQ v K", 1}]
end
end
end end
+39
View File
@@ -0,0 +1,39 @@
defmodule Chesstrainer.KeyTest do
use ExUnit.Case, async: true
doctest Chesstrainer.Key
alias Chesstrainer.Key
describe "from_fen/1" do
test "derives a rook endgame" do
assert Key.from_fen("8/8/3k4/8/8/3K1R2/8/8 w - - 0 1") == {:ok, "KR v K"}
end
test "is colour-agnostic" do
white_queen = "8/8/3k1r2/8/8/3K1Q2/8/8 w - - 0 1"
black_queen = "8/8/3k1q2/8/8/3K1R2/8/8 w - - 0 1"
assert Key.from_fen(white_queen) == {:ok, "KQ v KR"}
assert Key.from_fen(black_queen) == {:ok, "KQ v KR"}
end
test "puts the side with more material first" do
assert Key.from_fen("6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1") == {:ok, "KPPP v KPP"}
end
test "orders equal-value sides deterministically" do
white_bishop = "8/8/3k1n2/8/8/3K1B2/8/8 w - - 0 1"
white_knight = "8/8/3k1b2/8/8/3K1N2/8/8 w - - 0 1"
assert Key.from_fen(white_bishop) == {:ok, "KB v KN"}
assert Key.from_fen(white_knight) == {:ok, "KB v KN"}
end
test "returns an error for malformed FENs" do
assert Key.from_fen("not a fen") == {:error, :invalid_fen}
assert Key.from_fen("8/8/8 w - - 0 1") == {:error, :invalid_fen}
assert Key.from_fen(nil) == {:error, :invalid_fen}
end
end
end
-61
View File
@@ -1,61 +0,0 @@
defmodule Chesstrainer.TagsTest do
use Chesstrainer.DataCase
alias Chesstrainer.Tags
describe "tags" do
alias Chesstrainer.Tags.Tag
import Chesstrainer.TagsFixtures
@invalid_attrs %{name: nil, category: nil}
test "list_tags/0 returns all tags" do
tag = tag_fixture()
assert Tags.list_tags() == [tag]
end
test "get_tag!/1 returns the tag with given id" do
tag = tag_fixture()
assert Tags.get_tag!(tag.id) == tag
end
test "create_tag/1 with valid data creates a tag" do
valid_attrs = %{name: "some name", category: :endgame}
assert {:ok, %Tag{} = tag} = Tags.create_tag(valid_attrs)
assert tag.name == "some name"
assert tag.category == :endgame
end
test "create_tag/1 with invalid data returns error changeset" do
assert {:error, %Ecto.Changeset{}} = Tags.create_tag(@invalid_attrs)
end
test "update_tag/2 with valid data updates the tag" do
tag = tag_fixture()
update_attrs = %{name: "some updated name", category: :opening}
assert {:ok, %Tag{} = tag} = Tags.update_tag(tag, update_attrs)
assert tag.name == "some updated name"
assert tag.category == :opening
end
test "update_tag/2 with invalid data returns error changeset" do
tag = tag_fixture()
assert {:error, %Ecto.Changeset{}} = Tags.update_tag(tag, @invalid_attrs)
assert tag == Tags.get_tag!(tag.id)
end
test "delete_tag/1 deletes the tag" do
tag = tag_fixture()
assert {:ok, %Tag{}} = Tags.delete_tag(tag)
assert_raise Ecto.NoResultsError, fn -> Tags.get_tag!(tag.id) end
end
test "change_tag/1 returns a tag changeset" do
tag = tag_fixture()
assert %Ecto.Changeset{} = Tags.change_tag(tag)
end
end
end
+79
View File
@@ -0,0 +1,79 @@
defmodule Chesstrainer.ThemesTest do
use Chesstrainer.DataCase
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
theme = theme_fixture()
assert Themes.list_themes() == [theme]
end
test "get_theme!/1 returns the theme with given id" do
theme = theme_fixture()
assert Themes.get_theme!(theme.id) == theme
end
test "create_theme/1 with valid data creates a theme" do
valid_attrs = %{name: "some name", category: :endgame}
assert {:ok, %Theme{} = theme} = Themes.create_theme(valid_attrs)
assert theme.name == "some name"
assert theme.category == :endgame
end
test "create_theme/1 with invalid data returns error changeset" do
assert {:error, %Ecto.Changeset{}} = Themes.create_theme(@invalid_attrs)
end
test "update_theme/2 with valid data updates the theme" do
theme = theme_fixture()
update_attrs = %{name: "some updated name", category: :opening}
assert {:ok, %Theme{} = theme} = Themes.update_theme(theme, update_attrs)
assert theme.name == "some updated name"
assert theme.category == :opening
end
test "update_theme/2 with invalid data returns error changeset" do
theme = theme_fixture()
assert {:error, %Ecto.Changeset{}} = Themes.update_theme(theme, @invalid_attrs)
assert theme == Themes.get_theme!(theme.id)
end
test "delete_theme/1 deletes the theme" do
theme = theme_fixture()
assert {:ok, %Theme{}} = Themes.delete_theme(theme)
assert_raise Ecto.NoResultsError, fn -> Themes.get_theme!(theme.id) end
end
test "change_theme/1 returns a theme changeset" do
theme = theme_fixture()
assert %Ecto.Changeset{} = Themes.change_theme(theme)
end
test "get_or_create/2 matches case-insensitively and trims" do
assert {:ok, theme} = Themes.get_or_create("Lucena", "endgame")
assert {:ok, found} = Themes.get_or_create(" lucena ", "endgame")
assert found.id == theme.id
assert length(Themes.list_themes()) == 1
end
test "get_or_create/2 rejects a blank name" do
assert {:error, :blank_name} = Themes.get_or_create(" ", "endgame")
end
test "create_theme/1 rejects a case-insensitive duplicate" do
assert {:ok, _theme} = Themes.create_theme(%{name: "Lucena", category: :endgame})
assert {:error, changeset} = Themes.create_theme(%{name: "lucena", category: :endgame})
assert changeset.errors[:name]
end
end
end
@@ -0,0 +1,85 @@
defmodule ChesstrainerWeb.EndgameLive.FormTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.ThemesFixtures
alias Chesstrainer.Endgames
alias Chesstrainer.Repo
alias Chesstrainer.Themes
@fen "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
test "creates an endgame with staged themes", %{conn: conn} do
theme = theme_fixture(%{name: "Lucena"})
{:ok, view, html} = live(conn, ~p"/admin/endgames/new")
assert html =~ "max-w-2xl"
view |> form("#theme-form", %{theme_search: "Luc"}) |> render_change()
view |> element("button", "Lucena") |> render_click()
view
|> form("#endgame-form",
endgame: %{fen: @fen, rating: 1500, result: "win"}
)
|> render_submit()
assert_redirect(view, ~p"/admin/endgames")
endgame =
Endgames.list_endgames()
|> Enum.find(&(&1.fen == @fen))
|> Repo.preload(:themes)
assert Enum.map(endgame.themes, & &1.id) == [theme.id]
end
test "attaches multiple themes", %{conn: conn} do
theme_fixture(%{name: "Lucena"})
theme_fixture(%{name: "Philidor"})
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
view |> form("#theme-form", %{theme_search: "Luc"}) |> render_change()
view |> element("button", "Lucena") |> render_click()
view |> form("#theme-form", %{theme_search: "Phil"}) |> render_change()
view |> element("button", "Philidor") |> render_click()
html = render(view)
assert html =~ "Lucena"
assert html =~ "Philidor"
end
test "creates and attaches a new theme inline", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
view |> form("#theme-form", %{theme_search: "Lucerne"}) |> render_submit()
assert render(view) =~ "Lucerne"
assert [%{name: "Lucerne"}] = Themes.search("Lucerne", "endgame")
end
test "removes a theme from an existing endgame", %{conn: conn} do
theme = theme_fixture(%{name: "Lucena"})
attrs = %{fen: @fen, color: :white, result: :win, rating: 1500}
{:ok, endgame} = Endgames.create_endgame(attrs, [theme])
{:ok, view, _html} = live(conn, ~p"/admin/endgames/#{endgame}/edit")
assert render(view) =~ "Lucena"
view |> element("button[aria-label='Remove Lucena']") |> render_click()
view
|> form("#endgame-form", endgame: %{rating: 1500, result: "win"})
|> render_submit()
assert_redirect(view, ~p"/admin/endgames")
updated = Endgames.get_endgame!(endgame.id) |> Repo.preload(:themes)
assert updated.themes == []
end
end
@@ -0,0 +1,83 @@
defmodule ChesstrainerWeb.EndgameLive.IndexTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.EndgamesFixtures
import Chesstrainer.ThemesFixtures
alias Chesstrainer.Endgames
test "groups endgames by Key with a count", %{conn: conn} do
endgame_fixture()
endgame_fixture()
{:ok, view, html} = live(conn, ~p"/admin/endgames")
assert html =~ "max-w-7xl"
assert has_element?(view, "#key-group-K-v-K")
assert has_element?(view, "#key-group-K-v-K .badge", "2")
end
test "trims the table to the key columns", %{conn: conn} do
endgame_fixture()
{:ok, view, _html} = live(conn, ~p"/admin/endgames")
view |> element("#key-group-K-v-K button") |> render_click()
for label <- ~w(Key Color Result Themes Rating) do
assert has_element?(view, "th", label)
end
for label <- ~w(Fen Message Notes Attempted Solved) do
refute has_element?(view, "th", label)
end
end
test "lazy-loads a group's endgames when expanded", %{conn: conn} do
theme = theme_fixture(%{name: "Lucena"})
endgame = endgame_fixture()
{:ok, _} = Endgames.update_endgame(endgame, %{}, [theme])
{:ok, view, html} = live(conn, ~p"/admin/endgames")
# collapsed: the endgame row (and its themes) are not rendered yet
refute html =~ ~p"/endgames/#{endgame}/play"
refute html =~ "Lucena"
view |> element("#key-group-K-v-K button") |> render_click()
html = render(view)
assert html =~ ~p"/endgames/#{endgame}/play"
assert html =~ "Lucena"
end
test "filters by theme", %{conn: conn} do
lucena = theme_fixture(%{name: "Lucena"})
philidor = theme_fixture(%{name: "Philidor"})
kr = endgame_fixture(fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1")
kq = endgame_fixture(fen: "8/8/3k4/8/8/3K1Q2/8/8 w - - 0 1")
{:ok, _} = Endgames.update_endgame(kr, %{}, [lucena])
{:ok, _} = Endgames.update_endgame(kq, %{}, [philidor])
{:ok, view, _html} = live(conn, ~p"/admin/endgames")
view |> form("#theme-filter-form", %{theme_search: "Luc"}) |> render_change()
view |> element("button", "Lucena") |> render_click()
assert has_element?(view, "#key-group-KR-v-K")
refute has_element?(view, "#key-group-KQ-v-K")
end
test "filters by Key", %{conn: conn} do
endgame_fixture(fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1")
endgame_fixture(fen: "8/8/3k4/8/8/3K1Q2/8/8 w - - 0 1")
{:ok, view, _html} = live(conn, ~p"/admin/endgames")
view |> form("#key-filter-form", %{key: "KQ v K"}) |> render_change()
assert has_element?(view, "#key-group-KQ-v-K")
refute has_element?(view, "#key-group-KR-v-K")
end
end
@@ -39,6 +39,13 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
] ]
end end
defp draw_moves do
[
%Tablebase.Move{uci: "d1d7", san: "Qd7", category: :draw, dtz: nil},
%Tablebase.Move{uci: "d1d4", san: "Qd4", category: :win, dtz: nil}
]
end
defp play_move(view, endgame, from, to, san) do defp play_move(view, endgame, from, to, san) do
render_hook(view, "endgame_move_played", %{ render_hook(view, "endgame_move_played", %{
"from" => from, "from" => from,
@@ -71,7 +78,14 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
end end
test "shows endgame metadata in the header", %{conn: conn} do test "shows endgame metadata in the header", %{conn: conn} do
endgame = endgame_fixture(key: "KQ v K", color: :white, result: :win, rating: 1800) endgame =
endgame_fixture(
fen: "8/8/3k4/8/8/3K1Q2/8/8 w - - 0 1",
color: :white,
result: :win,
rating: 1800
)
seed_tablebase(endgame.fen) seed_tablebase(endgame.fen)
{:ok, _view, html} = live(conn, ~p"/endgames/#{endgame}/play") {:ok, _view, html} = live(conn, ~p"/endgames/#{endgame}/play")
@@ -79,6 +93,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
assert html =~ "KQ v K" assert html =~ "KQ v K"
assert html =~ "White to move" assert html =~ "White to move"
assert html =~ "1800" assert html =~ "1800"
assert html =~ "max-w-2xl"
end end
test "raises when the endgame does not exist", %{conn: conn} do test "raises when the endgame does not exist", %{conn: conn} do
@@ -294,6 +309,112 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
end end
end end
describe "draw endgames" do
test "loads and is playable", %{conn: conn} do
endgame = endgame_fixture(result: :draw)
seed_tablebase(endgame.fen, category: :draw, moves: [])
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
assert has_element?(view, "#endgame-board")
assert render(view) =~ "Make a move"
end
test "passes a move that keeps the draw and replies", %{conn: conn} do
endgame = endgame_fixture(result: :draw)
fen_after = "8/8/8/8/8/8/8/8 b - - 0 1"
reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :draw, dtz: nil}
seed_tablebase(endgame.fen, category: :draw, moves: draw_moves())
seed_tablebase(fen_after, category: :draw, moves: [reply])
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d7",
"san" => "Qd7",
"draw" => false,
"prev_fen" => endgame.fen,
"fen" => fen_after,
"endgame_id" => endgame.id
})
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "opponent_move", payload}}, 100
assert payload == %{from: "e8", to: "e7", promotion: nil, san: "Ke7"}
end
test "fails a move that loses the draw", %{conn: conn} do
endgame = endgame_fixture(result: :draw)
seed_tablebase(endgame.fen, category: :draw, moves: draw_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d4",
"san" => "Qd4",
"draw" => false,
"prev_fen" => endgame.fen,
"fen" => endgame.fen,
"endgame_id" => endgame.id
})
html = render(view)
assert html =~ "Failed"
assert html =~ "loses the draw"
assert html =~ "Qd7"
end
test "solves when the user's move draws by rule", %{conn: conn} do
endgame = endgame_fixture(result: :draw)
seed_tablebase(endgame.fen, category: :draw, moves: draw_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d7",
"san" => "Qd7",
"draw" => true,
"prev_fen" => endgame.fen,
"fen" => endgame.fen,
"endgame_id" => endgame.id
})
assert render(view) =~ "Draw held!"
assert Endgames.get_endgame!(endgame.id).times_solved == 1
end
test "solves when the opponent's reply draws by rule", %{conn: conn} do
endgame = endgame_fixture(result: :draw)
fen_after = "8/8/8/8/8/8/8/8 b - - 0 1"
reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :draw, dtz: nil}
seed_tablebase(endgame.fen, category: :draw, moves: draw_moves())
seed_tablebase(fen_after, category: :draw, moves: [reply])
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d7",
"san" => "Qd7",
"draw" => false,
"prev_fen" => endgame.fen,
"fen" => fen_after,
"endgame_id" => endgame.id
})
render_hook(view, "opponent_reply_applied", %{"fen" => fen_after, "draw" => true})
assert render(view) =~ "Draw held!"
assert Endgames.get_endgame!(endgame.id).times_solved == 1
end
end
describe "reset" do describe "reset" do
test "clears the move list and grade, and re-pushes init_board", %{conn: conn} do test "clears the move list and grade, and re-pushes init_board", %{conn: conn} do
endgame = endgame_fixture() endgame = endgame_fixture()
@@ -3,18 +3,47 @@ defmodule ChesstrainerWeb.EndgameLive.PlayerIndexTest do
import Phoenix.LiveViewTest import Phoenix.LiveViewTest
import Chesstrainer.EndgamesFixtures import Chesstrainer.EndgamesFixtures
import Chesstrainer.ThemesFixtures
test "lists endgames with a play link per row", %{conn: conn} do alias Chesstrainer.Endgames
test "groups endgames by Key and shows themes on expand", %{conn: conn} do
theme = theme_fixture(%{name: "Lucena"})
endgame = endgame_fixture() endgame = endgame_fixture()
other = endgame_fixture() other = endgame_fixture()
{:ok, _} = Endgames.update_endgame(endgame, %{}, [theme])
{:ok, _view, html} = live(conn, ~p"/endgames") {:ok, view, html} = live(conn, ~p"/endgames")
assert html =~ "Endgames" assert html =~ "Endgames"
assert html =~ endgame.key assert html =~ "max-w-7xl"
assert html =~ other.key assert has_element?(view, "#key-group-K-v-K")
refute html =~ "Lucena"
view |> element("#key-group-K-v-K button") |> render_click()
html = render(view)
assert html =~ ~p"/endgames/#{endgame}/play" assert html =~ ~p"/endgames/#{endgame}/play"
assert html =~ ~p"/endgames/#{other}/play" assert html =~ ~p"/endgames/#{other}/play"
assert html =~ "Lucena"
end
test "filters by theme", %{conn: conn} do
lucena = theme_fixture(%{name: "Lucena"})
philidor = theme_fixture(%{name: "Philidor"})
kr = endgame_fixture(fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1")
kq = endgame_fixture(fen: "8/8/3k4/8/8/3K1Q2/8/8 w - - 0 1")
{:ok, _} = Endgames.update_endgame(kr, %{}, [lucena])
{:ok, _} = Endgames.update_endgame(kq, %{}, [philidor])
{:ok, view, _html} = live(conn, ~p"/endgames")
view |> form("#theme-filter-form", %{theme_search: "Luc"}) |> render_change()
view |> element("button", "Lucena") |> render_click()
assert has_element?(view, "#key-group-KR-v-K")
refute has_element?(view, "#key-group-KQ-v-K")
end end
test "navigating to a play page renders the board", %{conn: conn} do test "navigating to a play page renders the board", %{conn: conn} do
+1 -3
View File
@@ -24,15 +24,13 @@ defmodule Chesstrainer.EndgamesFixtures do
@doc """ @doc """
Generate an endgame. Generate an endgame.
A simple K v K position with a unique FEN, color, A simple K v K position with a unique FEN, color, rating, and result.
key, rating, and result.
""" """
def endgame_fixture(attrs \\ %{}) do def endgame_fixture(attrs \\ %{}) do
{:ok, endgame} = {:ok, endgame} =
attrs attrs
|> Enum.into(%{ |> Enum.into(%{
fen: unique_endgame_fen(), fen: unique_endgame_fen(),
key: "KQ v K",
color: :white, color: :white,
result: :win, result: :win,
rating: 1500 rating: 1500
-26
View File
@@ -1,26 +0,0 @@
defmodule Chesstrainer.TagsFixtures do
@moduledoc """
This module defines test helpers for creating
entities via the `Chesstrainer.Tags` context.
"""
@doc """
Generate a unique tag name.
"""
def unique_tag_name, do: "some name#{System.unique_integer([:positive])}"
@doc """
Generate a tag.
"""
def tag_fixture(attrs \\ %{}) do
{:ok, tag} =
attrs
|> Enum.into(%{
category: :endgame,
name: unique_tag_name()
})
|> Chesstrainer.Tags.create_tag()
tag
end
end
+26
View File
@@ -0,0 +1,26 @@
defmodule Chesstrainer.ThemesFixtures do
@moduledoc """
This module defines test helpers for creating
entities via the `Chesstrainer.Themes` context.
"""
@doc """
Generate a unique theme name.
"""
def unique_theme_name, do: "some name#{System.unique_integer([:positive])}"
@doc """
Generate a theme.
"""
def theme_fixture(attrs \\ %{}) do
{:ok, theme} =
attrs
|> Enum.into(%{
category: :endgame,
name: unique_theme_name()
})
|> Chesstrainer.Themes.create_theme()
theme
end
end