Merge pull request #2687 from alco/mix-language-setting

Mix language setting

Author: alco

lib/mix/lib/mix/project.ex

@@ -11,7 +11,7 @@ defmodule Mix.Project do
 
         def project do
           [app: :my_app,
-           vsn: "0.6.0"]
+           version: "0.6.0"]
         end
       end
 
@@ -24,6 +24,16 @@ defmodule Mix.Project do
   function in the project, the developer can call `Mix.Project.get!/0`
   which fails with `Mix.NoProjectError` in case a project is not
   defined.
+
+  ## Erlang projects
+
+  Mix can be used to manage Erlang projects that don't have any Elixir code. To
+  ensure mix tasks work correctly for an Erlang project, `language: :erlang`
+  has to be added to `project`.
+
+  The setting also makes sure Elixir is not added as a dependency to the
+  generated .app file or to the escript generated with `mix escript.build`,
+  etc.
   """
 
   @doc false

lib/mix/lib/mix/tasks/compile.app.ex

@@ -90,8 +90,9 @@ defmodule Mix.Tasks.Compile.App do
       end
 
       # Ensure we always prepend the standard application dependencies
+      core_apps = [:kernel, :stdlib] ++ language_app(config)
       properties = Keyword.update!(properties, :applications, fn apps ->
-        [:kernel, :stdlib, :elixir] ++ apps
+        core_apps ++ apps
       end)
 
       properties = ensure_correct_properties(app, config, properties)
@@ -129,6 +130,14 @@ defmodule Mix.Tasks.Compile.App do
     Enum.map beams, &(&1 |> Path.basename |> Path.rootname(".beam") |> String.to_atom)
   end
 
+  defp language_app(config) do
+    case Keyword.fetch(config, :language) do
+      {:ok, :elixir} -> [:elixir]
+      {:ok, :erlang} -> []
+      :error -> [:elixir]
+    end
+  end
+
   defp ensure_correct_properties(app, config, properties) do
     properties
     |> Keyword.put_new(:description, to_char_list(config[:description] || app))

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"`.
@@ -56,6 +56,13 @@ defmodule Mix.Tasks.Escript.Build do
     * `:emu_args` - emulator arguments to embed in the escript file.
       Defaults to `""`.
 
+  There is one project-level option that affects how the escript is generated:
+
+    * `language: :elixir | :erlang` - set it to `:erlang` for Erlang projects
+      managed by mix. Doing so will ensure Elixir is not embedded by default.
+      Your app will still be started as part of escript loading, with the
+      config used during build.
+
   ## Example
 
       defmodule MyApp.Mixfile do
@@ -90,6 +97,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 +111,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 +165,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 +199,80 @@ 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
+      def main(args) do
+        unquote(main_body_for(language))
+      end
+
+      defp load_config(config) do
+        :lists.foreach(fn {app, kw} ->
+          :lists.foreach(fn {k, v} ->
             :application.set_env(app, k, v, persistent: true)
-          end
-          :ok
-        end
+          end, kw)
+        end, config)
+        :ok
+      end
 
-        defp start_app(nil) do
-          :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}: " <>
-                Application.format_error(reason)
-              System.halt(1)
-          end
+      defp start_app(app) do
+        case :application.ensure_all_started(app) do
+          {:ok, _} -> :ok
+          {:error, {app, reason}} ->
+            formatted_error = case :code.ensure_loaded(Application) do
+              {:module, Application} -> Application.format_error(reason)
+              {:error, _} -> :io_lib.format('~p', [reason])
+            end
+            io_error ["Could not start application ",
+                      :erlang.atom_to_binary(app, :utf8),
+                      ": ", formatted_error, ?\n]
+            :erlang.halt(1)
         end
+      end
 
-        defp io_error(message) do
-          IO.puts :stderr, IO.ANSI.format([:red, :bright, message])
-        end
+      defp io_error(message) do
+        :io.put_chars(:standard_error, message)
       end
+    end
 
+    {:module, ^name, binary, _} = Module.create(name, module_body, Macro.Env.location(__ENV__))
     [{'#{name}.beam', binary}]
   end
+
+  defp main_body_for(:elixir) do
+    quote 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
+  end
+
+  defp main_body_for(:erlang) do
+    quote do
+      load_config(@config)
+      start_app(@app)
+      @module.main(args)
+    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