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
This commit is contained in:
2026-11-02 09:14:17 +01:00
parent 645f65f2a3
commit cd2e7f0164
21 changed files with 387 additions and 382 deletions
+5 -5
View File
@@ -49,10 +49,10 @@ defmodule Chesstrainer.Endgames do
{:error, %Ecto.Changeset{}} {:error, %Ecto.Changeset{}}
""" """
def create_endgame(attrs, tags \\ []) do def create_endgame(attrs, themes \\ []) do
%Endgame{} %Endgame{}
|> Endgame.changeset(attrs) |> Endgame.changeset(attrs)
|> Ecto.Changeset.put_assoc(:tags, tags) |> Ecto.Changeset.put_assoc(:themes, themes)
|> Repo.insert() |> Repo.insert()
end end
@@ -68,14 +68,14 @@ defmodule Chesstrainer.Endgames do
{:error, %Ecto.Changeset{}} {:error, %Ecto.Changeset{}}
""" """
def update_endgame(%Endgame{} = endgame, attrs, tags \\ []) 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(:tags) |> Repo.preload(:themes)
|> Endgame.changeset(attrs) |> Endgame.changeset(attrs)
|> Ecto.Changeset.put_assoc(:tags, tags) |> Ecto.Changeset.put_assoc(:themes, themes)
|> Repo.update() |> Repo.update()
end end
+2 -2
View File
@@ -20,8 +20,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)
-156
View File
@@ -1,156 +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
case String.trim(query) do
"" ->
[]
query ->
pattern = "%#{query}%"
Tag
|> 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 tag 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_tag(%{name: name, category: category})
tag -> {:ok, tag}
end
end
end
defp find_by_name(name, category) do
downcased = String.downcase(name)
Repo.one(
from t in Tag,
where: t.category == ^category and fragment("lower(?)", t.name) == ^downcased,
limit: 1
)
end
@doc """
Returns the names of the given tags, sorted.
"""
def names(tags) when is_list(tags) do
tags |> Enum.map(& &1.name) |> Enum.sort()
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
@@ -1,8 +1,8 @@
defmodule Chesstrainer.Tags.Tag do defmodule Chesstrainer.Themes.Theme do
use Ecto.Schema use Ecto.Schema
import Ecto.Changeset import Ecto.Changeset
schema "tags" do schema "themes" do
field :name, :string field :name, :string
field :category, Ecto.Enum, values: [endgame: "endgame", opening: "opening", tactic: "tactic"] field :category, Ecto.Enum, values: [endgame: "endgame", opening: "opening", tactic: "tactic"]
@@ -10,8 +10,8 @@ defmodule Chesstrainer.Tags.Tag do
end end
@doc false @doc false
def changeset(tag, attrs) do def changeset(theme, attrs) do
tag theme
|> cast(attrs, [:name, :category]) |> cast(attrs, [:name, :category])
|> update_change(:name, fn |> update_change(:name, fn
name when is_binary(name) -> String.trim(name) name when is_binary(name) -> String.trim(name)
@@ -19,6 +19,9 @@ defmodule Chesstrainer.Tags.Tag do
end) end)
|> validate_required([:name, :category]) |> validate_required([:name, :category])
|> validate_length(:name, min: 1, max: 60) |> validate_length(:name, min: 1, max: 60)
|> unique_constraint(:name, name: :tags_name_category_lower_index, message: "already exists") |> unique_constraint(:name,
name: :themes_name_category_lower_index,
message: "already exists"
)
end end
end end
+42 -42
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
@@ -22,14 +22,14 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
</label> </label>
<div class="flex flex-wrap gap-2 mb-2"> <div class="flex flex-wrap gap-2 mb-2">
<%= for tag <- @selected_tags do %> <%= for theme <- @selected_themes do %>
<span class="badge badge-primary gap-1"> <span class="badge badge-primary gap-1">
{tag.name} {theme.name}
<button <button
type="button" type="button"
phx-click="remove_tag" phx-click="remove_theme"
phx-value-id={tag.id} phx-value-id={theme.id}
aria-label={"Remove #{tag.name}"} aria-label={"Remove #{theme.name}"}
> >
× ×
</button> </button>
@@ -39,13 +39,13 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
<form <form
id="theme-form" id="theme-form"
phx-change="search_tags" phx-change="search_themes"
phx-submit="create_tag_from_search" 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-debounce="200" phx-debounce="200"
autocomplete="off" autocomplete="off"
placeholder="Search or create a theme…" placeholder="Search or create a theme…"
@@ -53,16 +53,16 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
/> />
<ul class="menu bg-base-100 rounded-box mt-2"> <ul class="menu bg-base-100 rounded-box mt-2">
<%= for tag <- @tag_results do %> <%= for theme <- @theme_results do %>
<li> <li>
<button type="button" phx-click="add_tag" phx-value-id={tag.id}>{tag.name}</button> <button type="button" phx-click="add_theme" phx-value-id={theme.id}>{theme.name}</button>
</li> </li>
<% end %> <% end %>
<%= if @can_create do %> <%= if @can_create do %>
<li> <li>
<button type="button" phx-click="create_tag" phx-value-name={@tag_query}> <button type="button" phx-click="create_theme" phx-value-name={@theme_query}>
Create theme "{String.trim(@tag_query)}" Create theme "{String.trim(@theme_query)}"
</button> </button>
</li> </li>
<% end %> <% end %>
@@ -108,14 +108,14 @@ 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) |> Repo.preload(:tags) 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(:selected_tags, endgame.tags) |> assign(:selected_themes, endgame.themes)
|> assign(:tag_query, "") |> assign(:theme_query, "")
|> assign(:tag_results, []) |> assign(:theme_results, [])
|> assign(:can_create, false) |> assign(:can_create, false)
|> assign(:form, to_form(Endgames.change_endgame(endgame))) |> assign(:form, to_form(Endgames.change_endgame(endgame)))
end end
@@ -126,34 +126,34 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
socket socket
|> assign(:page_title, "New Endgame") |> assign(:page_title, "New Endgame")
|> assign(:endgame, endgame) |> assign(:endgame, endgame)
|> assign(:selected_tags, []) |> assign(:selected_themes, [])
|> assign(:tag_query, "") |> assign(:theme_query, "")
|> assign(:tag_results, []) |> assign(:theme_results, [])
|> assign(:can_create, false) |> 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
{:noreply, assign_search(socket, query)} {:noreply, assign_search(socket, query)}
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)
{:noreply, socket |> add_selected_tag(tag) |> clear_search()} {:noreply, socket |> add_selected_theme(theme) |> clear_search()}
end end
def handle_event("create_tag", %{"name" => name}, socket) do def handle_event("create_theme", %{"name" => name}, socket) do
{:noreply, create_theme(socket, name)} {:noreply, create_theme(socket, name)}
end end
def handle_event("create_tag_from_search", %{"tag_search" => name}, socket) do def handle_event("create_theme_from_search", %{"theme_search" => name}, socket) do
{:noreply, create_theme(socket, name)} {:noreply, create_theme(socket, name)}
end end
def handle_event("remove_tag", %{"id" => id}, socket) do def handle_event("remove_theme", %{"id" => id}, socket) do
selected = Enum.reject(socket.assigns.selected_tags, &(Integer.to_string(&1.id) == id)) selected = Enum.reject(socket.assigns.selected_themes, &(Integer.to_string(&1.id) == id))
{:noreply, assign(socket, :selected_tags, selected)} {: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
@@ -176,7 +176,7 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
case Endgames.update_endgame( case Endgames.update_endgame(
socket.assigns.endgame, socket.assigns.endgame,
endgame_params, endgame_params,
socket.assigns.selected_tags socket.assigns.selected_themes
) do ) do
{:ok, endgame} -> {:ok, endgame} ->
{:noreply, {:noreply,
@@ -193,7 +193,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, socket.assigns.selected_tags) do case Endgames.create_endgame(params, socket.assigns.selected_themes) do
{:ok, endgame} -> {:ok, endgame} ->
{:noreply, {:noreply,
socket socket
@@ -207,15 +207,15 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
defp assign_search(socket, query) do defp assign_search(socket, query) do
trimmed = String.trim(query) trimmed = String.trim(query)
results = Tags.search(query, "endgame") results = Themes.search(query, "endgame")
can_create = can_create =
trimmed != "" and trimmed != "" and
not Enum.any?(results, &(String.downcase(&1.name) == String.downcase(trimmed))) not Enum.any?(results, &(String.downcase(&1.name) == String.downcase(trimmed)))
socket socket
|> assign(:tag_query, query) |> assign(:theme_query, query)
|> assign(:tag_results, results) |> assign(:theme_results, results)
|> assign(:can_create, can_create) |> assign(:can_create, can_create)
end end
@@ -223,8 +223,8 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
if String.trim(name) == "" do if String.trim(name) == "" do
socket socket
else else
case Tags.get_or_create(name, "endgame") do case Themes.get_or_create(name, "endgame") do
{:ok, tag} -> socket |> add_selected_tag(tag) |> clear_search() {:ok, theme} -> socket |> add_selected_theme(theme) |> clear_search()
{:error, _reason} -> put_flash(socket, :error, "Could not create that theme.") {:error, _reason} -> put_flash(socket, :error, "Could not create that theme.")
end end
end end
@@ -232,16 +232,16 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
defp clear_search(socket) do defp clear_search(socket) do
socket socket
|> assign(:tag_query, "") |> assign(:theme_query, "")
|> assign(:tag_results, []) |> assign(:theme_results, [])
|> assign(:can_create, false) |> assign(:can_create, false)
end end
defp add_selected_tag(socket, tag) do defp add_selected_theme(socket, theme) do
if Enum.any?(socket.assigns.selected_tags, &(&1.id == tag.id)) do if Enum.any?(socket.assigns.selected_themes, &(&1.id == theme.id)) do
socket socket
else else
assign(socket, :selected_tags, socket.assigns.selected_tags ++ [tag]) assign(socket, :selected_themes, socket.assigns.selected_themes ++ [theme])
end end
end end
@@ -3,7 +3,7 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Repo alias Chesstrainer.Repo
alias Chesstrainer.Tags alias Chesstrainer.Themes
@impl true @impl true
def render(assigns) do def render(assigns) do
@@ -31,7 +31,7 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
<:col :let={{_id, endgame}} label="Notes">{endgame.notes}</:col> <:col :let={{_id, endgame}} label="Notes">{endgame.notes}</:col>
<:col :let={{_id, endgame}} label="Result">{endgame.result}</:col> <:col :let={{_id, endgame}} label="Result">{endgame.result}</:col>
<:col :let={{_id, endgame}} label="Themes"> <:col :let={{_id, endgame}} label="Themes">
{Enum.join(Tags.names(endgame.tags), ", ")} {Enum.join(Themes.names(endgame.themes), ", ")}
</:col> </:col>
<:col :let={{_id, endgame}} label="Attempted">{endgame.times_attempted}</:col> <:col :let={{_id, endgame}} label="Attempted">{endgame.times_attempted}</:col>
<:col :let={{_id, endgame}} label="Solved">{endgame.times_solved}</:col> <:col :let={{_id, endgame}} label="Solved">{endgame.times_solved}</:col>
@@ -72,6 +72,6 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
end end
defp list_endgames() do defp list_endgames() do
Endgames.list_endgames() |> Repo.preload(:tags) Endgames.list_endgames() |> Repo.preload(:themes)
end end
end end
@@ -4,7 +4,7 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Game alias Chesstrainer.Game
alias Chesstrainer.Repo alias Chesstrainer.Repo
alias Chesstrainer.Tags alias Chesstrainer.Themes
import ChesstrainerWeb.Board.BoardComponent import ChesstrainerWeb.Board.BoardComponent
@@ -52,7 +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(Tags.names(@endgame.tags), ", ")}</: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>
@@ -65,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) |> Repo.preload(:tags))} |> 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
@@ -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
@@ -1,15 +0,0 @@
defmodule Chesstrainer.Repo.Migrations.CaseInsensitiveTagNames do
use Ecto.Migration
def up do
drop index(:tags, [:name, :category])
create unique_index(:tags, ["lower(name)", :category], name: :tags_name_category_lower_index)
end
def down do
drop index(:tags, ["lower(name)", :category], name: :tags_name_category_lower_index)
create unique_index(:tags, [:name, :category])
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
+4 -4
View File
@@ -12,7 +12,7 @@
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)
@@ -49,7 +49,7 @@ Repo.insert_all(
IO.puts("✅ Done seeding endgames.") IO.puts("✅ Done seeding endgames.")
IO.puts("🌱 Seeding endgame tags into DB...") IO.puts("🌱 Seeding endgame themes into DB...")
theme_names = [ theme_names = [
"mate in 2", "mate in 2",
@@ -62,11 +62,11 @@ theme_names = [
] ]
Repo.insert_all( Repo.insert_all(
Tag, Theme,
Enum.map(theme_names, fn name -> Enum.map(theme_names, fn name ->
%{name: name, category: :endgame, inserted_at: now, updated_at: now} %{name: name, category: :endgame, inserted_at: now, updated_at: now}
end), end),
on_conflict: :nothing on_conflict: :nothing
) )
IO.puts("✅ Done seeding endgame tags.") IO.puts("✅ Done seeding endgame themes.")
+8 -8
View File
@@ -3,7 +3,7 @@ defmodule Chesstrainer.EndgamesTest do
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Endgames.Endgame alias Chesstrainer.Endgames.Endgame
alias Chesstrainer.Tags alias Chesstrainer.Themes
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" do
@@ -87,9 +87,9 @@ defmodule Chesstrainer.EndgamesTest do
end end
end end
describe "tags" do describe "themes" do
test "create_endgame/2 associates themes" do test "create_endgame/2 associates themes" do
{:ok, tag} = Tags.create_tag(%{name: "Lucena", category: :endgame}) {:ok, theme} = Themes.create_theme(%{name: "Lucena", category: :endgame})
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",
@@ -99,13 +99,13 @@ defmodule Chesstrainer.EndgamesTest do
rating: 1500 rating: 1500
} }
assert {:ok, endgame} = Endgames.create_endgame(attrs, [tag]) assert {:ok, endgame} = Endgames.create_endgame(attrs, [theme])
assert Enum.map(endgame.tags, & &1.id) == [tag.id] assert Enum.map(endgame.themes, & &1.id) == [theme.id]
end end
test "update_endgame/3 replaces themes" do test "update_endgame/3 replaces themes" do
{:ok, lucena} = Tags.create_tag(%{name: "Lucena", category: :endgame}) {:ok, lucena} = Themes.create_theme(%{name: "Lucena", category: :endgame})
{:ok, philidor} = Tags.create_tag(%{name: "Philidor", category: :endgame}) {:ok, philidor} = Themes.create_theme(%{name: "Philidor", category: :endgame})
attrs = %{ attrs = %{
fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1", fen: "6k1/5p2/6p1/8/7p/8/6PP/6K1 b - - 0 1",
@@ -117,7 +117,7 @@ defmodule Chesstrainer.EndgamesTest do
assert {:ok, endgame} = Endgames.create_endgame(attrs, [lucena]) assert {:ok, endgame} = Endgames.create_endgame(attrs, [lucena])
assert {:ok, updated} = Endgames.update_endgame(endgame, %{rating: 1600}, [philidor]) assert {:ok, updated} = Endgames.update_endgame(endgame, %{rating: 1600}, [philidor])
assert Enum.map(updated.tags, & &1.id) == [philidor.id] assert Enum.map(updated.themes, & &1.id) == [philidor.id]
end end
end end
end end
-79
View File
@@ -1,79 +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
test "get_or_create/2 matches case-insensitively and trims" do
assert {:ok, tag} = Tags.get_or_create("Lucena", "endgame")
assert {:ok, found} = Tags.get_or_create(" lucena ", "endgame")
assert found.id == tag.id
assert length(Tags.list_tags()) == 1
end
test "get_or_create/2 rejects a blank name" do
assert {:error, :blank_name} = Tags.get_or_create(" ", "endgame")
end
test "create_tag/1 rejects a case-insensitive duplicate" do
assert {:ok, _tag} = Tags.create_tag(%{name: "Lucena", category: :endgame})
assert {:error, changeset} = Tags.create_tag(%{name: "lucena", category: :endgame})
assert changeset.errors[:name]
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
@@ -2,20 +2,20 @@ defmodule ChesstrainerWeb.EndgameLive.FormTest do
use ChesstrainerWeb.ConnCase use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest import Phoenix.LiveViewTest
import Chesstrainer.TagsFixtures import Chesstrainer.ThemesFixtures
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
alias Chesstrainer.Repo alias Chesstrainer.Repo
alias Chesstrainer.Tags alias Chesstrainer.Themes
@fen "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1" @fen "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
test "creates an endgame with staged themes", %{conn: conn} do test "creates an endgame with staged themes", %{conn: conn} do
tag = tag_fixture(%{name: "Lucena"}) theme = theme_fixture(%{name: "Lucena"})
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new") {:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
view |> form("#theme-form", %{tag_search: "Luc"}) |> render_change() view |> form("#theme-form", %{theme_search: "Luc"}) |> render_change()
view |> element("button", "Lucena") |> render_click() view |> element("button", "Lucena") |> render_click()
view view
@@ -29,21 +29,21 @@ defmodule ChesstrainerWeb.EndgameLive.FormTest do
endgame = endgame =
Endgames.list_endgames() Endgames.list_endgames()
|> Enum.find(&(&1.fen == @fen)) |> Enum.find(&(&1.fen == @fen))
|> Repo.preload(:tags) |> Repo.preload(:themes)
assert Enum.map(endgame.tags, & &1.id) == [tag.id] assert Enum.map(endgame.themes, & &1.id) == [theme.id]
end end
test "attaches multiple themes", %{conn: conn} do test "attaches multiple themes", %{conn: conn} do
tag_fixture(%{name: "Lucena"}) theme_fixture(%{name: "Lucena"})
tag_fixture(%{name: "Philidor"}) theme_fixture(%{name: "Philidor"})
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new") {:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
view |> form("#theme-form", %{tag_search: "Luc"}) |> render_change() view |> form("#theme-form", %{theme_search: "Luc"}) |> render_change()
view |> element("button", "Lucena") |> render_click() view |> element("button", "Lucena") |> render_click()
view |> form("#theme-form", %{tag_search: "Phil"}) |> render_change() view |> form("#theme-form", %{theme_search: "Phil"}) |> render_change()
view |> element("button", "Philidor") |> render_click() view |> element("button", "Philidor") |> render_click()
html = render(view) html = render(view)
@@ -54,16 +54,16 @@ defmodule ChesstrainerWeb.EndgameLive.FormTest do
test "creates and attaches a new theme inline", %{conn: conn} do test "creates and attaches a new theme inline", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new") {:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
view |> form("#theme-form", %{tag_search: "Lucerne"}) |> render_submit() view |> form("#theme-form", %{theme_search: "Lucerne"}) |> render_submit()
assert render(view) =~ "Lucerne" assert render(view) =~ "Lucerne"
assert [%{name: "Lucerne"}] = Tags.search("Lucerne", "endgame") assert [%{name: "Lucerne"}] = Themes.search("Lucerne", "endgame")
end end
test "removes a theme from an existing endgame", %{conn: conn} do test "removes a theme from an existing endgame", %{conn: conn} do
tag = tag_fixture(%{name: "Lucena"}) theme = theme_fixture(%{name: "Lucena"})
attrs = %{fen: @fen, color: :white, key: "KR v K", result: :win, rating: 1500} attrs = %{fen: @fen, color: :white, key: "KR v K", result: :win, rating: 1500}
{:ok, endgame} = Endgames.create_endgame(attrs, [tag]) {:ok, endgame} = Endgames.create_endgame(attrs, [theme])
{:ok, view, _html} = live(conn, ~p"/admin/endgames/#{endgame}/edit") {:ok, view, _html} = live(conn, ~p"/admin/endgames/#{endgame}/edit")
@@ -77,7 +77,7 @@ defmodule ChesstrainerWeb.EndgameLive.FormTest do
assert_redirect(view, ~p"/admin/endgames") assert_redirect(view, ~p"/admin/endgames")
updated = Endgames.get_endgame!(endgame.id) |> Repo.preload(:tags) updated = Endgames.get_endgame!(endgame.id) |> Repo.preload(:themes)
assert updated.tags == [] assert updated.themes == []
end end
end end
@@ -3,14 +3,14 @@ defmodule ChesstrainerWeb.EndgameLive.IndexTest do
import Phoenix.LiveViewTest import Phoenix.LiveViewTest
import Chesstrainer.EndgamesFixtures import Chesstrainer.EndgamesFixtures
import Chesstrainer.TagsFixtures import Chesstrainer.ThemesFixtures
alias Chesstrainer.Endgames alias Chesstrainer.Endgames
test "lists an endgame's themes", %{conn: conn} do test "lists an endgame's themes", %{conn: conn} do
tag = tag_fixture(%{name: "Lucena"}) theme = theme_fixture(%{name: "Lucena"})
endgame = endgame_fixture() endgame = endgame_fixture()
{:ok, _endgame} = Endgames.update_endgame(endgame, %{}, [tag]) {:ok, _endgame} = Endgames.update_endgame(endgame, %{}, [theme])
{:ok, _view, html} = live(conn, ~p"/admin/endgames") {:ok, _view, html} = live(conn, ~p"/admin/endgames")
-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