refactor(editor): return map fmt when error raised

Author: mydearxym

lib/helper/converter/editor_to_html/validator.ex

@@ -36,13 +36,19 @@ defmodule Helper.Converter.EditorToHTML.Validator do
     with atom_map <- Utils.keys_to_atoms(map),
          true <- is_valid_editorjs_fmt(atom_map) do
       blocks = atom_map.blocks
+      # validate_blocks(blocks)
 
       try do
         validate_blocks(blocks)
       rescue
-        e in MatchError -> format_parse_error(e)
-        e in RuntimeError -> format_parse_error(e)
-        e -> format_parse_error()
+        e in MatchError ->
+          format_parse_error(e)
+
+        e in RuntimeError ->
+          format_parse_error(e)
+
+        e ->
+          format_parse_error()
       end
     else
       false ->
@@ -57,16 +63,47 @@ defmodule Helper.Converter.EditorToHTML.Validator do
 
   defp validate_blocks(blocks) do
     Enum.each(blocks, fn block ->
+      # if error happened, will be rescued
       {:ok, _} = validate_block(block)
     end)
 
     {:ok, :pass}
   end
 
+  defp validate_block(%{type: "paragraph", data: %{text: text} = data}) do
+    schema = %{text: [:string]}
+
+    case ValidateBySchema.cast(schema, data) do
+      {:error, errors} ->
+        format_parse_error("paragraph", errors)
+
+      _ ->
+        {:ok, :pass}
+    end
+  end
+
+  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]
+    }
+
+    case ValidateBySchema.cast(schema, data) do
+      {:error, errors} ->
+        format_parse_error("header", errors)
+
+      _ ->
+        {:ok, :pass}
+    end
+  end
+
   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],
@@ -77,24 +114,17 @@ defmodule Helper.Converter.EditorToHTML.Validator do
     }
 
     Enum.each(items, fn item ->
-      {:ok, _} = ValidateBySchema.cast(item_schema, item)
-    end)
-
-    {:ok, :pass}
-  end
+      case ValidateBySchema.cast(item_schema, item) do
+        {:error, errors} ->
+          {:error, message} = format_parse_error("list(#{mode})", errors)
+          raise %MatchError{term: {:error, message}}
 
-  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]
-    }
-
-    {:ok, _} = ValidateBySchema.cast(schema, data)
+        _ ->
+          {:ok, :pass}
+      end
+    end)
   end
 
-  # defp validate_block(%{type: type, data: _}), do: raise("invalid data for #{type} block")
   defp validate_block(%{type: type}), do: raise("undown #{type} block")
   defp validate_block(_), do: raise("undown block")
 
@@ -108,24 +138,20 @@ defmodule Helper.Converter.EditorToHTML.Validator do
       is_integer(map.time)
   end
 
-  # defp format_parse_error({:error, errors}) do
-  defp format_parse_error(%MatchError{term: {:error, errors}}) do
-    message =
-      Enum.reduce(errors, "", fn x, acc ->
-        case String.trim(acc) do
-          "" -> x.message
-          _ -> acc <> " ; " <> x.message
-        end
-      end)
+  defp format_parse_error(type, error_list) when is_list(error_list) do
+    {:error,
+     Enum.map(error_list, fn error ->
+       Map.merge(error, %{block: type})
+     end)}
+  end
 
-    {:error, message}
+  defp format_parse_error(%MatchError{term: {:error, error}}) do
+    {:error, error}
   end
 
-  # defp format_parse_error(%{message: message}), do: {:error, message}
   defp format_parse_error(%{message: message}) do
     {:error, message}
   end
 
-  # defp format_parse_error(e), do: IO.inspect(e, label: "e")
   defp format_parse_error(), do: {:error, "undown validate error"}
 end

lib/helper/validate_by_schema.ex

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

test/helper/converter/editor_to_html_test/header_test.exs

@@ -77,7 +77,7 @@ defmodule GroupherServer.Test.Helper.Converter.EditorToHTML.Header do
       "time" => 1_567_250_876_713,
       "version" => "2.15.0"
     }
-    @tag :wip2
+    @tag :wip
     test "optional field should valid properly" do
       json =
         Map.merge(@editor_json, %{
@@ -144,7 +144,21 @@ defmodule GroupherServer.Test.Helper.Converter.EditorToHTML.Header do
       {:ok, editor_string} = Jason.encode(json)
       {:error, error} = Parser.to_html(editor_string)
 
-      assert error == "eyebrowTitle should be: string ; footerTitle should be: string"
+      assert error ==
+               [
+                 %{
+                   block: "header",
+                   field: "eyebrowTitle",
+                   message: "should be: string",
+                   value: []
+                 },
+                 %{
+                   block: "header",
+                   field: "footerTitle",
+                   message: "should be: string",
+                   value: true
+                 }
+               ]
 
       json =
         Map.merge(@editor_json, %{
@@ -161,7 +175,7 @@ defmodule GroupherServer.Test.Helper.Converter.EditorToHTML.Header do
 
       {:ok, editor_string} = Jason.encode(json)
       {:error, error} = Parser.to_html(editor_string)
-      assert error == "level should be: 1 | 2 | 3"
+      assert error == [%{block: "header", field: "level", message: "should be: 1 | 2 | 3"}]
     end
   end
 end

test/helper/converter/editor_to_html_test/list_test.exs

@@ -94,11 +94,18 @@ 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)
-      # {:ok, converted} = Parser.to_html(editor_string)
-      assert {:error, "indent field should be: 0 | 1 | 2 | 3 | 4"} = Parser.to_html(editor_string)
+      {:error, error} = Parser.to_html(editor_string)
+
+      assert error === [
+               %{
+                 block: "list(checklist)",
+                 field: "indent",
+                 message: "should be: 0 | 1 | 2 | 3 | 4"
+               }
+             ]
     end
   end
 end

test/helper/converter/editor_to_html_test/paragraph_test.exs

@@ -41,13 +41,14 @@ defmodule GroupherServer.Test.Helper.Converter.EditorToHTML.Paragraph do
       ],
       "version" => "2.15.0"
     }
-    @tag :wip
+    @tag :wip2
     test "invalid paragraph should have invalid hint" do
       {:ok, editor_string} = Jason.encode(@editor_json)
-      {:ok, converted} = Parser.to_html(editor_string)
+      {:error, error} = Parser.to_html(editor_string)
 
-      assert converted ==
-               "<div class=\"#{@clazz.viewer}\"><div class=\"#{@clazz.invalid_block}\">[invalid-block] paragraph:text</div><div>"
+      assert error == [
+               %{block: "paragraph", field: "text", message: "should be: string", value: []}
+             ]
     end
   end
 end