Rebar3 dependency support

Author: ericmj

lib/mix/lib/mix/dep.ex

@@ -23,7 +23,7 @@ defmodule Mix.Dep do
     * `top_level` - true if dependency was defined in the top-level project
 
     * `manager` - the project management, possible values:
-      `:rebar` | `:mix` | `:make` | `nil`
+      `:rebar` | `:rebar3` | `:mix` | `:make` | `nil`
 
     * `from` - path to the file where the dependency was defined
 
@@ -57,7 +57,7 @@ defmodule Mix.Dep do
                status: atom,
                opts: Keyword.t,
                top_level: boolean,
-               manager: :rebar | :mix | :make | nil,
+               manager: :rebar | :rebar3 | :mix | :make | nil,
                from: String.t,
                extra: term}
 
@@ -343,7 +343,7 @@ defmodule Mix.Dep do
   Returns `true` if dependency is a rebar project.
   """
   def rebar?(%Mix.Dep{manager: manager}) do
-    manager == :rebar
+    manager in [:rebar, :rebar3]
   end
 
   @doc """

lib/mix/lib/mix/dep/converger.ex

@@ -65,8 +65,7 @@ defmodule Mix.Dep.Converger do
     # iteration.
     {deps, rest, lock} =
       all(main, only, [], current, callback, acc, lock, fn dep ->
-        if (converger = Mix.RemoteConverger.get) &&
-           converger.remote?(dep) do
+        if (converger = Mix.RemoteConverger.get) && converger.remote?(dep) do
           {:loaded, dep}
         else
           {:unloaded, dep, nil}
@@ -79,21 +78,21 @@ defmodule Mix.Dep.Converger do
 
     # Run remote converger if one is available and rerun Mix's
     # converger with the new information
-    if converger = Mix.RemoteConverger.get do
+    if remote = Mix.RemoteConverger.get do
       # If there is a lock, it means we are doing a get/update
       # and we need to hit the remote converger which do external
       # requests and what not. In case of deps.check, deps and so
       # on, there is no lock, so we won't hit this branch.
       if lock do
-        lock = converger.converge(deps, lock)
+        lock = remote.converge(deps, lock)
       end
 
       deps = deps
-             |> Enum.reject(&converger.remote?(&1))
+             |> Enum.reject(&remote.remote?(&1))
              |> Enum.into(%{}, &{&1.app, &1})
 
       # In case there is no lock, we will read the current lock
-      # which is potentially stale. So converger.deps/2 needs to
+      # which is potentially stale. So remote.deps/2 needs to
       # always check if the data it finds in the lock is actually
       # valid.
       lock_for_converger = lock || Mix.Dep.Lock.read
@@ -103,7 +102,7 @@ defmodule Mix.Dep.Converger do
           cached = deps[dep.app] ->
             {:loaded, cached}
           true ->
-            {:unloaded, dep, converger.deps(dep, lock_for_converger)}
+            {:unloaded, dep, remote.deps(dep, lock_for_converger)}
         end
       end)
     else
@@ -258,13 +257,12 @@ defmodule Mix.Dep.Converger do
   end
 
   defp converge?(%Mix.Dep{scm: scm1, opts: opts1}, %Mix.Dep{scm: scm2, opts: opts2}) do
-    scm1 == scm2 and mix_equal?(opts1, opts2) and scm1.equal?(opts1, opts2)
+    scm1 == scm2 and opts_equal?(opts1, opts2) and scm1.equal?(opts1, opts2)
   end
 
-  defp mix_equal?(opts1, opts2) do
-    Keyword.fetch(opts1, :app) == Keyword.fetch(opts2, :app) and
-      Keyword.fetch(opts1, :env) == Keyword.fetch(opts2, :env) and
-      Keyword.fetch(opts1, :compile) == Keyword.fetch(opts2, :compile)
+  defp opts_equal?(opts1, opts2) do
+    keys = ~w(app env compile manager)a
+    Enum.all?(keys, &(Keyword.fetch(opts1, &1) == Keyword.fetch(opts2, &1)))
   end
 
   defp reject_non_fullfilled_optional(children, upper_breadths) do

lib/mix/lib/mix/dep/loader.ex

@@ -4,6 +4,8 @@
 defmodule Mix.Dep.Loader do
   @moduledoc false
 
+  import Mix.Dep, only: [ok?: 1, mix?: 1, rebar?: 1, make?: 1]
+
   @doc """
   Gets all direct children of the current `Mix.Project`
   as a `Mix.Dep` struct. Umbrella project dependencies
@@ -37,25 +39,27 @@ defmodule Mix.Dep.Loader do
   Loads the given dependency information, including its
   latest status and children.
   """
-  def load(dep, children) do
-    %Mix.Dep{manager: manager, scm: scm, opts: opts} = dep
-    dep  = %{dep | status: scm_status(scm, opts)}
-    dest = opts[:dest]
+  def load(%Mix.Dep{manager: manager, scm: scm, opts: opts} = dep, children) do
+    manager = opts[:manager] ||
+              scm_manager(scm, opts) ||
+              select_manager(manager, opts[:dest])
+
+    dep = %{dep | manager: manager, status: scm_status(scm, opts)}
 
     {dep, children} =
       cond do
-        not ok?(dep.status) ->
+        not ok?(dep) ->
           {dep, []}
 
-        mix?(dest) ->
+        mix?(dep) ->
           mix_dep(dep, children)
 
         # If not an explicit rebar or Mix dependency
         # but came from rebar, assume to be a rebar dep.
-        rebar?(dest) or manager == :rebar ->
-          rebar_dep(dep, children)
+        rebar?(dep) ->
+          rebar_dep(dep, children, manager)
 
-        make?(dest) ->
+        make?(dep) ->
           make_dep(dep)
 
         true ->
@@ -155,11 +159,18 @@ defmodule Mix.Dep.Loader do
   end
 
   defp get_scm(app, opts) do
-    Enum.find_value Mix.SCM.available, {nil, opts}, fn(scm) ->
+    Enum.find_value Mix.SCM.available, {nil, opts}, fn scm ->
       (new = scm.accepts_options(app, opts)) && {scm, new}
     end
   end
 
+  @managers ~w(mix rebar rebar3 make)a
+
+  defp scm_manager(scm, opts) do
+    managers = scm.managers(opts)
+    Enum.find(@managers, &(&1 in managers))
+  end
+
   defp scm_status(scm, opts) do
     if scm.checked_out?(opts) do
       {:ok, nil}
@@ -168,19 +179,21 @@ defmodule Mix.Dep.Loader do
     end
   end
 
-  defp ok?({:ok, _}), do: true
-  defp ok?(_), do: false
-
-  defp mix?(dest) do
-    any_of?(dest, ["mix.exs"])
-  end
-
-  defp rebar?(dest) do
-    any_of?(dest, ["rebar", "rebar.config", "rebar.config.script"])
+  defp select_manager(nil, dest) do
+    cond do
+      any_of?(dest, ["mix.exs"]) ->
+        :mix
+      any_of?(dest, ["rebar", "rebar.config", "rebar.config.script"]) ->
+        :rebar
+      any_of?(dest, ["Makefile", "Makefile.win"]) ->
+        :make
+      true ->
+        nil
+    end
   end
 
-  defp make?(dest) do
-    any_of?(dest, ["Makefile", "Makefile.win"])
+  defp select_manager(manager, _dest) do
+    manager
   end
 
   defp any_of?(dest, files) do
@@ -227,7 +240,7 @@ defmodule Mix.Dep.Loader do
       end
 
       deps = mix_children(env: opts[:env] || :prod) ++ Mix.Dep.Umbrella.unloaded
-      {%{dep | manager: :mix, opts: opts}, deps}
+      {%{dep | opts: opts}, deps}
     end)
   end
 
@@ -238,25 +251,28 @@ defmodule Mix.Dep.Loader do
   defp mix_dep(%Mix.Dep{opts: opts} = dep, children) do
     from = Path.join(opts[:dest], "mix.exs")
     deps = Enum.map(children, &to_dep(&1, from))
-    {%{dep | manager: :mix}, deps}
+    {dep, deps}
   end
 
-  defp rebar_dep(%Mix.Dep{} = dep, children) do
+  defp rebar_dep(%Mix.Dep{app: app} = dep, children, manager) do
     Mix.Dep.in_dependency(dep, fn _ ->
-      rebar = Mix.Rebar.load_config(".")
-      extra = Keyword.take(rebar, [:sub_dirs])
-      deps  = if children do
+      config = Mix.Rebar.load_config(".")
+      extra = Mix.Rebar.merge_config(dep.extra, config)
+      deps   = if children do
         from = Path.absname("rebar.config")
-        Enum.map(children, &to_dep(&1, from, :rebar))
+        # Pass the manager because deps of a rebar project need
+        # to default to rebar if we cannot chose a manager from
+        # files in the dependency
+        Enum.map(children, &to_dep(&1, from, manager))
       else
-        rebar_children(rebar)
+        rebar_children(app, config, extra, manager)
       end
-      {%{dep | manager: :rebar, extra: extra}, deps}
+      {%{dep | extra: extra}, deps}
     end)
   end
 
   defp make_dep(dep) do
-    {%{dep | manager: :make}, []}
+    {dep, []}
   end
 
   defp validate_only!(only) do
@@ -274,18 +290,21 @@ defmodule Mix.Dep.Loader do
     |> elem(0)
   end
 
-  defp rebar_children(root_config) do
+  defp rebar_children(app, root_config, extra, manager) do
     from = Path.absname("rebar.config")
     Mix.Rebar.recur(root_config, fn config ->
-      Mix.Rebar.deps(config) |> Enum.map(&to_dep(&1, from, :rebar))
+      deps = Mix.Rebar.deps(app, config, extra[:overrides] || [])
+      Enum.map(deps, fn dep ->
+        %{to_dep(dep, from, manager) | extra: extra}
+      end)
     end) |> Enum.concat
   end
 
-  defp validate_app(%Mix.Dep{opts: opts, requirement: req, app: app, status: status} = dep) do
+  defp validate_app(%Mix.Dep{opts: opts, requirement: req, app: app} = dep) do
     opts_app = opts[:app]
 
     cond do
-      not ok?(status) ->
+      not ok?(dep) ->
         dep
       recently_fetched?(dep) ->
         %{dep | status: :compile}