improve tagging logic

lib/memex/contexts.ex

@@ -4,7 +4,6 @@ defmodule Memex.Contexts do
   """
 
   import Ecto.Query, warn: false
-  alias Ecto.Changeset
   alias Memex.{Accounts.User, Contexts.Context, Repo}
 
   @doc """
@@ -229,18 +228,4 @@ defmodule Memex.Contexts do
   def change_context(%Context{} = context, attrs \\ %{}, user) do
     context |> Context.update_changeset(attrs, user)
   end
-
-  @doc """
-  Gets a canonical string representation of the `:tags` field for a Note
-  """
-  @spec get_tags_string(Context.t() | Context.changeset() | [String.t()] | nil) :: String.t()
-  def get_tags_string(nil), do: ""
-  def get_tags_string(tags) when tags |> is_list(), do: tags |> Enum.join(",")
-  def get_tags_string(%Context{tags: tags}), do: tags |> get_tags_string()
-
-  def get_tags_string(%Changeset{} = changeset) do
-    changeset
-    |> Changeset.get_field(:tags)
-    |> get_tags_string()
-  end
 end

lib/memex/contexts/context.ex

@@ -27,7 +27,7 @@ defmodule Memex.Contexts.Context do
           slug: slug(),
           content: String.t(),
           tags: [String.t()] | nil,
-          tags_string: String.t(),
+          tags_string: String.t() | nil,
           visibility: :public | :private | :unlisted,
           user: User.t() | Ecto.Association.NotLoaded.t(),
           user_id: User.id(),
@@ -66,16 +66,38 @@ defmodule Memex.Contexts.Context do
     |> unsafe_validate_unique(:slug, Repo)
   end
 
-  defp cast_tags_string(changeset, %{"tags_string" => tags_string})
-       when tags_string |> is_binary() do
-    tags =
-      tags_string
-      |> String.split(",", trim: true)
-      |> Enum.map(fn str -> str |> String.trim() end)
-      |> Enum.sort()
-
-    changeset |> change(tags: tags)
+  defp cast_tags_string(changeset, attrs) do
+    changeset
+    |> put_change(:tags_string, changeset |> get_field(:tags) |> get_tags_string())
+    |> cast(attrs, [:tags_string])
+    |> validate_format(:tags_string, ~r/^[\p{L}\p{N}\-\,]+$/,
+      message:
+        dgettext(
+          "errors",
+          "invalid format: only numbers, letters and hyphen are accepted. tags must be comma-delimited"
+        )
+    )
+    |> cast_tags()
   end
 
-  defp cast_tags_string(changeset, _attrs), do: changeset
+  defp cast_tags(%{valid?: false} = changeset), do: changeset
+
+  defp cast_tags(%{valid?: true} = changeset) do
+    tags = changeset |> get_field(:tags_string) |> process_tags()
+    changeset |> put_change(:tags, tags)
+  end
+
+  defp process_tags(tags_string) when tags_string |> is_binary() do
+    tags_string
+    |> String.split(",", trim: true)
+    |> Enum.map(fn str -> str |> String.trim() end)
+    |> Enum.reject(fn str -> str |> is_nil() end)
+    |> Enum.sort()
+  end
+
+  defp process_tags(_other_tags_string), do: []
+
+  @spec get_tags_string([String.t()] | nil) :: String.t()
+  def get_tags_string(nil), do: ""
+  def get_tags_string(tags) when tags |> is_list(), do: tags |> Enum.join(",")
 end

lib/memex/notes.ex

@@ -4,7 +4,6 @@ defmodule Memex.Notes do
   """
 
   import Ecto.Query, warn: false
-  alias Ecto.Changeset
   alias Memex.{Accounts.User, Notes.Note, Repo}
 
   @doc """
@@ -229,18 +228,4 @@ defmodule Memex.Notes do
   def change_note(%Note{} = note, attrs \\ %{}, user) do
     note |> Note.update_changeset(attrs, user)
   end
-
-  @doc """
-  Gets a canonical string representation of the `:tags` field for a Note
-  """
-  @spec get_tags_string(Note.t() | Note.changeset() | [String.t()] | nil) :: String.t()
-  def get_tags_string(nil), do: ""
-  def get_tags_string(tags) when tags |> is_list(), do: tags |> Enum.join(",")
-  def get_tags_string(%Note{tags: tags}), do: tags |> get_tags_string()
-
-  def get_tags_string(%Changeset{} = changeset) do
-    changeset
-    |> Changeset.get_field(:tags)
-    |> get_tags_string()
-  end
 end

lib/memex/notes/note.ex

@@ -26,7 +26,7 @@ defmodule Memex.Notes.Note do
           slug: slug(),
           content: String.t(),
           tags: [String.t()] | nil,
-          tags_string: String.t(),
+          tags_string: String.t() | nil,
           visibility: :public | :private | :unlisted,
           user: User.t() | Ecto.Association.NotLoaded.t(),
           user_id: User.id(),
@@ -65,16 +65,38 @@ defmodule Memex.Notes.Note do
     |> unsafe_validate_unique(:slug, Repo)
   end
 
-  defp cast_tags_string(changeset, %{"tags_string" => tags_string})
-       when tags_string |> is_binary() do
-    tags =
-      tags_string
-      |> String.split(",", trim: true)
-      |> Enum.map(fn str -> str |> String.trim() end)
-      |> Enum.sort()
-
-    changeset |> change(tags: tags)
+  defp cast_tags_string(changeset, attrs) do
+    changeset
+    |> put_change(:tags_string, changeset |> get_field(:tags) |> get_tags_string())
+    |> cast(attrs, [:tags_string])
+    |> validate_format(:tags_string, ~r/^[\p{L}\p{N}\-\,]+$/,
+      message:
+        dgettext(
+          "errors",
+          "invalid format: only numbers, letters and hyphen are accepted. tags must be comma-delimited"
+        )
+    )
+    |> cast_tags()
   end
 
-  defp cast_tags_string(changeset, _attrs), do: changeset
+  defp cast_tags(%{valid?: false} = changeset), do: changeset
+
+  defp cast_tags(%{valid?: true} = changeset) do
+    tags = changeset |> get_field(:tags_string) |> process_tags()
+    changeset |> put_change(:tags, tags)
+  end
+
+  defp process_tags(tags_string) when tags_string |> is_binary() do
+    tags_string
+    |> String.split(",", trim: true)
+    |> Enum.map(fn str -> str |> String.trim() end)
+    |> Enum.reject(fn str -> str |> is_nil() end)
+    |> Enum.sort()
+  end
+
+  defp process_tags(_other_tags_string), do: []
+
+  @spec get_tags_string([String.t()] | nil) :: String.t()
+  def get_tags_string(nil), do: ""
+  def get_tags_string(tags) when tags |> is_list(), do: tags |> Enum.join(",")
 end

lib/memex/pipelines.ex

@@ -4,7 +4,6 @@ defmodule Memex.Pipelines do
   """
 
   import Ecto.Query, warn: false
-  alias Ecto.Changeset
   alias Memex.{Accounts.User, Pipelines.Pipeline, Repo}
 
   @doc """
@@ -231,18 +230,4 @@ defmodule Memex.Pipelines do
   def change_pipeline(%Pipeline{} = pipeline, attrs \\ %{}, user) do
     pipeline |> Pipeline.update_changeset(attrs, user)
   end
-
-  @doc """
-  Gets a canonical string representation of the `:tags` field for a Pipeline
-  """
-  @spec get_tags_string(Pipeline.t() | Pipeline.changeset() | [String.t()] | nil) :: String.t()
-  def get_tags_string(nil), do: ""
-  def get_tags_string(tags) when tags |> is_list(), do: tags |> Enum.join(",")
-  def get_tags_string(%Pipeline{tags: tags}), do: tags |> get_tags_string()
-
-  def get_tags_string(%Changeset{} = changeset) do
-    changeset
-    |> Changeset.get_field(:tags)
-    |> get_tags_string()
-  end
 end

lib/memex/pipelines/pipeline.ex

@@ -28,7 +28,7 @@ defmodule Memex.Pipelines.Pipeline do
           slug: slug(),
           description: String.t(),
           tags: [String.t()] | nil,
-          tags_string: String.t(),
+          tags_string: String.t() | nil,
           visibility: :public | :private | :unlisted,
           user: User.t() | Ecto.Association.NotLoaded.t(),
           user_id: User.id(),
@@ -67,16 +67,38 @@ defmodule Memex.Pipelines.Pipeline do
     |> unsafe_validate_unique(:slug, Repo)
   end
 
-  defp cast_tags_string(changeset, %{"tags_string" => tags_string})
-       when tags_string |> is_binary() do
-    tags =
-      tags_string
-      |> String.split(",", trim: true)
-      |> Enum.map(fn str -> str |> String.trim() end)
-      |> Enum.sort()
-
-    changeset |> change(tags: tags)
+  defp cast_tags_string(changeset, attrs) do
+    changeset
+    |> put_change(:tags_string, changeset |> get_field(:tags) |> get_tags_string())
+    |> cast(attrs, [:tags_string])
+    |> validate_format(:tags_string, ~r/^[\p{L}\p{N}\-\,]+$/,
+      message:
+        dgettext(
+          "errors",
+          "invalid format: only numbers, letters and hyphen are accepted. tags must be comma-delimited"
+        )
+    )
+    |> cast_tags()
   end
 
-  defp cast_tags_string(changeset, _attrs), do: changeset
+  defp cast_tags(%{valid?: false} = changeset), do: changeset
+
+  defp cast_tags(%{valid?: true} = changeset) do
+    tags = changeset |> get_field(:tags_string) |> process_tags()
+    changeset |> put_change(:tags, tags)
+  end
+
+  defp process_tags(tags_string) when tags_string |> is_binary() do
+    tags_string
+    |> String.split(",", trim: true)
+    |> Enum.map(fn str -> str |> String.trim() end)
+    |> Enum.reject(fn str -> str |> is_nil() end)
+    |> Enum.sort()
+  end
+
+  defp process_tags(_other_tags_string), do: []
+
+  @spec get_tags_string([String.t()] | nil) :: String.t()
+  def get_tags_string(nil), do: ""
+  def get_tags_string(tags) when tags |> is_list(), do: tags |> Enum.join(",")
 end