Only pass overrides from parent to child rebar dep (#5687)

Signed-off-by: José Valim <[email protected]>

Author: josevalim

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

@@ -264,11 +264,13 @@ defmodule Mix.Dep.Loader do
     {dep, deps}
   end
 
-  defp rebar_dep(%Mix.Dep{app: app, opts: opts} = dep, children, manager) do
-    config = File.cd!(opts[:dest], fn ->
-      Mix.Rebar.load_config(".")
-    end)
-    extra = Mix.Rebar.merge_config(dep.extra, config)
+  defp rebar_dep(%Mix.Dep{app: app, opts: opts, extra: overrides} = dep, children, manager) do
+    config =
+      File.cd!(opts[:dest], fn -> Mix.Rebar.load_config(".") end)
+
+    config =
+      Mix.Rebar.apply_overrides(app, config, overrides)
+
     deps =
       if children do
         from = Path.join(opts[:dest], "rebar.config")
@@ -277,9 +279,10 @@ defmodule Mix.Dep.Loader do
         # files in the dependency
         Enum.map(children, &to_dep(&1, from, manager))
       else
-        rebar_children(app, config, extra, manager)
+        rebar_children(config, manager)
       end
-    {%{dep | extra: extra}, deps}
+
+    {%{dep | extra: config}, deps}
   end
 
   defp make_dep(dep) do
@@ -301,17 +304,18 @@ defmodule Mix.Dep.Loader do
     |> elem(0)
   end
 
-  defp rebar_children(app, root_config, extra, manager) do
+  defp rebar_children(root_config, manager) do
     from = Path.absname("rebar.config")
     Mix.Rebar.recur(root_config, fn config ->
-      app
-      |> Mix.Rebar.deps(config, overrides(manager, extra))
-      |> Enum.map(fn dep -> %{to_dep(dep, from, manager) | extra: extra} end)
+      overrides = overrides(manager, config)
+      config
+      |> Mix.Rebar.deps()
+      |> Enum.map(fn dep -> %{to_dep(dep, from, manager) | extra: overrides} end)
     end) |> Enum.concat
   end
 
-  defp overrides(:rebar3, extra), do: extra[:overrides] || []
-  defp overrides(_, _extra), do: []
+  defp overrides(:rebar3, config), do: config[:overrides] || []
+  defp overrides(_, _config), do: []
 
   defp validate_app(%Mix.Dep{opts: opts, requirement: req, app: app} = dep) do
     opts_app = opts[:app]

lib/mix/lib/mix/rebar.ex

@@ -61,108 +61,6 @@ defmodule Mix.Rebar do
     end
   end
 
-  @doc """
-  Merges a rebar3 parent config with a child config.
-  """
-  # From https://github.com/rebar/rebar3/blob/b1da2ec0674df89599564252734bd4d794436425/src/rebar_opts.erl#L103
-  def merge_config(old, new) do
-    Keyword.merge(old, new, fn
-      :deps, old, _new               -> old
-      {:deps, _}, _old, new          -> new
-      :plugins, _old, new            -> new
-      {:plugins, _}, _old, new       -> new
-      :profiles, old, new            -> merge_config(old, new)
-      :mib_first_files, value, value -> value
-      :mib_first_files, old, new     -> old ++ new
-      :relx, old, new                -> tuple_merge(new, old)
-      _key, old, new when is_list(new) ->
-        case :io_lib.printable_list(new) do
-          true when new == [] ->
-            if :io_lib.printable_list(old), do: new, else: old
-          true ->
-            new
-          false ->
-            tuple_merge(old, new)
-        end
-      _key, _old, new -> new
-    end)
-  end
-
-  # From https://github.com/rebar/rebar3/blob/b1da2ec0674df89599564252734bd4d794436425/src/rebar_utils.erl#L282
-  defp tuple_merge(old, new),
-    do: do_tuple_merge(tuple_sort(old), tuple_sort(new))
-
-  defp do_tuple_merge(old, []),
-    do: old
-  defp do_tuple_merge(olds, [new | news]),
-    do: do_tuple_umerge_dedup(umerge(:new, olds, [], news, new), [])
-
-  defp umerge(_, [], [], acc, current),
-    do: [current | acc]
-  defp umerge(:new, [], news, acc, current),
-    do: Enum.reverse(news, [current | acc])
-  defp umerge(:old, olds, [], acc, current),
-    do: Enum.reverse(olds, [current | acc])
-  defp umerge(:new, [old | olds], news, acc, current) do
-    {dir, merged, new_current} = compare({:new, current}, {:old, old})
-    umerge(dir, olds, news, [merged | acc], new_current)
-  end
-  defp umerge(:old, olds, [new | news], acc, current) do
-    {dir, merged, new_current} = compare({:new, new}, {:old, current})
-    umerge(dir, olds, news, [merged | acc], new_current)
-  end
-
-  defp compare({priority, a}, {secondary, b}) when is_tuple(a) and is_tuple(b) do
-    ka = elem(a, 0)
-    kb = elem(b, 0)
-    cond do
-      ka == kb -> {secondary, a, b}
-      ka  < kb -> {secondary, a, b}
-      ka  > kb -> {priority, b, a}
-    end
-  end
-  defp compare({priority, a}, {secondary, b}) when not is_tuple(a) and not is_tuple(b) do
-    cond do
-      a == b -> {secondary, a, b}
-      a  < b -> {secondary, a, b}
-      a  > b -> {priority, b, a}
-    end
-  end
-  defp compare({priority, a}, {secondary, b}) when is_tuple(a) and not is_tuple(b) do
-    ka = elem(a, 0)
-    cond do
-      ka == b -> {secondary, a, b}
-      ka  < b -> {secondary, a, b}
-      ka  > b -> {priority, b, a}
-    end
-  end
-  defp compare({priority, a}, {secondary, b}) when not is_tuple(a) and is_tuple(b) do
-    kb = elem(b, 0)
-    cond do
-      a == kb -> {secondary, a, b}
-      a  < kb -> {secondary, a, b}
-      a  > kb -> {priority, b, a}
-    end
-  end
-
-  defp do_tuple_umerge_dedup([], acc), do: acc
-  defp do_tuple_umerge_dedup([h | t], acc) do
-    if h in t do
-      do_tuple_umerge_dedup(t, acc)
-    else
-      do_tuple_umerge_dedup(t, [h | acc])
-    end
-  end
-
-  defp tuple_sort(list) do
-    Enum.sort(list, fn
-      a, b when is_tuple(a) and is_tuple(b) -> elem(a, 0) <= elem(b, 0)
-      a, b when is_tuple(a) -> elem(a, 0) <= b
-      a, b when is_tuple(b) -> a <= elem(b, 0)
-      a, b -> a <= b
-    end)
-  end
-
   @doc """
   Serializes a Rebar config to a term file.
   """
@@ -178,7 +76,7 @@ defmodule Mix.Rebar do
   def dependency_config(config) do
     Enum.map(config, fn
       {:erl_opts, opts} ->
-        {:erl_opts, Enum.reject(opts, &(&1 == :warnings_as_errors))}
+        {:erl_opts, List.delete(opts, :warnings_as_errors)}
       other ->
         other
     end)
@@ -187,10 +85,9 @@ defmodule Mix.Rebar do
   @doc """
   Parses the dependencies in given `rebar.config` to Mix's dependency format.
   """
-  def deps(app, config, overrides) do
+  def deps(config) do
     # We don't have to handle rebar3 profiles because dependencies
     # are always in the default profile which cannot be customized
-    config = apply_overrides(app, config, overrides)
     if deps = config[:deps] do
       Enum.map(deps, &parse_dep/1)
     else
@@ -201,19 +98,17 @@ defmodule Mix.Rebar do
   @doc """
   Runs `fun` for the given config and for each `sub_dirs` in the
   given Rebar config.
-  """
-  def recur(config, fun) when is_binary(config) do
-    recur(load_config(config), fun)
-  end
 
+  `sub_dirs` is only supported in Rebar 2. In Rebar 3, the equivalent
+  to umbrella apps cannot be used as dependencies, so we don't need
+  to worry about such cases in Mix.
+  """
   def recur(config, fun) do
     subs =
       (config[:sub_dirs] || [])
-      |> Enum.map(&Path.wildcard(&1))
-      |> Enum.concat
+      |> Enum.flat_map(&Path.wildcard(&1))
       |> Enum.filter(&File.dir?(&1))
-      |> Enum.map(&recur(&1, fun))
-      |> Enum.concat
+      |> Enum.flat_map(&recur(load_config(&1), fun))
 
     [fun.(config) | subs]
   end
@@ -325,9 +220,11 @@ defmodule Mix.Rebar do
     end
   end
 
-  defp apply_overrides(app, config, overrides) do
+  @doc """
+  Applies the given overrides for app config.
+  """
+  def apply_overrides(app, config, overrides) do
     # Inefficient. We want the order we get here though.
-
     config =
       Enum.reduce(overrides, config, fn
         {:override, overrides}, config ->
@@ -340,22 +237,25 @@ defmodule Mix.Rebar do
 
     config =
       Enum.reduce(overrides, config, fn
-        {:override, oapp, overrides}, config when oapp == app ->
+        {:override, ^app, overrides}, config ->
           Enum.reduce(overrides, config, fn {key, value}, config ->
             Keyword.put(config, key, value)
           end)
         _, config ->
           config
       end)
 
-    Enum.reduce(overrides, config, fn
-      {:add, oapp, overrides}, config when oapp == app ->
-        Enum.reduce(overrides, config, fn {key, value}, config ->
-          old_value = Keyword.get(config, key, [])
-          Keyword.put(config, key, value ++ old_value)
+    config =
+      Enum.reduce(overrides, config, fn
+        {:add, ^app, overrides}, config ->
+          Enum.reduce(overrides, config, fn {key, value}, config ->
+            old_value = Keyword.get(config, key, [])
+            Keyword.put(config, key, value ++ old_value)
+          end)
+        _, config ->
+          config
       end)
-      _, config ->
-        config
-    end)
+
+    Keyword.update(config, :overrides, overrides, &(overrides ++ &1))
   end
 end