Move dependencies callbacks back into Mix.Deps.Converger

The converger is the one that knows if a dependency exists or
not and, as such, is the best one to know if a dependency callback
should be invoked or not.

This commit also normalizes some of the Retriever internal
functions, for example, now we have mix_children and rebar_children.
The goal is to extract those functions (and the ones in Mix.Deps)
one by one into a Mix.DepsManager behaviour which will be implemented
by Mix.DepsManager.Mix and Mix.DepsManager.Rebar, removing all
the conditional calls existing in the code.

Author: José Valim

lib/mix/lib/mix/deps.ex

@@ -243,12 +243,12 @@ defmodule Mix.Deps do
   end
 
   def load_paths(Mix.Dep[manager: :rebar, opts: opts, source: source]) do
-    # Add root dir and all sub dirs with ebin/ directory
-    [ opts[:dest] | (source[:sub_dirs] || []) ]
+    subdirs = (source[:sub_dirs] || [])
       |> Enum.map(Path.wildcard(&1))
       |> List.concat
       |> Enum.map(fn path -> Path.join([opts[:dest], path, "ebin"]) end)
-      |> Enum.filter(File.dir?(&1))
+
+    [Path.join(opts[:dest], "ebin")|subdirs] |> Enum.filter(File.dir?(&1))
   end
 
   def load_paths(Mix.Dep[manager: nil, opts: opts]) do

lib/mix/lib/mix/deps/converger.ex

@@ -20,8 +20,8 @@ defmodule Mix.Deps.Converger do
   def all(rest, callback) do
     config = [ deps_path: Path.expand(Mix.project[:deps_path]),
                root_lockfile: Path.expand(Mix.project[:lockfile]) ]
-    { main, rest } = Mix.Deps.Retriever.all(rest, config, callback)
-    { all(Enum.reverse(main), [], [], main), rest }
+    main = Mix.Deps.Retriever.children(config)
+    all(main, [], [], main, config, callback, rest)
   end
 
   # We traverse the tree of dependencies in a breadth-
@@ -63,25 +63,22 @@ defmodule Mix.Deps.Converger do
   # Now, since `d` was specified in a parent project, no
   # exception is going to be raised since d is considered
   # to be the authorative source.
-  defp all([dep|t], acc, upper_breadths, current_breadths) do
+  defp all([dep|t], acc, upper_breadths, current_breadths, config, callback, rest) do
     cond do
       contains_dep?(upper_breadths, dep) ->
-        all(t, acc, upper_breadths, current_breadths)
+        all(t, acc, upper_breadths, current_breadths, config, callback, rest)
       match?({ diverged_acc, true }, diverged_dep?(acc, dep)) ->
-        all(t, diverged_acc, upper_breadths, current_breadths)
+        all(t, diverged_acc, upper_breadths, current_breadths, config, callback, rest)
       true ->
-        deps = dep.deps
-        if deps != [] do
-          acc = all(t, [dep|acc], upper_breadths, current_breadths)
-          all(deps, acc, current_breadths, deps ++ current_breadths)
-        else
-          all(t, [dep|acc], upper_breadths, current_breadths)
-        end
+        { dep, rest } = callback.(dep, rest)
+        deps = Mix.Deps.Retriever.children(dep, config)
+        { acc, rest } = all(t, [dep.deps(deps)|acc], upper_breadths, current_breadths, config, callback, rest)
+        all(deps, acc, current_breadths, deps ++ current_breadths, config, callback, rest)
     end
   end
 
-  defp all([], acc, _upper, _current) do
-    acc
+  defp all([], acc, _upper, _current, _config, _callback, rest) do
+    { acc, rest }
   end
 
   # Does the list contain the given dependency?

lib/mix/lib/mix/deps/retriever.ex

@@ -5,114 +5,82 @@ defmodule Mix.Deps.Retriever do
   @moduledoc false
 
   @doc """
-  Returns all dependencies for the current Mix.Project
+  Gets all direct children for the current Mix.Project
   as a `Mix.Dep` record.
-
-  ## Exceptions
-
-  This function raises an exception in case the developer
-  provides a dependency in the wrong format.
   """
-  def all(post_config // []) do
-    { deps, _ } = all(nil, children(post_config), post_config, fn(dep, acc) -> { dep, acc } end)
-    deps
+  def children(post_config // []) do
+    mix_children(post_config)
   end
 
   @doc """
-  Like `all/0` but takes a callback that is invoked for
-  each dependency and must return an updated depedency
-  in case some processing is done.
+  Gets all children for a given dependency.
   """
-  def all(rest, post_config // [], callback) do
-    all(rest, children(post_config), post_config, callback)
-  end
-
-  defp all(rest, childs, post_config, callback) do
-    Enum.map_reduce childs, rest, fn (dep, rest) ->
-      { dep, rest } = callback.(dep, rest)
-
-      cond do
-        Mix.Deps.available?(dep) and mixfile?(dep) ->
-          Mix.Deps.in_dependency(dep, post_config, fn project ->
-            { deps, rest } = all(rest, children(post_config), post_config, callback)
-
-            # We need to call with_mix_project once again
-            # here in case the dependency was not available
-            # the first time and the callback hook just
-            # happened to fetch it.
-            { with_mix_project(dep, project).deps(deps), rest }
-          end)
-
-        Mix.Deps.available?(dep) and rebarconfig?(dep) ->
-          dep = rebar_dep(dep)
-
-          Mix.Deps.in_dependency(dep, post_config, fn _ ->
-            { deps, rest } = all(rest, rebar_children("."), post_config, callback)
-            { dep.deps(deps), rest }
-          end)
-
-        true ->
-          { dep, rest }
-      end
+  def children(dep, config) do
+    cond do
+      Mix.Deps.available?(dep) and mixfile?(dep) ->
+        Mix.Deps.in_dependency(dep, config, fn _ ->
+          mix_children(config)
+        end)
+
+      Mix.Deps.available?(dep) and rebarconfig?(dep) ->
+        Mix.Deps.in_dependency(dep, config, fn _ ->
+          rebar_children(".")
+        end)
+
+      true ->
+        []
     end
   end
 
-  @doc """
-  Gets all direct children for the current Mix.Project
-  as a `Mix.Dep` record. Unlike with `all` the `deps`
-  field is not populated.
-  """
-  def children(post_config // []) do
-    Mix.Project.recur(post_config, fn _ ->
-      (Mix.project[:deps] || []) |> setup_deps
-    end) |> List.concat
-  end
-
   @doc """
   Receives a dependency and update its status.
   """
   def update(Mix.Dep[scm: scm, app: app, requirement: req, opts: opts]) do
-    with_scm_and_status({ app, req, opts }, [scm])
+    update({ app, req, opts }, [scm])
   end
 
   ## Helpers
 
-  defp rebar_children(dir) do
-    Mix.Rebar.recur(dir, fn config ->
-      Mix.Rebar.deps(config) |> setup_deps
+  defp mix_children(config) do
+    scms = Mix.SCM.available
+    Mix.Project.recur(config, fn _ ->
+      (Mix.project[:deps] || []) |> Enum.map(update(&1, scms))
     end) |> List.concat
   end
 
-  defp setup_deps(deps) do
+  defp rebar_children(dir) do
     scms = Mix.SCM.available
+    Mix.Rebar.recur(dir, fn config ->
+      Mix.Rebar.deps(config) |> Enum.map(update(&1, scms))
+    end) |> List.concat
+  end
 
-    Enum.map deps, fn dep ->
-      dep = with_scm_and_status(dep, scms)
+  defp update(tuple, scms) do
+    dep = with_scm_and_status(tuple, scms)
 
-      cond do
-        Mix.Deps.available?(dep) and mixfile?(dep) ->
-          Mix.Deps.in_dependency(dep, fn project ->
-            with_mix_project(dep, project)
-          end)
+    cond do
+      Mix.Deps.available?(dep) and mixfile?(dep) ->
+        Mix.Deps.in_dependency(dep, fn project ->
+          mix_dep(dep, project)
+        end)
 
-        Mix.Deps.available?(dep) and rebarconfig?(dep) ->
-          rebar_dep(dep)
+      Mix.Deps.available?(dep) and rebarconfig?(dep) ->
+        rebar_dep(dep)
 
-        true ->
-          dep
-      end
+      true ->
+        dep
     end
   end
 
-  defp with_mix_project(Mix.Dep[manager: nil] = dep, project) do
+  defp mix_dep(Mix.Dep[manager: nil] = dep, project) do
     if match?({ :noappfile, _ }, dep.status) and Mix.Project.umbrella? do
       dep = dep.update_opts(Keyword.put(&1, :app, false))
                .status({ :ok, nil })
     end
     dep.manager(:mix).source(project)
   end
 
-  defp with_mix_project(dep, _project), do: dep
+  defp mix_dep(dep, _project), do: dep
 
   defp rebar_dep(Mix.Dep[manager: nil, opts: opts] = dep) do
     config = Mix.Rebar.load_config(opts[:dest])