Support ports on precompiled and use consistent option naming (#64)

Author: josevalim

PRECOMPILATION_GUIDE.md

@@ -26,7 +26,7 @@ def deps do
 end
 ```
 
-Then add `:elixir_make` to the `compilers` list, and set `CCPrecompile` as the value for `make_precompiler`.
+Then add `:elixir_make` to the `compilers` list, and set the type (`:nif` or `:port`) and `CCPrecompile` as the value for `:make_precompiler`.
 
 ```elixir
 @version "0.1.0"
@@ -35,20 +35,20 @@ def project do
     # ...
     compilers: [:elixir_make] ++ Mix.compilers(),
     # elixir_make specific config
-    make_precompiler: CCPrecompiler,
-    make_precompiled_url: "https://github.com/cocoa-xu/cc_precompiler_example/releases/download/v#{@version}/@{artefact_filename}",
-    make_nif_filename: "nif",
+    make_precompiler: {:nif, CCPrecompiler},
+    make_precompiler_url: "https://github.com/cocoa-xu/cc_precompiler_example/releases/download/v#{@version}/@{artefact_filename}",
+    make_precompiler_filename: "nif",
     make_precompiler_priv_paths: ["nif.*"]
     # ...
   ]
 end
 ```
 
-Another required field is `make_precompiled_url`. It is a URL template to the artefact file.
+Another required field is `make_precompiler_url`. It is a URL template to the artefact file.
 
 `@{artefact_filename}` in the URL template string will be replaced by corresponding artefact filenames when fetching them. For example, `cc_precompiler_example-nif-2.16-x86_64-linux-gnu-0.1.0.tar.gz`.
 
-Note that there is an optional config key for elixir_make, `make_nif_filename`. If the name (file extension does not count) of the shared library is different from your app's name, then `make_nif_filename` should be set. For example, if the app name is `"cc_precompiler_example"` while the name shared library is `"nif.so"` (or `"nif.dll"` on windows), then `make_nif_filename` should be set as `"nif"`.
+Note that there is an optional config key for elixir_make, `make_precompiler_filename`. If the name (file extension does not count) of the shared library is different from your app's name, then `make_precompiler_filename` should be set. For example, if the app name is `"cc_precompiler_example"` while the name shared library is `"nif.so"` (or `"nif.dll"` on windows), then `make_precompiler_filename` should be set as `"nif"`.
 
 Another optional config key is `make_precompiler_priv_paths`. For example, say the `priv` directory is organised as follows in Linux, macOS and Windows respectively,
 

lib/elixir_make/artefact.ex

@@ -66,7 +66,13 @@ defmodule ElixirMake.Artefact do
   end
 
   defp archive_filename(config, target) do
-    "#{config[:app]}-nif-#{:erlang.system_info(:nif_version)}-#{target}-#{config[:version]}.tar.gz"
+    case config[:make_precompiler] do
+      {:nif, _} ->
+        "#{config[:app]}-nif-#{:erlang.system_info(:nif_version)}-#{target}-#{config[:version]}.tar.gz"
+
+      {type, _} ->
+        "#{config[:app]}-#{type}-#{target}-#{config[:version]}.tar.gz"
+    end
   end
 
   @doc """
@@ -138,12 +144,12 @@ defmodule ElixirMake.Artefact do
   @doc """
   Returns all available target-url pairs available.
   """
-  def available_nif_urls(config, precompiler) do
+  def available_target_urls(config, precompiler) do
     targets = precompiler.all_supported_targets(:fetch)
 
     url_template =
-      config[:make_precompiled_url] ||
-        Mix.raise("`make_precompiled_url` is not specified in `project`")
+      config[:make_precompiler_url] ||
+        Mix.raise("`make_precompiler_url` is not specified in `project`")
 
     Enum.map(targets, fn target ->
       archive_filename = archive_filename(config, target)
@@ -154,10 +160,10 @@ defmodule ElixirMake.Artefact do
   @doc """
   Returns the url for the current target.
   """
-  def current_target_nif_url(config, precompiler) do
+  def current_target_url(config, precompiler) do
     case precompiler.current_target() do
       {:ok, current_target} ->
-        available_urls = available_nif_urls(config, precompiler)
+        available_urls = available_target_urls(config, precompiler)
 
         case List.keyfind(available_urls, current_target, 0) do
           {^current_target, download_url} ->

lib/mix/tasks/compile.elixir_make.ex

@@ -56,13 +56,19 @@ defmodule Mix.Tasks.Compile.ElixirMake do
 
   The following options configure precompilation:
 
-    * `:make_precompiler` - the precompiled module to use. Defaults to none.
-
-    * `:make_precompiled_url` - the download URL template. Defaults to none.
+    * `:make_precompiler` - a two-element tuple with the precompiled type
+      and module to use. The precompile type is either `:nif` or `:port`
+      and then the precompilation module. If the type is a `:nif`, it looks
+      for a DDL or a shared object as precompilation target given by
+      `:make_precompiler_filename` and the current NIF version is part of
+      the precompiled archive. If `:port`, it looks for an executable with
+      `:make_precompiler_filename`.
+
+    * `:make_precompiler_url` - the download URL template. Defaults to none.
       Required when `make_precompiler` is set.
 
-    * `:make_nif_filename` - the filename of the compiled NIF without extension.
-      Defaults to the app name.
+    * `:make_precompiler_filename` - the filename of the compiled artefact
+      without its extension. Defaults to the app name.
 
     * `:make_force_build` - if build should be forced even if precompiled artefacts
       are available. Defaults to true if the app has a `-dev` version flag.
@@ -118,7 +124,7 @@ defmodule Mix.Tasks.Compile.ElixirMake do
     app = config[:app]
     version = config[:version]
     force_build = pre_release?(version) or Keyword.get(config, :make_force_build, false)
-    precompiler = config[:make_precompiler]
+    {precompiler_type, precompiler} = config[:make_precompiler] || {nil, nil}
 
     cond do
       precompiler == nil ->
@@ -128,19 +134,24 @@ defmodule Mix.Tasks.Compile.ElixirMake do
         precompiler.build_native(args)
 
       true ->
-        nif_filename = config[:make_nif_filename] || "#{app}"
-        app_priv = Path.join(Mix.Project.app_path(config), "priv")
-
-        load_path =
-          case :os.type() do
-            {:win32, _} -> Path.join(app_priv, "#{nif_filename}.dll")
-            _ -> Path.join(app_priv, "#{nif_filename}.so")
+        rootname = config[:make_precompiler_filename] || "#{app}"
+
+        extname =
+          case {precompiler_type, :os.type()} do
+            {:nif, {:win32, _}} -> ".dll"
+            {:nif, _} -> ".so"
+            {:port, {:win32, _}} -> ".exe"
+            {:port, _} -> ""
+            {_, _} -> raise_unknown_precompiler_type(precompiler_type)
           end
 
+        app_priv = Path.join(Mix.Project.app_path(config), "priv")
+        load_path = Path.join(app_priv, rootname <> extname)
+
         with false <- File.exists?(load_path),
-             {:error, precomp_error} <- download_or_reuse_nif(config, precompiler, app_priv) do
+             {:error, message} <- download_or_reuse_nif(config, precompiler, app_priv) do
           Mix.shell().error("""
-          Error happened while installing #{app} from precompiled binary: #{precomp_error}.
+          Error happened while installing #{app} from precompiled binary: #{message}.
 
           Attempting to compile #{app} from source...\
           """)
@@ -152,6 +163,10 @@ defmodule Mix.Tasks.Compile.ElixirMake do
     end
   end
 
+  defp raise_unknown_precompiler_type(precompiler_type) do
+    Mix.raise("Unknown precompiler type: #{inspect(precompiler_type)} (expected :nif or :port)")
+  end
+
   # This is called by Elixir when `mix clean` runs
   # and `:elixir_make` is in the list of compilers.
   @doc false
@@ -171,7 +186,7 @@ defmodule Mix.Tasks.Compile.ElixirMake do
   end
 
   defp download_or_reuse_nif(config, precompiler, app_priv) do
-    case Artefact.current_target_nif_url(config, precompiler) do
+    case Artefact.current_target_url(config, precompiler) do
       {:ok, target, url} ->
         archived_fullpath = Artefact.archive_path(config, target)
 

lib/mix/tasks/elixir_make.checksum.ex

@@ -32,7 +32,7 @@ defmodule Mix.Tasks.ElixirMake.Checksum do
   def run(flags) when is_list(flags) do
     config = Mix.Project.config()
 
-    precompiler =
+    {_, precompiler} =
       config[:make_precompiler] ||
         Mix.raise(
           ":make_precompiler project configuration is required when using elixir_make.checksum"
@@ -43,10 +43,10 @@ defmodule Mix.Tasks.ElixirMake.Checksum do
     urls =
       cond do
         Keyword.get(options, :all) ->
-          Artefact.available_nif_urls(config, precompiler)
+          Artefact.available_target_urls(config, precompiler)
 
         Keyword.get(options, :only_local) ->
-          case Artefact.current_target_nif_url(config, precompiler) do
+          case Artefact.current_target_url(config, precompiler) do
             {:ok, target, url} -> [{target, url}]
             {:error, error} -> Mix.raise(error)
           end

lib/mix/tasks/elixir_make.precompile.ex

@@ -4,7 +4,12 @@ defmodule Mix.Tasks.ElixirMake.Precompile do
   @moduledoc """
   Precompiles the given project for all targets.
 
-  This is only supported if `make_precompiler` is specified.
+  This task must only be used by package creators who want to ship the
+  precompiled NIFs. This task is often used on CI to precompile
+  for different targets.
+
+  This is only supported if `:make_precompiler` is specified
+  in your project configuration.
   """
 
   alias ElixirMake.Artefact
@@ -16,15 +21,15 @@ defmodule Mix.Tasks.ElixirMake.Precompile do
     config = Mix.Project.config()
     paths = config[:make_precompiler_priv_paths] || ["."]
 
-    try do
-      precompiler =
-        config[:make_precompiler] ||
-          Mix.raise(
-            ":make_precompiler project configuration is required when using elixir_make.precompile"
-          )
+    {_, precompiler} =
+      config[:make_precompiler] ||
+        Mix.raise(
+          ":make_precompiler project configuration is required when using elixir_make.precompile"
+        )
 
-      targets = precompiler.all_supported_targets(:compile)
+    targets = precompiler.all_supported_targets(:compile)
 
+    try do
       precompiled_artefacts =
         Enum.map(targets, fn target ->
           case precompiler.precompile(args, target) do

test/mix/tasks/compile.make_test.exs

@@ -318,7 +318,7 @@ defmodule Mix.Tasks.Compile.ElixirMakeTest do
       build_file = "build_file"
 
       precompile_config = [
-        make_precompiler: MyApp.Precompiler,
+        make_precompiler: {:nif, MyApp.Precompiler},
         make_precompiler_priv_paths: ["include_this*.txt", "symlink_to_lib", "lib", build_file],
         make_force_build: true
       ]