Apply review - Use sigils, fix doc, update one test

Author: Premwoik

lib/gradient/debug.ex

@@ -8,7 +8,7 @@ defmodule Gradient.Debug do
   @type erlang_form() :: Gradient.Types.form()
 
   @doc ~S"""
-  Translate Elixir code to abstract code.
+  Translate the Elixir code to the Erlang AST.
   """
   defmacro elixir_to_ast(do: code) do
     quoted_to_ast(code)
@@ -19,7 +19,7 @@ defmodule Gradient.Debug do
   end
 
   @doc ~S"""
-  Translate Elixir quoted to abstract code.
+  Translate the Elixir AST to the Erlang AST.
   """
   @spec quoted_to_ast(elixir_form()) :: erlang_form()
   def quoted_to_ast(qt) do

test/gradient/elixir_expr_test.exs

@@ -93,7 +93,7 @@ defmodule Gradient.ElixirExprTest do
         end
         |> ElixirExpr.pp_expr()
 
-      assert "receive do {:hello, msg} -> msg after 1000 -> \"nothing happened\" end" == actual
+      assert ~s(receive do {:hello, msg} -> msg after 1000 -> "nothing happened" end) == actual
     end
 
     test "call pipe" do
@@ -140,7 +140,7 @@ defmodule Gradient.ElixirExprTest do
         end
         |> ElixirExpr.pp_expr()
 
-      assert "try do raise \"ok\"; catch :error, e -> IO.puts(Exception.format(:error, e, __STACKTRACE__)); reraise e, __STACKTRACE__ end" ==
+      assert ~s(try do raise "ok"; catch :error, e -> IO.puts(Exception.format(:error, e, __STACKTRACE__\)\); reraise e, __STACKTRACE__ end) ==
                actual
     end
 
@@ -155,7 +155,7 @@ defmodule Gradient.ElixirExprTest do
         end
         |> ElixirExpr.pp_expr()
 
-      assert "try do raise \"oops\"; catch :error, %RuntimeError{} = _ -> \"Error!\" end" ==
+      assert ~s(try do raise "oops"; catch :error, %RuntimeError{} = _ -> "Error!" end) ==
                actual
     end
 
@@ -215,7 +215,7 @@ defmodule Gradient.ElixirExprTest do
         end
         |> ElixirExpr.pp_expr()
 
-      assert "try do throw \"good\"; :ok; else v when v == :ok -> :ok; v -> :nok; catch :error, %RuntimeError{} = e -> 11; e; :throw, val -> val; :throw, _ -> 0; after IO.puts(\"Cleaning!\") end" ==
+      assert ~s(try do throw "good"; :ok; else v when v == :ok -> :ok; v -> :nok; catch :error, %RuntimeError{} = e -> 11; e; :throw, val -> val; :throw, _ -> 0; after IO.puts("Cleaning!"\) end) ==
                actual
     end
 
@@ -301,73 +301,29 @@ defmodule Gradient.ElixirExprTest do
     end
 
     test "try with rescue and catch" do
-      try_expr =
-        {:try, 3,
-         [
-           {:case, 4, {:atom, 4, true},
-            [
-              {:clause, [generated: true, location: 4], [{:atom, 0, false}], [],
-               [
-                 {:call, 7, {:remote, 7, {:atom, 7, :erlang}, {:atom, 7, :error}},
-                  [
-                    {:call, 7, {:remote, 7, {:atom, 7, RuntimeError}, {:atom, 7, :exception}},
-                     [
-                       {:bin, 7,
-                        [
-                          {:bin_element, 7, {:string, 7, 'oops'}, :default, :default}
-                        ]}
-                     ]}
-                  ]}
-               ]},
-              {:clause, [generated: true, location: 4], [{:atom, 0, true}], [],
-               [
-                 {:call, 5, {:remote, 5, {:atom, 5, :erlang}, {:atom, 5, :throw}},
-                  [
-                    {:bin, 5, [{:bin_element, 5, {:string, 5, 'good'}, :default, :default}]}
-                  ]}
-               ]}
-            ]}
-         ], [],
-         [
-           {:clause, 10,
-            [
-              {:tuple, 10,
-               [
-                 {:atom, 10, :error},
-                 {:var, 10, :_@1},
-                 {:var, 10, :___STACKTRACE__@1}
-               ]}
-            ],
-            [
-              [
-                {:op, 10, :andalso,
-                 {:op, 10, :==,
-                  {:call, 10, {:remote, 10, {:atom, 10, :erlang}, {:atom, 10, :map_get}},
-                   [{:atom, 10, :__struct__}, {:var, 10, :_@1}]}, {:atom, 10, RuntimeError}},
-                 {:call, 10, {:remote, 10, {:atom, 10, :erlang}, {:atom, 10, :map_get}},
-                  [{:atom, 10, :__exception__}, {:var, 10, :_@1}]}}
-              ]
-            ],
-            [
-              {:match, 10, {:var, 10, :_e@1}, {:var, 10, :_@1}},
-              {:integer, 11, 11},
-              {:var, 12, :_e@1}
-            ]},
-           {:clause, 14,
-            [
-              {:tuple, 14,
-               [
-                 {:atom, 14, :throw},
-                 {:var, 14, :_val@1},
-                 {:var, 14, :___STACKTRACE__@1}
-               ]}
-            ], [], [{:integer, 15, 12}, {:var, 16, :_val@1}]}
-         ], []}
-
-      result = ElixirExpr.pp_expr(try_expr)
-
-      assert "try do if true do throw \"good\" else raise \"oops\" end;" <>
-               " catch :error, %RuntimeError{} = e -> 11; e; :throw, val -> 12; val end" == result
+      actual =
+        elixir_to_ast do
+          try do
+            if true do
+              throw("good")
+            else
+              raise "oops"
+            end
+          rescue
+            e in RuntimeError ->
+              11
+              e
+          catch
+            val ->
+              12
+              val
+          end
+        end
+        |> ElixirExpr.pp_expr()
+
+      assert ~s(try do if true do throw "good" else raise "oops" end;) <>
+               ~s( catch :error, %RuntimeError{} = e -> 11; e; :throw, val -> 12; val end) ==
+               actual
     end
   end
 end

test/support/expr_data.ex

@@ -28,15 +28,15 @@ defmodule Gradient.ExprData do
       {"char", {:char, 0, ?c}, "?c"},
       {"float", {:float, 0, 12.0}, "12.0"},
       {"integer", {:integer, 0, 1}, "1"},
-      {"erlang string", {:string, 0, 'ala ma kota'}, "\'ala ma kota\'"}
+      {"erlang string", {:string, 0, 'ala ma kota'}, ~s('ala ma kota')}
     ]
   end
 
   def list_test_data() do
     [
       {"charlist",
        {:cons, 0, {:integer, 0, 97},
-        {:cons, 0, {:integer, 0, 108}, {:cons, 0, {:integer, 0, 97}, {nil, 0}}}}, "\'ala\'"},
+        {:cons, 0, {:integer, 0, 108}, {:cons, 0, {:integer, 0, 97}, {nil, 0}}}}, ~s('ala')},
       {"int list",
        {:cons, 0, {:integer, 0, 0},
         {:cons, 0, {:integer, 0, 1}, {:cons, 0, {:integer, 0, 2}, {nil, 0}}}}, "[0, 1, 2]"},
@@ -72,11 +72,11 @@ defmodule Gradient.ExprData do
   def exception_test_data() do
     [
       {"throw", elixir_to_ast(throw({:ok, 12})), "throw {:ok, 12}"},
-      {"raise/1", elixir_to_ast(raise "test error"), "raise \"test error\""},
+      {"raise/1", elixir_to_ast(raise "test error"), ~s(raise "test error")},
       {"raise/1 without msg", elixir_to_ast(raise RuntimeError), "raise RuntimeError"},
-      {"raise/2", elixir_to_ast(raise RuntimeError, "test error"), "raise \"test error\""},
+      {"raise/2", elixir_to_ast(raise RuntimeError, "test error"), ~s(raise "test error")},
       {"custom raise", elixir_to_ast(raise ArithmeticError, "only odd numbers"),
-       "raise ArithmeticError, \"only odd numbers\""}
+       ~s(raise ArithmeticError, "only odd numbers")}
     ]
   end
 
@@ -94,11 +94,11 @@ defmodule Gradient.ExprData do
 
   def map_test_data do
     [
-      {"string map", elixir_to_ast(%{"a" => 12}), "%{\"a\" => 12}"},
+      {"string map", elixir_to_ast(%{"a" => 12}), ~s(%{"a" => 12})},
       {"map pm", elixir_to_ast(%{a: a} = %{a: 12}), "%{a: a} = %{a: 12}"},
       {"update map", elixir_to_ast(%{%{} | a: 1}), "%{%{} | a: 1}"},
       {"struct expr", elixir_to_ast(%{__struct__: TestStruct, name: "John"}),
-       "%TestStruct{name: \"John\"}"}
+       ~s(%TestStruct{name: "John"})}
     ]
   end
 
@@ -158,7 +158,7 @@ defmodule Gradient.ExprData do
         "a" <> x
       end
 
-    {"binary <> joining", ast, "x = \"b\"; <<\"a\", x::binary>>"}
+    {"binary <> joining", ast, ~s(x = "b"; <<"a", x::binary>>)}
   end
 
   defp bin_with_bin_var do
@@ -168,7 +168,7 @@ defmodule Gradient.ExprData do
         <<"a", "b", x::binary>>
       end
 
-    {"binary with bin var", ast, "x = \"b\"; <<\"a\", \"b\", x::binary>>"}
+    {"binary with bin var", ast, ~s(x = "b"; <<"a", "b", x::binary>>)}
   end
 
   defp bin_with_pp_int_size do
@@ -177,7 +177,7 @@ defmodule Gradient.ExprData do
         <<a::16>> = <<"abcd">>
       end
 
-    {"binary with int size", ast, "<<a::16>> = \"abcd\""}
+    {"binary with int size", ast, ~s(<<a::16>> = "abcd")}
   end
 
   defp bin_with_pp_and_bitstring_size do