Figured out how to compile in memory beam data

bryanjos · bryanjos · commit 803b8910c5e0 · 2017-09-18T22:11:12.000-05:00
diff --git a/lib/elixir_script/beam.ex b/lib/elixir_script/beam.ex
@@ -7,7 +7,7 @@ defmodule ElixirScript.Beam do
   For protocols, this will return a list of
   all the protocol implementations
   """
-  @spec debug_info(atom) :: {:ok | :error, map | binary}
+  @spec debug_info(atom | bitstring) :: {:ok | :error, map | binary}
   def debug_info(module)
 
   # We get debug info from String and then replace
@@ -39,9 +39,23 @@ defmodule ElixirScript.Beam do
     do_debug_info(module)
   end
 
-  defp do_debug_info(module) when is_atom(module) do
-    with  {_, beam, beam_path} <- :code.get_object_code(module),
-          {:ok, {^module, [debug_info: {:debug_info_v1, backend, data}]}} <- :beam_lib.chunks(beam, [:debug_info]),
+  def debug_info(beam) when is_bitstring(beam) do
+    do_debug_info(beam)
+  end
+
+  defp do_debug_info(module, path \\ nil)
+
+  defp do_debug_info(module, _) when is_atom(module) do
+    case :code.get_object_code(module) do
+      {_, beam, beam_path} ->
+        do_debug_info(beam, beam_path)
+      :error ->
+        {:error, "Unknown module"}
+    end
+  end
+
+  defp do_debug_info(beam, beam_path) do
+    with  {:ok, {module, [debug_info: {:debug_info_v1, backend, data}]}} <- :beam_lib.chunks(beam, [:debug_info]),
           {:ok, {^module, attribute_info}} = :beam_lib.chunks(beam, [:attributes]) do
 
           if Keyword.get(attribute_info[:attributes], :protocol) do
@@ -62,6 +76,11 @@ defmodule ElixirScript.Beam do
     end
   end
 
+  defp process_debug_info({:ok, info}, nil) do
+    info = Map.put(info, :last_modified, nil)
+    {:ok, info}
+  end
+
   defp process_debug_info({:ok, info}, beam_path) do
     info = case File.stat(beam_path, time: :posix) do
       {:ok, file_info} ->
diff --git a/lib/elixir_script/compiler.ex b/lib/elixir_script/compiler.ex
@@ -22,13 +22,40 @@ defmodule ElixirScript.Compiler do
 
   * `root`: Optional root for imports of FFI JavaScript modules. Defaults to `.`.
   """
-  @spec compile(atom | [atom], []) :: nil
-  def compile(entry_modules, opts \\ []) do
+  @spec compile(atom | [atom] | binary, []) :: nil
+  def compile(path, opts \\ [])
+
+  def compile(path, opts) when is_binary(path) do
+    opts = build_compiler_options(opts, [])
+    {:ok, pid} = ElixirScript.State.start_link()
+
+    path = if String.ends_with?(path, ".ex") or String.ends_with?(path, ".exs") do
+      path
+    else
+      Path.join([path, "**", "*.{ex,exs}"])
+    end
+
+    files = Path.wildcard(path)
+
+    Kernel.ParallelCompiler.files(files, [each_module: &on_module_compile(pid, &1, &2, &3)])
+
+    entry_modules = pid
+    |> ElixirScript.State.get_in_memory_modules
+    |> Keyword.keys
+
+    do_compile(entry_modules, pid, opts)
+  end
+
+  def compile(entry_modules, opts) do
     opts = build_compiler_options(opts, entry_modules)
     {:ok, pid} = ElixirScript.State.start_link()
 
     entry_modules = List.wrap(entry_modules)
 
+    do_compile(entry_modules, pid, opts)
+  end
+
+  defp do_compile(entry_modules, pid, opts) do
     ElixirScript.FindUsedModules.execute(entry_modules, pid)
 
     ElixirScript.FindUsedFunctions.execute(entry_modules, pid)
@@ -54,4 +81,8 @@ defmodule ElixirScript.Compiler do
     options = default_options
     Map.put(options, :module_formatter, ElixirScript.ModuleSystems.ES)
   end
+
+  defp on_module_compile(pid, _file, module, beam) do
+    ElixirScript.State.put_in_memory_module(pid, module, beam)
+  end
 end
diff --git a/lib/elixir_script/passes/find_used_modules.ex b/lib/elixir_script/passes/find_used_modules.ex
@@ -11,14 +11,19 @@ defmodule ElixirScript.FindUsedModules do
     modules
     |> List.wrap
     |> Enum.each(fn(module) ->
-      if ElixirScript.State.get_module(pid, module) == nil do
-        do_execute(module, pid)
-      end
+      do_execute(module, pid)
     end)
   end
 
   defp do_execute(module, pid) do
-    case ElixirScript.Beam.debug_info(module) do
+    result = case ModuleState.get_in_memory_module(pid, module) do
+      nil ->
+        ElixirScript.Beam.debug_info(module)
+      beam ->
+        ElixirScript.Beam.debug_info(beam)
+    end
+
+    case result do
       {:ok, info} ->
         walk_module(module, info, pid)
       {:ok, module, implementations} ->
diff --git a/lib/elixir_script/state.ex b/lib/elixir_script/state.ex
@@ -7,7 +7,8 @@ defmodule ElixirScript.State do
     Agent.start_link(fn ->
       %{
         modules: Keyword.new,
-        js_modules: []
+        js_modules: [],
+        in_memory_modules: []
       }
     end)
   end
@@ -88,4 +89,24 @@ defmodule ElixirScript.State do
       state.modules
     end)
   end
+
+  def get_in_memory_module(pid, module) do
+    Agent.get(pid, fn(state) ->
+      Keyword.get(state.in_memory_modules, module)
+    end)
+  end
+
+  def get_in_memory_modules(pid) do
+    Agent.get(pid, fn(state) ->
+      state.in_memory_modules
+    end)
+  end
+
+  def put_in_memory_module(pid, module, beam) do
+    Agent.update(pid, fn(state) ->
+      in_memory_modules = Map.get(state, :in_memory_modules, [])
+      in_memory_modules = [{module, beam} | in_memory_modules]
+      %{ state | in_memory_modules: in_memory_modules }
+    end)
+  end
 end
