Add pipe and with tests. Fix with

Author: Premwoik

lib/gradient/elixir_expr.ex

@@ -103,7 +103,7 @@ defmodule Gradient.ElixirExpr do
   end
 
   def pp_expr({:call, _, {:remote, _, {:atom, _, :erlang}, {:atom, _, :error}}, [arg]}) do
-    "raise " <> pp_raise_args(arg)
+    "raise " <> pp_raise_arg(arg)
   end
 
   def pp_expr({:call, _, name, args}) do
@@ -155,9 +155,9 @@ defmodule Gradient.ElixirExpr do
     "{" <> elements_str <> "}"
   end
 
-  def pp_expr({:var, _, t}) do
+  def pp_expr({:var, anno, t}) do
     case Atom.to_string(t) |> String.split("@") |> List.first() do
-      "_" -> "_"
+      "_" -> if :erl_anno.generated(anno), do: "_gen", else: "_"
       "_" <> name -> name
       name -> name
     end
@@ -456,20 +456,24 @@ defmodule Gradient.ElixirExpr do
     end
   end
 
-  defp pp_raise_args({:call, _, {:remote, _, error_type, {:atom, _, :exception}}, [{nil, _}]}) do
+  defp pp_raise_arg({:call, _, {:remote, _, error_type, {:atom, _, :exception}}, [{nil, _}]}) do
     pp_expr(error_type)
   end
 
-  defp pp_raise_args(
+  defp pp_raise_arg(
          {:call, _, {:remote, _, {:atom, _, RuntimeError}, {:atom, _, :exception}}, [arg]}
        ) do
     pp_expr(arg)
   end
 
-  defp pp_raise_args({:call, _, {:remote, _, error_type, {:atom, _, :exception}}, [arg]}) do
+  defp pp_raise_arg({:call, _, {:remote, _, error_type, {:atom, _, :exception}}, [arg]}) do
     pp_expr(error_type) <> ", " <> pp_expr(arg)
   end
 
+  defp pp_raise_arg(arg) do
+    pp_expr(arg)
+  end
+
   defp try_int_list_({nil, _}), do: []
   defp try_int_list_({:cons, _, {:integer, _, val}, t}), do: [val | try_int_list_(t)]
   defp try_int_list_(_), do: throw(nil)

test/gradient/elixir_expr_test.exs

@@ -96,6 +96,37 @@ defmodule Gradient.ElixirExprTest do
       assert "receive do {:hello, msg} -> msg after 1000 -> \"nothing happened\" end" == actual
     end
 
+    test "call pipe" do
+      actual =
+        elixir_to_ast do
+          [1, 2, 3]
+          |> Enum.map(fn x -> x + 1 end)
+          |> Enum.map(&(&1 + 1))
+        end
+        |> ElixirExpr.pp_expr()
+
+      assert "Enum.map(Enum.map([1, 2, 3], fn x -> x + 1 end), fn _ -> _ + 1 end)" == actual
+    end
+
+    test "with" do
+      actual =
+        elixir_to_ast do
+          map = %{a: 12, b: 0}
+
+          with {:ok, a} <- Map.fetch(map, :a),
+               {:ok, b} <- Map.fetch(map, :b) do
+            a + b
+          else
+            :error ->
+              0
+          end
+        end
+        |> ElixirExpr.pp_expr()
+
+      assert "map = %{a: 12, b: 0}; case :maps.find(:a, map) do {:ok, a} -> case :maps.find(:b, map) do {:ok, b} -> a + b; _gen -> case _gen do :error -> 0; _gen -> raise {:with_clause, _gen} end end; _gen -> case _gen do :error -> 0; _gen -> raise {:with_clause, _gen} end end" ==
+               actual
+    end
+
     test "try reraise" do
       actual =
         elixir_to_ast do