mirror of
https://github.com/TheRealOwenRees/chess-endgame-trainer.git
synced 2026-11-18 11:42:07 +00:00
Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7658450573
|
||
|
|
49c3cddffb
|
||
|
|
d231860f14
|
||
|
|
ca65207baa
|
||
|
|
cd2e7f0164
|
||
|
|
645f65f2a3
|
||
|
|
be23f1d7f8
|
+11
@@ -19,6 +19,17 @@ _Avoid_: Endgame (the stored record), exercise
|
||||
One playthrough of a puzzle by a user, ending solved or failed.
|
||||
_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
|
||||
|
||||
**Winning side**:
|
||||
|
||||
@@ -161,6 +161,8 @@ export const ChessBoard = {
|
||||
fen: this.chess.fen(),
|
||||
san: move.san,
|
||||
promotion: promotion || null,
|
||||
draw: this.chess.isDraw(),
|
||||
checkmate: this.chess.isCheckmate(),
|
||||
};
|
||||
|
||||
if (isTrainer) {
|
||||
@@ -204,6 +206,8 @@ export const ChessBoard = {
|
||||
this.pushEvent("opponent_reply_applied", {
|
||||
fen: this.chess.fen(),
|
||||
san: move.san,
|
||||
draw: this.chess.isDraw(),
|
||||
checkmate: this.chess.isCheckmate(),
|
||||
});
|
||||
},
|
||||
|
||||
|
||||
@@ -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.
|
||||
@@ -21,6 +21,61 @@ defmodule Chesstrainer.Endgames do
|
||||
Repo.all(Endgame)
|
||||
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 """
|
||||
Gets a single endgame.
|
||||
|
||||
@@ -49,9 +104,10 @@ defmodule Chesstrainer.Endgames do
|
||||
{:error, %Ecto.Changeset{}}
|
||||
|
||||
"""
|
||||
def create_endgame(attrs) do
|
||||
def create_endgame(attrs, themes \\ []) do
|
||||
%Endgame{}
|
||||
|> Endgame.changeset(attrs)
|
||||
|> Ecto.Changeset.put_assoc(:themes, themes)
|
||||
|> Repo.insert()
|
||||
end
|
||||
|
||||
@@ -67,12 +123,14 @@ defmodule Chesstrainer.Endgames do
|
||||
{:error, %Ecto.Changeset{}}
|
||||
|
||||
"""
|
||||
def update_endgame(%Endgame{} = endgame, attrs) do
|
||||
def update_endgame(%Endgame{} = endgame, attrs, themes \\ []) do
|
||||
# ignore fen on update
|
||||
attrs = Map.delete(attrs, "fen")
|
||||
|
||||
endgame
|
||||
|> Repo.preload(:themes)
|
||||
|> Endgame.changeset(attrs)
|
||||
|> Ecto.Changeset.put_assoc(:themes, themes)
|
||||
|> Repo.update()
|
||||
end
|
||||
|
||||
@@ -120,20 +178,4 @@ defmodule Chesstrainer.Endgames do
|
||||
|
||||
{:ok, Repo.get!(Endgame, id)}
|
||||
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
|
||||
|
||||
@@ -6,6 +6,8 @@ defmodule Chesstrainer.Endgames.Endgame do
|
||||
use Ecto.Schema
|
||||
import Ecto.Changeset
|
||||
|
||||
alias Chesstrainer.Key
|
||||
|
||||
@primary_key {:id, :binary_id, autogenerate: true}
|
||||
@foreign_key_type :binary_id
|
||||
schema "endgames" do
|
||||
@@ -20,8 +22,8 @@ defmodule Chesstrainer.Endgames.Endgame do
|
||||
field :times_attempted, :integer
|
||||
field :times_solved, :integer
|
||||
|
||||
many_to_many :tags, Chesstrainer.Tags.Tag,
|
||||
join_through: "endgames_tags",
|
||||
many_to_many :themes, Chesstrainer.Themes.Theme,
|
||||
join_through: "endgames_themes",
|
||||
on_replace: :delete
|
||||
|
||||
timestamps(type: :utc_datetime)
|
||||
@@ -30,12 +32,9 @@ defmodule Chesstrainer.Endgames.Endgame do
|
||||
@doc false
|
||||
def changeset(endgame, attrs) do
|
||||
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([:key, :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_required([:result, :rating])
|
||||
|> validate_change(:fen, fn :fen, fen ->
|
||||
case fen_issues(fen) do
|
||||
[] -> []
|
||||
@@ -43,6 +42,14 @@ defmodule Chesstrainer.Endgames.Endgame do
|
||||
end
|
||||
end)
|
||||
|> 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
|
||||
|
||||
defp normalize_attrs(%{"fen" => fen} = attrs) when is_binary(fen),
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -31,12 +31,16 @@ defmodule ChesstrainerWeb.Layouts do
|
||||
default: nil,
|
||||
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
|
||||
|
||||
def app(assigns) do
|
||||
~H"""
|
||||
<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)}
|
||||
</div>
|
||||
</main>
|
||||
|
||||
@@ -2,7 +2,7 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
|
||||
use ChesstrainerWeb, :live_view
|
||||
|
||||
alias Chesstrainer.Repo
|
||||
alias Chesstrainer.Tags
|
||||
alias Chesstrainer.Themes
|
||||
alias Chesstrainer.FEN
|
||||
alias Chesstrainer.Endgames
|
||||
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>
|
||||
</.header>
|
||||
|
||||
<.form for={@form} id="endgame-form" phx-change="validate" phx-submit="save">
|
||||
<.input field={@form[:fen]} type="text" label="Fen" disabled={@live_action == :edit} />
|
||||
<.input field={@form[:color]} type="text" label="Color" disabled />
|
||||
<.input field={@form[:key]} type="text" label="Key" />
|
||||
<.input field={@form[:rating]} type="number" label="Rating" />
|
||||
<div class="field mb-6">
|
||||
<label class="label">
|
||||
<span class="label-text">Themes</span>
|
||||
</label>
|
||||
|
||||
<!-- ✅ TAG SELECTOR -->
|
||||
<div class="field">
|
||||
<label>Tags</label>
|
||||
|
||||
<!-- Search box -->
|
||||
<input
|
||||
type="text"
|
||||
name="tag_search"
|
||||
value={@tag_query}
|
||||
phx-change="search_tags"
|
||||
autocomplete="off"
|
||||
/>
|
||||
|
||||
<!-- Search results -->
|
||||
<ul class="tag-results">
|
||||
<%= for tag <- @tag_results do %>
|
||||
<li phx-click="add_tag" phx-value-id={tag.id}>
|
||||
{tag.name}
|
||||
</li>
|
||||
<% end %>
|
||||
|
||||
<%= if @tag_query != "" and @tag_results == [] do %>
|
||||
<li phx-click="create_tag" phx-value-name={@tag_query}>
|
||||
Create tag "{@tag_query}"
|
||||
</li>
|
||||
<% end %>
|
||||
</ul>
|
||||
|
||||
<!-- Selected tags -->
|
||||
<div class="selected-tags">
|
||||
<%= for tag <- @endgame.tags do %>
|
||||
<span class="tag">
|
||||
{tag.name}
|
||||
<button type="button" phx-click="remove_tag" phx-value-id={tag.id}>×</button>
|
||||
<div class="flex flex-wrap gap-2 mb-2">
|
||||
<%= for theme <- @selected_themes do %>
|
||||
<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>
|
||||
|
||||
<form
|
||||
id="theme-form"
|
||||
phx-change="search_themes"
|
||||
phx-submit="create_theme_from_search"
|
||||
>
|
||||
<input
|
||||
type="text"
|
||||
name="theme_search"
|
||||
value={@theme_query}
|
||||
phx-debounce="200"
|
||||
autocomplete="off"
|
||||
placeholder="Search or create a theme…"
|
||||
class="input input-bordered w-full"
|
||||
/>
|
||||
|
||||
<ul class="menu bg-base-100 rounded-box mt-2">
|
||||
<%= for theme <- @theme_results do %>
|
||||
<li>
|
||||
<button type="button" phx-click="add_theme" phx-value-id={theme.id}>{theme.name}</button>
|
||||
</li>
|
||||
<% end %>
|
||||
|
||||
<%= if @can_create do %>
|
||||
<li>
|
||||
<button type="button" phx-click="create_theme" phx-value-name={@theme_query}>
|
||||
Create theme "{String.trim(@theme_query)}"
|
||||
</button>
|
||||
</li>
|
||||
<% end %>
|
||||
</ul>
|
||||
</form>
|
||||
</div>
|
||||
|
||||
<.form for={@form} id="endgame-form" phx-change="validate" phx-submit="save">
|
||||
<.input field={@form[:fen]} type="text" label="Fen" disabled={@live_action == :edit} />
|
||||
<.input field={@form[:color]} type="text" label="Color" disabled />
|
||||
<.input field={@form[:rating]} type="number" label="Rating" />
|
||||
<.input field={@form[:message]} type="textarea" label="Message" />
|
||||
<.input field={@form[:notes]} type="textarea" label="Notes" />
|
||||
<.input
|
||||
@@ -94,14 +107,15 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
|
||||
defp return_to(_), do: "index"
|
||||
|
||||
defp apply_action(socket, :edit, %{"id" => id}) do
|
||||
endgame = Endgames.get_endgame!(id)
|
||||
endgame = Endgames.get_endgame!(id) |> Repo.preload(:themes)
|
||||
|
||||
socket
|
||||
|> assign(:page_title, "Edit Endgame")
|
||||
|> assign(:endgame, endgame)
|
||||
|> assign(:tag_query, "")
|
||||
|> assign(:tag_results, [])
|
||||
|> assign(:endgame, Repo.preload(endgame, :tags))
|
||||
|> assign(:selected_themes, endgame.themes)
|
||||
|> assign(:theme_query, "")
|
||||
|> assign(:theme_results, [])
|
||||
|> assign(:can_create, false)
|
||||
|> assign(:form, to_form(Endgames.change_endgame(endgame)))
|
||||
end
|
||||
|
||||
@@ -111,67 +125,46 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
|
||||
socket
|
||||
|> assign(:page_title, "New Endgame")
|
||||
|> assign(:endgame, endgame)
|
||||
|> assign(:tag_query, "")
|
||||
|> assign(:tag_results, [])
|
||||
|> assign(:endgame, Repo.preload(endgame, :tags))
|
||||
|> assign(:selected_themes, [])
|
||||
|> assign(:theme_query, "")
|
||||
|> assign(:theme_results, [])
|
||||
|> assign(:can_create, false)
|
||||
|> assign(:form, to_form(Endgames.change_endgame(endgame)))
|
||||
end
|
||||
|
||||
@impl true
|
||||
def handle_event("search_tags", %{"tag_search" => query}, socket) do
|
||||
tags = Tags.search(query, "endgame")
|
||||
|
||||
{:noreply,
|
||||
socket
|
||||
|> assign(:tag_query, query)
|
||||
|> assign(:tag_results, tags)}
|
||||
def handle_event("search_themes", %{"theme_search" => query}, socket) do
|
||||
{:noreply, assign_search(socket, query)}
|
||||
end
|
||||
|
||||
def handle_event("add_tag", %{"id" => id}, socket) do
|
||||
tag = Tags.get_tag!(id)
|
||||
{:ok, endgame} = Endgames.add_tag(socket.assigns.endgame, tag)
|
||||
|
||||
{:noreply,
|
||||
socket
|
||||
|> assign(:endgame, Repo.preload(endgame, :tags))
|
||||
|> assign(:tag_query, "")
|
||||
|> assign(:tag_results, [])}
|
||||
def handle_event("add_theme", %{"id" => id}, socket) do
|
||||
theme = Themes.get_theme!(id)
|
||||
{:noreply, socket |> add_selected_theme(theme) |> clear_search()}
|
||||
end
|
||||
|
||||
def handle_event("create_tag", %{"name" => name}, socket) do
|
||||
{:ok, tag} = Tags.get_or_create(name, "endgame")
|
||||
{:ok, endgame} = Endgames.add_tag(socket.assigns.endgame, tag)
|
||||
|
||||
{:noreply,
|
||||
socket
|
||||
|> assign(:endgame, Repo.preload(endgame, :tags))
|
||||
|> assign(:tag_query, "")
|
||||
|> assign(:tag_results, [])}
|
||||
def handle_event("create_theme", %{"name" => name}, socket) do
|
||||
{:noreply, create_theme(socket, name)}
|
||||
end
|
||||
|
||||
def handle_event("remove_tag", %{"id" => id}, socket) do
|
||||
tag = Tags.get_tag!(id)
|
||||
{:ok, endgame} = Endgames.remove_tag(socket.assigns.endgame, tag)
|
||||
def handle_event("create_theme_from_search", %{"theme_search" => name}, socket) do
|
||||
{:noreply, create_theme(socket, name)}
|
||||
end
|
||||
|
||||
{:noreply,
|
||||
socket
|
||||
|> assign(:endgame, Repo.preload(endgame, :tags))}
|
||||
def handle_event("remove_theme", %{"id" => id}, socket) do
|
||||
selected = Enum.reject(socket.assigns.selected_themes, &(Integer.to_string(&1.id) == id))
|
||||
{:noreply, assign(socket, :selected_themes, selected)}
|
||||
end
|
||||
|
||||
def handle_event("validate", %{"endgame" => endgame_params}, socket) do
|
||||
# Compute color from the incoming FEN
|
||||
color = FEN.color_from_fen(endgame_params["fen"])
|
||||
fen = endgame_params["fen"] || socket.assigns.endgame.fen
|
||||
color = FEN.color_from_fen(fen)
|
||||
|
||||
# Update the struct
|
||||
endgame = %{socket.assigns.endgame | color: color}
|
||||
|
||||
# Build the changeset *from the updated struct*
|
||||
changeset =
|
||||
endgame
|
||||
|> Endgames.change_endgame()
|
||||
socket.assigns.endgame
|
||||
|> Endgames.change_endgame(endgame_params)
|
||||
|> 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
|
||||
|
||||
def handle_event("save", %{"endgame" => endgame_params}, socket) do
|
||||
@@ -179,7 +172,11 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
|
||||
end
|
||||
|
||||
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} ->
|
||||
{:noreply,
|
||||
socket
|
||||
@@ -195,7 +192,7 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
|
||||
color = FEN.color_from_fen(endgame_params["fen"])
|
||||
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} ->
|
||||
{:noreply,
|
||||
socket
|
||||
@@ -207,6 +204,46 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
|
||||
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("show", endgame), do: ~p"/admin/endgames/#{endgame}"
|
||||
end
|
||||
|
||||
@@ -3,10 +3,12 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
|
||||
|
||||
alias Chesstrainer.Endgames
|
||||
|
||||
import ChesstrainerWeb.EndgameList
|
||||
|
||||
@impl true
|
||||
def render(assigns) do
|
||||
~H"""
|
||||
<Layouts.app flash={@flash}>
|
||||
<Layouts.app flash={@flash} wide>
|
||||
<.header>
|
||||
Listing Endgames
|
||||
<:actions>
|
||||
@@ -16,36 +18,68 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
|
||||
</:actions>
|
||||
</.header>
|
||||
|
||||
<.table
|
||||
id="endgames"
|
||||
rows={@streams.endgames}
|
||||
row_click={fn {_id, endgame} -> JS.navigate(~p"/admin/endgames/#{endgame}") end}
|
||||
>
|
||||
<:col :let={{_id, endgame}} label="Fen">{endgame.fen}</:col>
|
||||
<: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>
|
||||
<:col :let={{_id, endgame}} label="Message">{endgame.message}</:col>
|
||||
<:col :let={{_id, endgame}} label="Notes">{endgame.notes}</:col>
|
||||
<:col :let={{_id, endgame}} label="Result">{endgame.result}</:col>
|
||||
<:col :let={{_id, endgame}} label="Attempted">{endgame.times_attempted}</:col>
|
||||
<:col :let={{_id, endgame}} label="Solved">{endgame.times_solved}</:col>
|
||||
<:action :let={{_id, endgame}}>
|
||||
<div class="sr-only">
|
||||
<.filter_bar
|
||||
selected_themes={@selected_themes}
|
||||
theme_query={@theme_query}
|
||||
theme_results={@theme_results}
|
||||
keys={@keys}
|
||||
selected_key={@selected_key}
|
||||
/>
|
||||
|
||||
<.grouped_list :if={@groups != []} groups={@groups}>
|
||||
<:header>
|
||||
<tr>
|
||||
<th>Key</th>
|
||||
<th>Color</th>
|
||||
<th>Result</th>
|
||||
<th>Themes</th>
|
||||
<th>Rating</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"/admin/endgames/#{endgame}")} class="hover:cursor-pointer">
|
||||
{endgame.key}
|
||||
</td>
|
||||
<td phx-click={JS.navigate(~p"/admin/endgames/#{endgame}")} class="hover:cursor-pointer">
|
||||
{endgame.color}
|
||||
</td>
|
||||
<td phx-click={JS.navigate(~p"/admin/endgames/#{endgame}")} class="hover:cursor-pointer">
|
||||
{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>
|
||||
</div>
|
||||
<.link navigate={~p"/endgames/#{endgame}/play"}>Play</.link>
|
||||
<.link navigate={~p"/admin/endgames/#{endgame}/edit"}>Edit</.link>
|
||||
</:action>
|
||||
<:action :let={{id, endgame}}>
|
||||
<.link
|
||||
phx-click={JS.push("delete", value: %{id: endgame.id}) |> hide("##{id}")}
|
||||
phx-click={JS.push("delete", value: %{id: endgame.id})}
|
||||
data-confirm="Are you sure?"
|
||||
>
|
||||
Delete
|
||||
</.link>
|
||||
</:action>
|
||||
</.table>
|
||||
</div>
|
||||
</td>
|
||||
</tr>
|
||||
</:row>
|
||||
</.grouped_list>
|
||||
|
||||
<p :if={@groups == []} class="text-base-content/70">
|
||||
No endgames match these filters.
|
||||
</p>
|
||||
</Layouts.app>
|
||||
"""
|
||||
end
|
||||
@@ -55,7 +89,7 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
|
||||
{:ok,
|
||||
socket
|
||||
|> assign(:page_title, "Listing Endgames")
|
||||
|> stream(:endgames, list_endgames())}
|
||||
|> init_state()}
|
||||
end
|
||||
|
||||
@impl true
|
||||
@@ -63,10 +97,10 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
|
||||
endgame = Endgames.get_endgame!(id)
|
||||
{:ok, _} = Endgames.delete_endgame(endgame)
|
||||
|
||||
{:noreply, stream_delete(socket, :endgames, endgame)}
|
||||
{:noreply, refresh(socket)}
|
||||
end
|
||||
|
||||
defp list_endgames() do
|
||||
Endgames.list_endgames()
|
||||
def handle_event(event, params, socket) do
|
||||
handle_filter_event(event, params, socket)
|
||||
end
|
||||
end
|
||||
|
||||
@@ -40,10 +40,16 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|
||||
<p class="font-semibold text-red-600">Tablebase unavailable</p>
|
||||
<p class="text-red-500">{@blocked_reason}</p>
|
||||
<% @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 -> %>
|
||||
<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 %>
|
||||
<p class="text-gray-600">Best was: {@best_move}</p>
|
||||
<% end %>
|
||||
@@ -119,6 +125,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|
||||
def handle_event("endgame_move_played", params, socket) do
|
||||
%{"from" => from, "to" => to, "san" => san} = params
|
||||
promotion = params["promotion"]
|
||||
draw = params["draw"] || false
|
||||
prev_fen = params["prev_fen"] || socket.assigns.fen
|
||||
fen_after = params["fen"] || socket.assigns.fen
|
||||
|
||||
@@ -135,12 +142,22 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|
||||
put_flash(socket, :error, "That move is out of sequence. Press Reset to try again.")}
|
||||
|
||||
true ->
|
||||
grade_and_record(socket, from, to, promotion, san, fen_after)
|
||||
grade_and_record(socket, from, to, promotion, san, fen_after, draw)
|
||||
end
|
||||
end
|
||||
|
||||
def handle_event("opponent_reply_applied", %{"fen" => fen}, socket) do
|
||||
if socket.assigns.awaiting_reply do
|
||||
def handle_event("opponent_reply_applied", params, socket) do
|
||||
%{"fen" => fen} = params
|
||||
draw = params["draw"] || false
|
||||
|
||||
cond do
|
||||
not socket.assigns.awaiting_reply ->
|
||||
{:noreply, socket}
|
||||
|
||||
draw and socket.assigns.endgame.result == :draw ->
|
||||
solve_attempt(socket)
|
||||
|
||||
true ->
|
||||
case Tablebase.new(fen) do
|
||||
{:ok, tablebase} ->
|
||||
{:noreply,
|
||||
@@ -159,8 +176,6 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|
||||
|> assign(:status, :blocked)
|
||||
|> assign(:blocked_reason, blocked_reason(other))}
|
||||
end
|
||||
else
|
||||
{:noreply, socket}
|
||||
end
|
||||
end
|
||||
|
||||
@@ -251,7 +266,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|
||||
"The tablebase is unavailable (#{inspect(reason)})."
|
||||
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
|
||||
nil ->
|
||||
{:noreply, put_flash(socket, :error, "Could not identify that move in the tablebase.")}
|
||||
@@ -270,11 +285,17 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|
||||
grade == :losing ->
|
||||
fail_attempt(socket)
|
||||
|
||||
grade in [:optimal, :winning] and not is_nil(promotion) ->
|
||||
# Conversion cutoff: a promotion that keeps the win ends the puzzle.
|
||||
grade not in [:optimal, :winning] ->
|
||||
{:noreply, socket}
|
||||
|
||||
draw and socket.assigns.endgame.result == :draw ->
|
||||
# A drawn-by-rule position is the goal of a draw puzzle.
|
||||
solve_attempt(socket)
|
||||
|
||||
socket.assigns.endgame.result == :win and not is_nil(promotion) ->
|
||||
# Conversion cutoff: a promotion that keeps the win ends a win puzzle.
|
||||
solve_attempt(socket)
|
||||
|
||||
grade in [:optimal, :winning] and
|
||||
not same_position?(fen_after, socket.assigns.fen) ->
|
||||
start_opponent_reply(socket, fen_after)
|
||||
|
||||
|
||||
@@ -1,29 +1,65 @@
|
||||
defmodule ChesstrainerWeb.EndgameLive.PlayerIndex do
|
||||
use ChesstrainerWeb, :live_view
|
||||
|
||||
alias Chesstrainer.Endgames
|
||||
import ChesstrainerWeb.EndgameList
|
||||
|
||||
@impl true
|
||||
def render(assigns) do
|
||||
~H"""
|
||||
<Layouts.app flash={@flash}>
|
||||
<Layouts.app flash={@flash} wide>
|
||||
<.header>
|
||||
Endgames
|
||||
<:subtitle>Pick an endgame to play.</:subtitle>
|
||||
</.header>
|
||||
|
||||
<.table
|
||||
id="player-endgames"
|
||||
rows={@streams.endgames}
|
||||
>
|
||||
<:col :let={{_id, endgame}} label="Key">{endgame.key}</:col>
|
||||
<:col :let={{_id, endgame}} label="Color">{endgame.color}</:col>
|
||||
<:col :let={{_id, endgame}} label="Result">{endgame.result}</:col>
|
||||
<:col :let={{_id, endgame}} label="Rating">{endgame.rating}</:col>
|
||||
<:action :let={{_id, endgame}}>
|
||||
<.filter_bar
|
||||
selected_themes={@selected_themes}
|
||||
theme_query={@theme_query}
|
||||
theme_results={@theme_results}
|
||||
keys={@keys}
|
||||
selected_key={@selected_key}
|
||||
/>
|
||||
|
||||
<.grouped_list :if={@groups != []} groups={@groups}>
|
||||
<:header>
|
||||
<tr>
|
||||
<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>
|
||||
</:action>
|
||||
</.table>
|
||||
</td>
|
||||
</tr>
|
||||
</:row>
|
||||
</.grouped_list>
|
||||
|
||||
<p :if={@groups == []} class="text-base-content/70">
|
||||
No endgames match these filters.
|
||||
</p>
|
||||
</Layouts.app>
|
||||
"""
|
||||
end
|
||||
@@ -33,6 +69,11 @@ defmodule ChesstrainerWeb.EndgameLive.PlayerIndex do
|
||||
{:ok,
|
||||
socket
|
||||
|> 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
|
||||
|
||||
@@ -3,6 +3,8 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
|
||||
|
||||
alias Chesstrainer.Endgames
|
||||
alias Chesstrainer.Game
|
||||
alias Chesstrainer.Repo
|
||||
alias Chesstrainer.Themes
|
||||
|
||||
import ChesstrainerWeb.Board.BoardComponent
|
||||
|
||||
@@ -23,7 +25,7 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
|
||||
|> assign(:game_type, :endgame)
|
||||
|
||||
~H"""
|
||||
<Layouts.app flash={@flash}>
|
||||
<Layouts.app flash={@flash} wide>
|
||||
<.header>
|
||||
Endgame {@endgame.id}
|
||||
<: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="Notes">{@endgame.notes}</: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="Solved">{@endgame.times_solved}</:item>
|
||||
</.list>
|
||||
@@ -62,6 +65,6 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
|
||||
{:ok,
|
||||
socket
|
||||
|> assign(:page_title, "Show Endgame")
|
||||
|> assign(:endgame, Endgames.get_endgame!(id))}
|
||||
|> assign(:endgame, Endgames.get_endgame!(id) |> Repo.preload(:themes))}
|
||||
end
|
||||
end
|
||||
|
||||
+3
-3
@@ -1,14 +1,14 @@
|
||||
defmodule Chesstrainer.Repo.Migrations.CreateTags do
|
||||
defmodule Chesstrainer.Repo.Migrations.CreateThemes do
|
||||
use Ecto.Migration
|
||||
|
||||
def change do
|
||||
create table(:tags) do
|
||||
create table(:themes) do
|
||||
add :name, :string
|
||||
add :category, :string
|
||||
|
||||
timestamps(type: :utc_datetime)
|
||||
end
|
||||
|
||||
create unique_index(:tags, [:name, :category])
|
||||
create unique_index(:themes, [:name, :category])
|
||||
end
|
||||
end
|
||||
@@ -19,5 +19,6 @@ defmodule Chesstrainer.Repo.Migrations.CreateEndgames do
|
||||
end
|
||||
|
||||
create unique_index(:endgames, [:fen])
|
||||
create index(:endgames, [:key])
|
||||
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
@@ -12,54 +12,62 @@
|
||||
|
||||
alias Chesstrainer.Repo
|
||||
alias Chesstrainer.Endgames.Endgame
|
||||
alias Chesstrainer.Tags.Tag
|
||||
alias Chesstrainer.Themes.Theme
|
||||
|
||||
now = DateTime.utc_now() |> DateTime.truncate(:second)
|
||||
|
||||
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",
|
||||
color: :white,
|
||||
key: "KR v K",
|
||||
message: "Rook vs king endgame",
|
||||
notes: "Basic rook endgame",
|
||||
result: :win,
|
||||
inserted_at: now,
|
||||
updated_at: now
|
||||
result: :win
|
||||
},
|
||||
%{
|
||||
id: Ecto.UUID.generate(),
|
||||
fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1",
|
||||
color: :black,
|
||||
key: "KPPP v KPP",
|
||||
message: "3 pawns vs 2 pawns",
|
||||
notes: "https://www.chessgames.com/perl/chessgame?gid=1017147",
|
||||
result: :win,
|
||||
inserted_at: now,
|
||||
updated_at: now
|
||||
result: :win
|
||||
}
|
||||
])
|
||||
]
|
||||
|
||||
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("🌱 Seeding endgame tags into DB...")
|
||||
IO.puts("🌱 Seeding endgame themes into DB...")
|
||||
|
||||
Repo.insert_all(Tag, [
|
||||
%{
|
||||
name: "mate in 2",
|
||||
category: :endgame,
|
||||
inserted_at: now,
|
||||
updated_at: now
|
||||
},
|
||||
%{
|
||||
name: "mate in 3",
|
||||
category: :endgame,
|
||||
inserted_at: now,
|
||||
updated_at: now
|
||||
}
|
||||
])
|
||||
theme_names = [
|
||||
"mate in 2",
|
||||
"mate in 3",
|
||||
"Lucena",
|
||||
"Philidor",
|
||||
"opposition",
|
||||
"promotion",
|
||||
"stalemate"
|
||||
]
|
||||
|
||||
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.")
|
||||
|
||||
@@ -3,25 +3,60 @@ defmodule Chesstrainer.EndgamesTest do
|
||||
|
||||
alias Chesstrainer.Endgames
|
||||
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
|
||||
test "accepts a standard valid FEN" do
|
||||
test "accepts a standard valid FEN and derives its key" do
|
||||
attrs = %{
|
||||
fen: "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1",
|
||||
color: :white,
|
||||
key: "KR v K",
|
||||
result: :win,
|
||||
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
|
||||
|
||||
test "normalizes fullmove 0 to 1 before inserting" do
|
||||
attrs = %{
|
||||
fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 0",
|
||||
color: :black,
|
||||
key: "KPPP v KPP",
|
||||
result: :win,
|
||||
rating: 1500
|
||||
}
|
||||
@@ -34,7 +69,6 @@ defmodule Chesstrainer.EndgamesTest do
|
||||
attrs = %{
|
||||
fen: " 8/8/3k4/8/8/3K1R2/8/8 w - - 0 1\t\n",
|
||||
color: :white,
|
||||
key: "KR v K",
|
||||
result: :win,
|
||||
rating: 1500
|
||||
}
|
||||
@@ -47,7 +81,6 @@ defmodule Chesstrainer.EndgamesTest do
|
||||
attrs = %{
|
||||
fen: "4k3/8/8/8/8/8/8/0K7 w - - 0 1",
|
||||
color: :white,
|
||||
key: "KQ v K",
|
||||
result: :win,
|
||||
rating: 1500
|
||||
}
|
||||
@@ -61,7 +94,6 @@ defmodule Chesstrainer.EndgamesTest do
|
||||
attrs = %{
|
||||
fen: "8/8/3k4/8/8/3K1R2/8/8",
|
||||
color: :white,
|
||||
key: "KQ v K",
|
||||
result: :win,
|
||||
rating: 1500
|
||||
}
|
||||
@@ -75,7 +107,6 @@ defmodule Chesstrainer.EndgamesTest do
|
||||
attrs = %{
|
||||
fen: "8/8/3k4/8/8/3K1R2/8/8 x - - 0 1",
|
||||
color: :white,
|
||||
key: "KQ v K",
|
||||
result: :win,
|
||||
rating: 1500
|
||||
}
|
||||
@@ -85,4 +116,82 @@ defmodule Chesstrainer.EndgamesTest do
|
||||
assert msg =~ "active color"
|
||||
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
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
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
|
||||
render_hook(view, "endgame_move_played", %{
|
||||
"from" => from,
|
||||
@@ -71,7 +78,14 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
|
||||
end
|
||||
|
||||
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)
|
||||
|
||||
{: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 =~ "White to move"
|
||||
assert html =~ "1800"
|
||||
assert html =~ "max-w-2xl"
|
||||
end
|
||||
|
||||
test "raises when the endgame does not exist", %{conn: conn} do
|
||||
@@ -294,6 +309,112 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
|
||||
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
|
||||
test "clears the move list and grade, and re-pushes init_board", %{conn: conn} do
|
||||
endgame = endgame_fixture()
|
||||
|
||||
@@ -3,18 +3,47 @@ defmodule ChesstrainerWeb.EndgameLive.PlayerIndexTest do
|
||||
|
||||
import Phoenix.LiveViewTest
|
||||
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()
|
||||
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 =~ endgame.key
|
||||
assert html =~ other.key
|
||||
assert html =~ "max-w-7xl"
|
||||
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/#{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
|
||||
|
||||
test "navigating to a play page renders the board", %{conn: conn} do
|
||||
|
||||
@@ -24,15 +24,13 @@ defmodule Chesstrainer.EndgamesFixtures do
|
||||
@doc """
|
||||
Generate an endgame.
|
||||
|
||||
A simple K v K position with a unique FEN, color,
|
||||
key, rating, and result.
|
||||
A simple K v K position with a unique FEN, color, rating, and result.
|
||||
"""
|
||||
def endgame_fixture(attrs \\ %{}) do
|
||||
{:ok, endgame} =
|
||||
attrs
|
||||
|> Enum.into(%{
|
||||
fen: unique_endgame_fen(),
|
||||
key: "KQ v K",
|
||||
color: :white,
|
||||
result: :win,
|
||||
rating: 1500
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user