Add some tests for the Form module

bryanjos · bryanjos · commit eb20acfe3f40 · 2017-06-04T19:29:41.000-05:00
diff --git a/lib/elixir_script/next/passes/translate/examples/example.ex b/lib/elixir_script/next/passes/translate/examples/example.ex
@@ -1,10 +1,5 @@
 defmodule Example do
-  def start(v, _) do
-    case v do
-      :normal ->
-        "yolo"
-      _ ->
-        "yolo too"
-    end
+  def start(_, _) do
+    -1
   end
 end
diff --git a/lib/elixir_script/next/passes/translate/form.ex b/lib/elixir_script/next/passes/translate/form.ex
@@ -1,6 +1,6 @@
 defmodule ElixirScript.Translate.Form do
   alias ESTree.Tools.Builder, as: J
-  alias ElixirScript.Translate.Forms.{Bitstring, Match, Try, For, Struct, Receive, Remote, Pattern}
+  alias ElixirScript.Translate.Forms.{Bitstring, Match, Try, For, Receive, Remote, Pattern}
   alias ElixirScript.Translate.Functions.{Erlang, Lists, Maps}
   alias ElixirScript.Translator.Identifier
   alias ElixirScript.Translate.Clause
@@ -34,8 +34,7 @@ defmodule ElixirScript.Translate.Form do
 
   def compile(form, state) when is_atom(form) do
     ast = if ElixirScript.Translate.Module.is_elixir_module(form) do
-      members = if form == Elixir, do: ["Elixir"], else: ["Elixir"] ++ Module.split(form)
-      J.identifier(Enum.join(members, "_"))
+      Remote.process_module_name(form, state)
     else
       J.call_expression(
         J.member_expression(
@@ -80,8 +79,16 @@ defmodule ElixirScript.Translate.Form do
     Match.compile(match, state)
   end
 
-  def compile({:%, _, [_, _]} = ast, state) do
-    Struct.compile(ast, state)
+  def compile({:%, _, [module, params]}, state) do
+    ast = J.call_expression(
+      J.member_expression(
+        Remote.process_module_name(module),
+        J.identifier("__struct__")
+      ),
+      [Form.compile!(params, state)]
+    )
+
+    { ast, state }
   end
 
   def compile({:for, _, _} = ast, state) do
diff --git a/lib/elixir_script/next/passes/translate/forms/remote.ex b/lib/elixir_script/next/passes/translate/forms/remote.ex
@@ -1,4 +1,6 @@
 defmodule ElixirScript.Translate.Forms.Remote do
+  @moduledoc false
+
   alias ESTree.Tools.Builder, as: J
   alias ElixirScript.Translate.Form
   alias ElixirScript.Translator.Identifier
@@ -16,6 +18,13 @@ defmodule ElixirScript.Translate.Forms.Remote do
     :file
   ]
 
+  @doc """
+  Compiles functions into JavaScript AST.
+  These are not actual function calls, but
+  the function identifiers themselves. Also
+  includes function heads for converting some
+  erlang functions into JavaScript functions.
+  """
   def compile({:., _, [:erlang, :+]}, state) do
     ast = erlang_compat_function("erlang", "plus")
     { ast, state }    
@@ -131,20 +140,24 @@ defmodule ElixirScript.Translate.Forms.Remote do
     {ast, state}
   end
 
-  defp process_module_name(module, state) when is_atom(module) do
+  def process_module_name(module, state) when is_atom(module) do
     cond do
       ElixirScript.Translate.Module.is_js_module(module, state) ->
         members = tl(Module.split(module))
         Identifier.make_namespace_members(members)      
       ElixirScript.Translate.Module.is_elixir_module(module) ->
-        members = ["Elixir"] ++ Module.split(module)
-        J.identifier(Enum.join(members, "_"))
+        members = ["Elixir"] ++ Module.split(module) ++ ["__load"]
+
+        J.call_expression(
+          Identifier.make_namespace_members(members),
+          [J.identifier("Elixir")]
+        )
       true ->
         ElixirScript.Translator.Identifier.make_identifier(module)
     end
   end
 
-  defp process_module_name(module, state) do
+  def process_module_name(module, state) do
     Form.compile!(module, state)
   end
 
diff --git a/lib/elixir_script/next/passes/translate/forms/struct.ex b/lib/elixir_script/next/passes/translate/forms/struct.ex
diff --git a/lib/elixir_script/next/passes/translate/module.ex b/lib/elixir_script/next/passes/translate/module.ex
@@ -14,6 +14,9 @@ defmodule ElixirScript.Translate.Module do
   end
 
   def compile(module, info, pid) do
+    if Atom.to_string(module) == "Elixir.Example" do
+      IO.inspect info
+    end
     %{
       attributes: attrs, 
       compile_opts: _compile_opts,
@@ -86,6 +89,10 @@ defmodule ElixirScript.Translate.Module do
     J.object_expression(exports)
   end
 
+  @doc """
+  Determins if the given atom
+  is an Elixir function
+  """
   def is_elixir_module(Elixir) do
     true
   end
@@ -105,6 +112,12 @@ defmodule ElixirScript.Translate.Module do
     false
   end
 
+  @doc """
+  Determines is given function is a JS module.
+  A JS module is either one that begins with "JS"
+  or is a module defined from the js_modules compiler
+  opt
+  """
   def is_js_module(module, state) do
     cond do
       module in ModuleState.get_javascript_modules(state.pid) ->
diff --git a/test/next/passes/translate/form_test.exs b/test/next/passes/translate/form_test.exs
@@ -0,0 +1,121 @@
+defmodule ElixirScript.Translate.Forms.Test do
+  use ExUnit.Case
+  alias ElixirScript.Translate.Form
+  alias ElixirScript.Translator.Identifier
+  alias ESTree.Tools.Builder, as: J
+
+
+  setup_all do
+    {:ok, pid} = ElixirScript.State.start_link(%{})
+
+    state = %{
+      pid: pid
+    }
+
+    [state: state]
+  end
+
+  test "integer" do
+    ast = 1
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.literal(1)
+  end
+
+  test "boolean" do
+    ast = true
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.literal(true)
+  end
+
+  test "float" do
+    ast = 1.0
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.literal(1.0)
+  end
+
+  test "binary" do
+    ast = "hello"
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.literal("hello")
+  end
+
+  test "atom" do
+    ast = :tiger
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.call_expression(
+        J.member_expression(
+          J.identifier("Symbol"),
+          J.identifier("for")
+        ),
+        [J.literal(:tiger)]
+      )
+  end
+
+  test "module", %{state: state} do
+    ast = IO
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.call_expression(
+          Identifier.make_namespace_members(["Elixir", "IO", "__load"]),
+          [J.identifier("Elixir")]
+        )
+  end
+
+  test "tuple" do
+    ast = {1, 2}
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.call_expression(
+      J.member_expression(
+        J.member_expression(
+          J.identifier("Bootstrap"),
+          J.identifier("Core")
+        ),
+        J.identifier("Tuple")
+      ),
+      [J.literal(1), J.literal(2)]
+    )
+  end
+
+  test "list" do
+    ast = [1, 2]
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.array_expression([J.literal(1), J.literal(2)])
+  end
+
+  test "super" do
+    ast = {:super, [], [1]}
+    state = %{function: {:my_function, nil}}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.call_expression(
+      J.identifier("my_function"),
+      [J.literal(1)]
+    )
+  end
+
+  test "local function" do
+    ast = {:my_function, [], [1]}
+    state = %{}
+
+    {js_ast, _} = Form.compile(ast, state)
+    assert js_ast == J.call_expression(
+      J.identifier("my_function"),
+      [J.literal(1)]
+    )
+  end
+
+end
