Precompiled deps

README.md

@@ -126,8 +126,19 @@ Configuration of each native may contain following options:
 * `includes` - Paths to look for header files (empty list by default).
 * `lib_dirs` - Absolute paths to look for libraries (empty list by default).
 * `libs` - Names of libraries to link (empty list by default).
-* `pkg_configs` - Names of libraries for which the appropriate flags will be
+* `pkg_configs` - (deprecated) Names of libraries for which the appropriate flags will be
 obtained using pkg-config (empty list by default).
+* `os_deps` - List of external OS dependencies. It's a list of tuples in the form of 
+  `{provider | [provider], lib_name | [lib_name]}` where `provider` is either `:pkg_config` 
+  or a tuple `{:precompiled, <string representing URL to the precompiled library>}` and `lib_name` 
+  is a string representing a library that should be provided by a given providers. 
+  In case `pkg_config` provider is used, the `pkg-config` will be used to resolve the compilation 
+  and linking flags (note that the given libary needs to be previously installed in the system). 
+  In case `{:precompiled, <string representing URL to the precompiled library>}` is used, 
+  the precompiled library will be first downloaded from the provider URL and appropriate compilation 
+  and linking flags will be set. 
+  The list of providers is resolved with the order of elements in the providers list - 
+  in case one provider fails to provide a library, the next provider from the list is tried.
 * `deps` - Dependencies in the form of `{app, lib_name}`, where `app`
 is the application name of the dependency, and `lib_name` is the name of lib
 specified in Bundlex project of this dependency. Empty list by default. See _Dependencies_ section below

lib/bundlex.ex

@@ -8,6 +8,31 @@ defmodule Bundlex do
 
   @type platform_t :: :linux | :macosx | :windows32 | :windows64
 
+  @typedoc """
+  A map containing three fields that describe the platform.
+
+  It consists of:
+  * architecture - e.g. `x86_64` or `arm64`
+  * vendor - e.g. `pc`
+  * os - operating system, e.g. `linux` or `darwin20.6.0`
+  """
+  @type target ::
+          %{architecture: String.t(), vendor: String.t(), os: String.t()}
+  @doc """
+  A function returning a target triplet for the environment on which it is run.
+  """
+  @spec get_target() :: target()
+  def get_target() do
+    [architecture, vendor, os | _rest] =
+      :erlang.system_info(:system_architecture) |> List.to_string() |> String.split("-")
+
+    %{
+      architecture: architecture,
+      vendor: vendor,
+      os: os
+    }
+  end
+
   @doc """
   Returns current platform name.
   """

lib/bundlex/cnode/server.ex

@@ -19,7 +19,7 @@ defmodule Bundlex.CNode.Server do
         {:spawn_executable, Bundlex.build_path(opts.app, opts.native_name, :cnode)},
         args: [host_name(), name, cnode, "#{creation}"],
         line: 2048,
-        env: [{'BUNDLEX_ERLANG_COOKIE', cookie}]
+        env: [{~c"BUNDLEX_ERLANG_COOKIE", cookie}]
       )
 
     Process.send_after(self(), :timeout, 5000)
@@ -39,7 +39,7 @@ defmodule Bundlex.CNode.Server do
 
   @impl true
   def handle_info(
-        {port, {:data, {:eol, 'ready'}}},
+        {port, {:data, {:eol, ~c"ready"}}},
         %{port: port, status: :waiting, msg_part?: false} = state
       ) do
     case Node.connect(state.cnode) do

lib/bundlex/loader.ex

@@ -131,6 +131,7 @@ defmodule Bundlex.Loader do
     quote do
       app = unquote(app || MixHelper.get_app!())
       nif_name = unquote(nif_name)
+
       path = Bundlex.build_path(app, nif_name, :nif)
 
       with :ok <- :erlang.load_nif(path |> PathHelper.fix_slashes() |> to_charlist(), 0) do

lib/bundlex/native.ex

@@ -5,21 +5,31 @@ defmodule Bundlex.Native do
 
   use Bunch
 
+  require Logger
   alias Bundlex.Helper.ErlangHelper
   alias Bundlex.{Output, Platform, Project}
   alias Bundlex.Project.Preprocessor
+  alias Bundlex.Toolchain.Common.Unix.OSDeps
 
   @type name_t :: atom()
   @type interface_t :: :nif | :cnode | :port
   @type language_t :: :c | :cpp
 
+  @type lib_name :: String.t()
+  @type precompiled_dependency_url :: String.t()
+  @type os_dep_provider :: :pkg_config | {:precompiled, precompiled_dependency_url} | nil
+
+  @type os_dep ::
+          {os_dep_provider() | [os_dep_provider()], lib_name() | [lib_name()]}
+
   @type t :: %__MODULE__{
           name: atom,
           app: Application.app(),
           type: :native | :lib,
           includes: [String.t()],
           libs: [String.t()],
           lib_dirs: [String.t()],
+          os_deps: [os_dep()],
           pkg_configs: [String.t()],
           sources: [String.t()],
           deps: [t],
@@ -38,6 +48,7 @@ defmodule Bundlex.Native do
             includes: [],
             libs: [],
             lib_dirs: [],
+            os_deps: [],
             pkg_configs: [],
             sources: [],
             deps: [],
@@ -104,7 +115,21 @@ defmodule Bundlex.Native do
         |> Map.update!(:sources, &Enum.uniq/1)
         |> Map.update!(:deps, fn deps -> Enum.uniq_by(deps, &{&1.app, &1.name}) end)
 
-      commands = Platform.get_module(platform).toolchain_module.compiler_commands(native)
+      native =
+        if native.pkg_configs != [] do
+          IO.warn("`pkg_configs` option has been deprecated. Please use `os_deps` option.")
+          %{native | os_deps: [{:pkg_config, native.pkg_configs} | native.os_deps]}
+        else
+          native
+        end
+
+      native_with_resolved_os_deps = OSDeps.resolve_os_deps(native)
+
+      commands =
+        Platform.get_module(platform).toolchain_module.compiler_commands(
+          native_with_resolved_os_deps
+        )
+
       {:ok, commands}
     end
   end
@@ -197,7 +222,15 @@ defmodule Bundlex.Native do
   defp merge_dep(%__MODULE__{type: :lib} = dependency, %__MODULE__{} = native) do
     Map.merge(
       native,
-      Map.take(dependency, [:includes, :libs, :lib_dirs, :pkg_configs, :linker_flags, :deps]),
+      Map.take(dependency, [
+        :includes,
+        :libs,
+        :lib_dirs,
+        :os_deps,
+        :pkg_configs,
+        :linker_flags,
+        :deps
+      ]),
       fn _k, v1, v2 -> v2 ++ v1 end
     )
   end

lib/bundlex/platform.ex

@@ -45,8 +45,11 @@ defmodule Bundlex.Platform do
     case :os.type() do
       {:win32, _} ->
         {:ok, reg} = :win32reg.open([:read])
-        :ok = :win32reg.change_key(reg, '\\hklm\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion')
-        {:ok, build} = :win32reg.value(reg, 'BuildLabEx')
+
+        :ok =
+          :win32reg.change_key(reg, ~c"\\hklm\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion")
+
+        {:ok, build} = :win32reg.value(reg, ~c"BuildLabEx")
 
         platform_name =
           if build |> to_string |> String.contains?("amd64") do

lib/bundlex/project.ex

@@ -21,7 +21,7 @@ defmodule Bundlex.Project do
   * `includes` - Paths to look for header files (empty list by default).
   * `lib_dirs` - Paths to look for libraries (empty list by default).
   * `libs` - Names of libraries to link (empty list by default).
-  * `pkg_configs` - Names of libraries for which the appropriate flags will be
+  * `pkg_configs` - (deprecated) Names of libraries for which the appropriate flags will be
   obtained using pkg-config (empty list by default).
   * `deps` - Dependencies in the form of `{app, lib_name}`, where `app`
   is the application name of the dependency, and `lib_name` is the name of lib
@@ -40,6 +40,7 @@ defmodule Bundlex.Project do
           includes: [String.t()],
           lib_dirs: [String.t()],
           libs: [String.t()],
+          os_deps: [Bundlex.Native.os_dep()],
           pkg_configs: [String.t()],
           deps: [{Application.app(), native_name_t | [native_name_t]}],
           src_base: String.t(),
@@ -57,6 +58,7 @@ defmodule Bundlex.Project do
       :libs,
       :lib_dirs,
       :pkg_configs,
+      :os_deps,
       :sources,
       :deps,
       :compiler_flags,

lib/bundlex/toolchain/common/unix.ex

@@ -2,7 +2,7 @@ defmodule Bundlex.Toolchain.Common.Unix do
   @moduledoc false
 
   use Bunch
-  alias Bundlex.{Native, Output, Toolchain}
+  alias Bundlex.{Native, Toolchain}
   alias Bundlex.Toolchain.Common.Compilers
 
   @spec compiler_commands(
@@ -14,7 +14,7 @@ defmodule Bundlex.Toolchain.Common.Unix do
         ) :: [String.t()]
   def compiler_commands(native, compile, link, lang, options \\ []) do
     includes = native.includes |> paths("-I")
-    pkg_config_cflags = pkg_config(native, :cflags)
+
     compiler_flags = resolve_compiler_flags(native.compiler_flags, native.interface, lang)
     output = Toolchain.output_path(native.app, native.name, native.interface)
     output_obj = output <> "_obj"
@@ -34,7 +34,7 @@ defmodule Bundlex.Toolchain.Common.Unix do
       |> Enum.map(fn {source, object} ->
         """
         #{compile} -Wall -Wextra -c -O2 -g #{compiler_flags} \
-        -o #{path(object)} #{includes} #{pkg_config_cflags} #{path(source)}
+        -o #{path(object)} #{includes} #{path(source)}
         """
       end)
 
@@ -95,8 +95,8 @@ defmodule Bundlex.Toolchain.Common.Unix do
 
     [
       """
-      #{link} #{linker_flags} -o #{path(output <> extension)} \
-      #{deps} #{paths(objects)} #{libs(native)}
+      #{link} -o #{path(output <> extension)} \
+      #{deps} #{paths(objects)} #{libs(native)} #{linker_flags}
       """
     ]
   end
@@ -113,41 +113,7 @@ defmodule Bundlex.Toolchain.Common.Unix do
   defp libs(native) do
     lib_dirs = native.lib_dirs |> paths("-L")
     libs = native.libs |> Enum.map_join(" ", fn lib -> "-l#{lib}" end)
-    pkg_config_libs = pkg_config(native, :libs)
-    "#{pkg_config_libs} #{lib_dirs} #{libs}"
-  end
-
-  defp pkg_config(%Native{pkg_configs: []}, _options), do: ""
-
-  defp pkg_config(%Native{pkg_configs: packages, app: app}, options) do
-    options = options |> Bunch.listify() |> Enum.map(&"--#{&1}")
-    System.put_env("PATH", System.get_env("PATH", "") <> ":/usr/local/bin:/opt/homebrew/bin")
 
-    case System.cmd("which", ["pkg-config"]) do
-      {_path, 0} ->
-        :ok
-
-      {_path, _error} ->
-        Output.raise("""
-        pkg-config not found. Bundlex needs pkg-config to find packages in system.
-        On Mac OS, you can install pkg-config via Homebrew by typing `brew install pkg-config`.
-        """)
-    end
-
-    Enum.map_join(packages, " ", fn package ->
-      case System.cmd("pkg-config", options ++ [package], stderr_to_stdout: true) do
-        {output, 0} ->
-          String.trim_trailing(output)
-
-        {output, error} ->
-          Output.raise("""
-          Couldn't find system package #{package} with pkg-config. Check whether it's installed.
-          Installation instructions may be available in the readme of package #{app}.
-          Output from pkg-config:
-          Error: #{error}
-          #{output}
-          """)
-      end
-    end)
+    "#{lib_dirs} #{libs}"
   end
 end