refactor(editor): use string-fmt map instead of atom-fmt

Author: mydearxym

lib/helper/converter/editor_to_html/validator.ex

@@ -9,37 +9,9 @@ defmodule Helper.Converter.EditorToHTML.Validator do
   @valid_list_label_type ["success", "done", "todo"]
   @valid_list_indent [0, 1, 2, 3, 4]
 
-  # atoms dynamically and atoms are not
-  # garbage-collected. Therefore, string should not be an untrusted value, such as
-  # input received from a socket or during a web request. Consider using
-  # to_existing_atom/1 instead
-  # keys_to_atoms is using to_existing_atom under the hook, so we have to pre-define the
-  # trusted atoms
-  tursted_atoms = [
-    # common
-    :text,
-    :items,
-    # header
-    :level,
-    :eyebrowTitle,
-    :footerTitle,
-    # list
-    :hideLabel,
-    :labelType,
-    :indent,
-    :checked,
-    :label,
-    # code
-    :lang
-  ]
-
-  Enum.each(tursted_atoms, fn atom -> _ = atom end)
-
   def is_valid(map) when is_map(map) do
-    with atom_map <- Utils.keys_to_atoms(map),
-         true <- is_valid_editorjs_fmt(atom_map) do
-      blocks = atom_map.blocks
-      # validate_blocks(blocks)
+    with true <- is_valid_editorjs_fmt(map) do
+      blocks = map["blocks"]
 
       try do
         validate_blocks(blocks)
@@ -73,8 +45,8 @@ defmodule Helper.Converter.EditorToHTML.Validator do
     {:ok, :pass}
   end
 
-  defp validate_block(%{type: "paragraph", data: %{text: text} = data}) do
-    schema = %{text: [:string]}
+  defp validate_block(%{"type" => "paragraph", "data" => %{"text" => text} = data}) do
+    schema = %{"text" => [:string]}
 
     case ValidateBySchema.cast(schema, data) do
       {:error, errors} ->
@@ -85,12 +57,12 @@ defmodule Helper.Converter.EditorToHTML.Validator do
     end
   end
 
-  defp validate_block(%{type: "header", data: %{text: text, level: level} = data}) do
+  defp validate_block(%{"type" => "header", "data" => %{"text" => text, "level" => level} = data}) do
     schema = %{
-      text: [:string],
-      level: [enum: @valid_header_level],
-      eyebrowTitle: [:string, required: false],
-      footerTitle: [:string, required: false]
+      "text" => [:string],
+      "level" => [enum: @valid_header_level],
+      "eyebrowTitle" => [:string, required: false],
+      "footerTitle" => [:string, required: false]
     }
 
     case ValidateBySchema.cast(schema, data) do
@@ -102,18 +74,18 @@ defmodule Helper.Converter.EditorToHTML.Validator do
     end
   end
 
-  defp validate_block(%{type: "list", data: %{mode: mode, items: items} = data})
+  defp validate_block(%{"type" => "list", "data" => %{"mode" => mode, "items" => items} = data})
        when mode in @valid_list_mode and is_list(items) do
     # mode_schema = %{mode: [enum: @valid_list_mode]}
     # {:ok, _} = ValidateBySchema.cast(mode_schema, data)
 
     item_schema = %{
-      checked: [:boolean],
-      hideLabel: [:boolean],
-      label: [:string],
-      labelType: [enum: @valid_list_label_type],
-      indent: [enum: @valid_list_indent],
-      text: [:string]
+      "checked" => [:boolean],
+      "hideLabel" => [:boolean],
+      "label" => [:string],
+      "labelType" => [enum: @valid_list_label_type],
+      "indent" => [enum: @valid_list_indent],
+      "text" => [:string]
     }
 
     Enum.each(items, fn item ->
@@ -130,7 +102,7 @@ defmodule Helper.Converter.EditorToHTML.Validator do
     {:ok, :pass}
   end
 
-  defp validate_block(%{type: "code"}) do
+  defp validate_block(%{"type" => "code"}) do
     # schema = %{text: [:string]}
     # case ValidateBySchema.cast(schema, data) do
     #   {:error, errors} ->
@@ -142,17 +114,17 @@ defmodule Helper.Converter.EditorToHTML.Validator do
     {:ok, :pass}
   end
 
-  defp validate_block(%{type: type}), do: raise("undown #{type} block")
+  defp validate_block(%{"type" => type}), do: raise("undown #{type} block")
   defp validate_block(_), do: raise("undown block")
 
   #  check if the given map has the right key-value fmt of the editorjs structure
   defp is_valid_editorjs_fmt(map) when is_map(map) do
-    Map.has_key?(map, :time) and
-      Map.has_key?(map, :version) and
-      Map.has_key?(map, :blocks) and
-      is_list(map.blocks) and
-      is_binary(map.version) and
-      is_integer(map.time)
+    Map.has_key?(map, "time") and
+      Map.has_key?(map, "version") and
+      Map.has_key?(map, "blocks") and
+      is_list(map["blocks"]) and
+      is_binary(map["version"]) and
+      is_integer(map["time"])
   end
 
   defp format_parse_error(type, error_list) when is_list(error_list) do

lib/helper/validate_by_schema.ex

@@ -91,8 +91,8 @@ defmodule Helper.ValidateBySchema do
       false ->
         {:error,
          %{
-           field: "#{field |> to_string}",
-           message: "should be: #{enum |> Enum.join(" | ") |> to_string}"
+           field: field,
+           message: "should be: #{enum |> Enum.join(" | ")}"
          }}
     end
   end

test/helper/converter/editor_to_html_test/list_test.exs

@@ -73,7 +73,7 @@ defmodule GroupherServer.Test.Helper.Converter.EditorToHTML.List do
       ],
       "version" => "2.15.0"
     }
-    @tag :wip
+    @tag :wip2
     test "valid list parse should work" do
       {:ok, editor_string} = Jason.encode(@editor_json)
       assert {:ok, _} = Parser.to_html(editor_string)
@@ -101,7 +101,7 @@ defmodule GroupherServer.Test.Helper.Converter.EditorToHTML.List do
       ],
       "version" => "2.15.0"
     }
-    @tag :wip
+    @tag :wip2
     test "invalid indent field should get error" do
       {:ok, editor_string} = Jason.encode(@editor_json)
       {:error, error} = Parser.to_html(editor_string)