Support building Erlang-based escripts in mix escript.build

Author: alco

lib/mix/lib/mix/tasks/escript.build.ex

@@ -45,7 +45,7 @@ defmodule Mix.Tasks.Escript.Build do
     * `:embed_elixir` - if `true` embed elixir and its children apps
       (`ex_unit`, `mix`, etc.) mentioned in the `:applications` list inside the
       `application` function in `mix.exs`.
-      Defaults to `true`.
+      Defaults to `true` for Elixir projects.
 
     * `:shebang` - shebang interpreter directive used to execute the escript.
       Defaults to `"#! /usr/bin/env escript\n"`.
@@ -90,6 +90,7 @@ defmodule Mix.Tasks.Escript.Build do
     main         = escript_opts[:main_module]
     app          = Keyword.get(escript_opts, :app, project[:app])
     files        = project_files()
+    language     = Keyword.get(project, :language, :elixir)
 
     escript_mod = String.to_atom(Atom.to_string(app) <> "_escript")
 
@@ -103,8 +104,9 @@ defmodule Mix.Tasks.Escript.Build do
           "in your project configuration (under `:escript` option) to a module that implements main/1"
 
       force || Mix.Utils.stale?(files, [filename]) ->
-        tuples = gen_main(escript_mod, main, app) ++
-                 to_tuples(files) ++ deps_tuples() ++ embed_tuples(escript_opts)
+        tuples = gen_main(escript_mod, main, app, language) ++
+                 to_tuples(files) ++ deps_tuples() ++
+                 embed_tuples(escript_opts, language)
 
         case :zip.create 'mem', tuples, [:memory] do
           {:ok, {'mem', zip}} ->
@@ -156,8 +158,8 @@ defmodule Mix.Tasks.Escript.Build do
     Enum.flat_map(deps, fn dep -> get_tuples(dep.opts[:build]) end)
   end
 
-  defp embed_tuples(escript_opts) do
-    if Keyword.get(escript_opts, :embed_elixir, true) do
+  defp embed_tuples(escript_opts, language) do
+    if Keyword.get(escript_opts, :embed_elixir, language == :elixir) do
       Enum.flat_map [:elixir|extra_apps()], &app_tuples(&1)
     else
       []
@@ -190,61 +192,104 @@ defmodule Mix.Tasks.Escript.Build do
     "%%! -escript main #{escript_mod} #{user_args}\n"
   end
 
-  defp gen_main(name, module, app) do
+  defp gen_main(name, module, app, language) do
     config =
       if File.regular?("config/config.exs") do
         Mix.Config.read!("config/config.exs")
       else
         []
       end
 
-    {:module, ^name, binary, _} =
-      defmodule name do
-        @module module
-        @config config
-        @app app
-
-        # We need to use Erlang modules at this point
-        # because we are not sure Elixir is available.
-        def main(args) do
-          case :application.ensure_all_started(:elixir) do
-            {:ok, _} ->
-              load_config(@config)
-              start_app(@app)
-              args = Enum.map(args, &List.to_string(&1))
-              Kernel.CLI.run fn _ -> @module.main(args) end, true
-            _ ->
-              :io.put_chars :standard_error, "Elixir is not available, aborting.\n"
-              :erlang.halt(1)
-          end
-        end
+    module_body = quote do
+      @module unquote(module)
+      @config unquote(config)
+      @app unquote(app)
 
-        defp load_config(config) do
-          for {app, kw} <- config, {k, v} <- kw do
-            :application.set_env(app, k, v, persistent: true)
-          end
-          :ok
+      # We need to use Erlang modules at this point
+      # because we are not sure Elixir is available.
+      unquote(module_body_for(language))
+    end
+
+    {:module, ^name, binary, _} = Module.create(name, module_body, Macro.Env.location(__ENV__))
+    [{'#{name}.beam', binary}]
+  end
+
+  defp module_body_for(:elixir) do
+    quote do
+      def main(args) do
+        case :application.ensure_all_started(:elixir) do
+          {:ok, _} ->
+            load_config(@config)
+            start_app(@app)
+            args = Enum.map(args, &List.to_string(&1))
+            Kernel.CLI.run fn _ -> @module.main(args) end, true
+          _ ->
+            :io.put_chars :standard_error, "Elixir is not available, aborting.\n"
+            :erlang.halt(1)
         end
+      end
 
-        defp start_app(nil) do
-          :ok
+      defp load_config(config) do
+        for {app, kw} <- config, {k, v} <- kw do
+          :application.set_env(app, k, v, persistent: true)
         end
+        :ok
+      end
 
-        defp start_app(app) do
-          case :application.ensure_all_started(app) do
-            {:ok, _} -> :ok
-            {:error, {app, reason}} ->
-              io_error "Could not start application #{app}: " <>
-                Application.format_error(reason)
-              System.halt(1)
-          end
+      defp start_app(nil) do
+        :ok
+      end
+
+      defp start_app(app) do
+        case :application.ensure_all_started(app) do
+          {:ok, _} -> :ok
+          {:error, {app, reason}} ->
+            io_error "Could not start application #{app}: " <>
+              Application.format_error(reason)
+            System.halt(1)
         end
+      end
+
+      defp io_error(message) do
+        IO.puts :stderr, IO.ANSI.format([:red, :bright, message])
+      end
+    end
+  end
+
+  defp module_body_for(:erlang) do
+    quote do
+      def main(args) do
+        load_config(@config)
+        start_app(@app)
+        @module.main(args)
+      end
 
-        defp io_error(message) do
-          IO.puts :stderr, IO.ANSI.format([:red, :bright, message])
+      defp load_config(config) do
+        :lists.foreach(fn {app, kw} ->
+          :lists.foreach(fn {k, v} ->
+            :application.set_env(app, k, v, persistent: true)
+          end, kw)
+        end, config)
+        :ok
+      end
+
+      defp start_app(nil) do
+        :ok
+      end
+
+      defp start_app(app) do
+        case :application.ensure_all_started(app) do
+          {:ok, _} -> :ok
+          {:error, {app, reason}} ->
+            io_error ["Could not start application #{app}: ",
+                                              :io_lib.format('~p~n', [reason])]
+            :erlang.halt(1)
         end
       end
 
-    [{'#{name}.beam', binary}]
+      defp io_error(message) do
+        :io.put_chars(:standard_error, message)
+      end
+    end
   end
 end

lib/mix/test/fixtures/escripttest/config/config.exs

@@ -0,0 +1,3 @@
+use Mix.Config
+
+config :escripttest, erlval: "Erlang value"

lib/mix/test/fixtures/escripttest/src/escripttest.erl

@@ -0,0 +1,11 @@
+-module(escripttest).
+
+-export([start/0, main/1]).
+
+
+start() ->
+    ok = application:start(escripttest).
+
+main(_Args) ->
+    {ok, Val} = application:get_env(escripttest, erlval),
+    io:put_chars(Val).

lib/mix/test/mix/tasks/escript_test.exs

@@ -42,6 +42,19 @@ defmodule Mix.Tasks.EscriptTest do
     end
   end
 
+  defmodule EscriptErlangWithDeps do
+    def project do
+      [ app: :escripttesterlangwithdeps,
+        version: "0.0.1",
+        language: :erlang,
+        escript: [
+          main_module: :escripttest,
+          path: Path.join("ebin", "escripttesterlangwithdeps"),
+        ],
+        deps: [{:ok, path: fixture_path("deps_status/deps/ok")}] ]
+    end
+  end
+
   test "generate escript" do
     Mix.Project.push Escript
 
@@ -90,4 +103,16 @@ defmodule Mix.Tasks.EscriptTest do
   after
     purge [Ok.Mixfile]
   end
+
+  test "generate Erlang escript with config and deps" do
+    Mix.Project.push EscriptErlangWithDeps
+
+    in_fixture "escripttest", fn ->
+      Mix.Tasks.Escript.Build.run []
+      assert_received {:mix_shell, :info, ["Generated escript ebin/escripttesterlangwithdeps with MIX_ENV=dev"]}
+      assert System.cmd("escript", ["ebin/escripttesterlangwithdeps"]) == {"Erlang value", 0}
+    end
+  after
+    purge [Ok.Mixfile]
+  end
 end