Merge pull request #2161 from ericmj/remote-converge-lock

Remote converger should receive and update lock

Author: ericmj

lib/mix/lib/mix/dep.ex

@@ -57,7 +57,7 @@ defmodule Mix.Dep do
   provided in the project are in the wrong format.
   """
   def loaded(opts) do
-    { deps, _ } = Mix.Dep.Converger.all(nil, opts, fn(dep, acc) -> { dep, acc } end)
+    { deps, _, _ } = Mix.Dep.Converger.all(nil, nil, opts, &{ &1, &2, &3 })
     Mix.Dep.Converger.topsort(deps)
   end
 
@@ -106,9 +106,9 @@ defmodule Mix.Dep do
   This function raises an exception if any of the dependencies
   provided in the project are in the wrong format.
   """
-  def unloaded(acc, opts, callback) do
-    { deps, acc } = Mix.Dep.Converger.all(acc, opts, callback)
-    { Mix.Dep.Converger.topsort(deps), acc }
+  def unloaded(acc, lock, opts, callback) do
+    { deps, acc, lock } = Mix.Dep.Converger.all(acc, lock, opts, callback)
+    { Mix.Dep.Converger.topsort(deps), acc, lock }
   end
 
   @doc """
@@ -120,14 +120,14 @@ defmodule Mix.Dep do
   This function raises an exception if any of the dependencies
   provided in the project are in the wrong format.
   """
-  def unloaded_by_name(given, acc, opts, callback) do
+  def unloaded_by_name(given, acc, lock, opts, callback) do
     names = to_app_names(given)
 
-    unloaded(acc, opts, fn(dep, acc) ->
+    unloaded(acc, lock, opts, fn dep, acc, lock ->
       if dep.app in names do
-        callback.(dep, acc)
+        callback.(dep, acc, lock)
       else
-        { dep, acc }
+        { dep, acc, lock }
       end
     end)
   end

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

@@ -41,7 +41,7 @@ defmodule Mix.Dep.Converger do
 
   See `Mix.Dep.Loader.children/1` for options.
   """
-  def all(rest, opts, callback) do
+  def all(acc, lock, opts, callback) do
     main      = Mix.Dep.Loader.children(opts)
     apps      = Enum.map(main, &(&1.app))
     converger = Mix.RemoteConverger.get
@@ -51,10 +51,8 @@ defmodule Mix.Dep.Converger do
     # being updated or fetched for the first time (only then do
     # we want the remote converger to run)
     result =
-      all(main, [], [], apps, callback, rest, fn dep ->
-        if not nil?(rest) &&
-           converger &&
-           converger.remote?(dep) do
+      all(main, [], [], apps, callback, acc, lock, fn dep ->
+        if not nil?(lock) && converger && converger.remote?(dep) do
           { :loaded, dep }
         else
           { :unloaded, dep }
@@ -64,20 +62,18 @@ defmodule Mix.Dep.Converger do
     # Run remote converger if one is available and rerun mix's
     # converger with the new information
     case converger && result do
-      { deps, rest } when not nil?(rest) ->
-        to_dict = &{ &1.app, &1 }
+      { deps, rest, lock } when not nil?(lock) ->
+        new_lock = converger.converge(main, lock)
 
-        converged_deps = converger.converge(deps)
-                         |> Enum.into(HashDict.new, to_dict)
         deps = deps
                |> Enum.reject(&converger.remote?(&1))
-               |> Enum.into(HashDict.new, to_dict)
+               |> Enum.into(HashDict.new, &{ &1.app, &1 })
 
-        all(main, [], [], apps, callback, rest, fn dep ->
-          cond do
-            cached = deps[dep.app] -> { :loaded, cached }
-            cached = converged_deps[dep.app] -> { :unloaded, cached }
-            true -> { :unloaded, dep }
+        all(main, [], [], apps, callback, rest, new_lock, fn dep ->
+          if cached = deps[dep.app] do
+            { :loaded, cached }
+          else
+            { :unloaded, dep }
           end
         end)
       _ ->
@@ -124,17 +120,17 @@ defmodule Mix.Dep.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, callback, rest, cache) do
+  defp all([dep|t], acc, upper_breadths, current_breadths, callback, rest, lock, cache) do
     cond do
       new_acc = diverged_deps(acc, upper_breadths, dep) ->
-        all(t, new_acc, upper_breadths, current_breadths, callback, rest, cache)
+        all(t, new_acc, upper_breadths, current_breadths, callback, rest, lock, cache)
       true ->
         dep =
           case cache.(dep) do
             { :loaded, cached_dep } ->
               cached_dep
             { :unloaded, dep } ->
-              { dep, rest } = callback.(dep, rest)
+              { dep, rest, lock } = callback.(dep, rest, lock)
 
               # After we invoke the callback (which may actually check out the
               # dependency), we load the dependency including its latest info
@@ -143,13 +139,13 @@ defmodule Mix.Dep.Converger do
           end
 
         dep = %{dep | deps: reject_non_fullfilled_optional(dep.deps, current_breadths)}
-        { acc, rest } = all(t, [dep|acc], upper_breadths, current_breadths, callback, rest, cache)
-        all(dep.deps, acc, current_breadths, Enum.map(dep.deps, &(&1.app)) ++ current_breadths, callback, rest, cache)
+        { acc, rest, lock } = all(t, [dep|acc], upper_breadths, current_breadths, callback, rest, lock, cache)
+        all(dep.deps, acc, current_breadths, Enum.map(dep.deps, &(&1.app)) ++ current_breadths, callback, rest, lock, cache)
     end
   end
 
-  defp all([], acc, _upper, _current, _callback, rest, _cache) do
-    { acc, rest }
+  defp all([], acc, _upper, _current, _callback, rest, lock, _cache) do
+    { acc, rest, lock }
   end
 
   # Look for divergence in dependencies.

lib/mix/lib/mix/dep/fetcher.ex

@@ -15,8 +15,8 @@ defmodule Mix.Dep.Fetcher do
   See `Mix.Dep.unloaded/3` for options.
   """
   def all(old_lock, new_lock, opts) do
-    deps = Mix.Dep.unloaded({ [], new_lock }, opts, &do_fetch/2)
-    { apps, _deps } = do_finalize(deps, old_lock, opts)
+    result = Mix.Dep.unloaded([], new_lock, opts, &do_fetch/3)
+    { apps, _deps } = do_finalize(result, old_lock, opts)
     apps
   end
 
@@ -26,19 +26,19 @@ defmodule Mix.Dep.Fetcher do
   See `Mix.Dep.unloaded_by_name/4` for options.
   """
   def by_name(names, old_lock, new_lock, opts) do
-    deps = Mix.Dep.unloaded_by_name(names, { [], new_lock }, opts, &do_fetch/2)
-    { apps, deps } = do_finalize(deps, old_lock, opts)
+    result = Mix.Dep.unloaded_by_name(names, [], new_lock, opts, &do_fetch/3)
+    { apps, deps } = do_finalize(result, old_lock, opts)
     Mix.Dep.loaded_by_name(names, deps, opts) # Check all given dependencies are loaded or fail
     apps
   end
 
-  defp do_fetch(dep, { acc, lock }) do
+  defp do_fetch(dep, acc, lock) do
     %Mix.Dep{app: app, scm: scm, opts: opts} = dep = check_lock(dep, lock)
 
     cond do
       # Dependencies that cannot be fetched are always compiled afterwards
       not scm.fetchable? ->
-        { dep, { [app|acc], lock } }
+        { dep, [app|acc], lock }
 
       # If the dependency is not available or we have a lock mismatch
       out_of_date?(dep) ->
@@ -52,14 +52,14 @@ defmodule Mix.Dep.Fetcher do
           end
 
         if new do
-          { dep, { [app|acc], Map.put(lock, app, new) } }
+          { dep, [app|acc], Map.put(lock, app, new) }
         else
-          { dep, { acc, lock } }
+          { dep, acc, lock }
         end
 
       # The dependency is ok or has some other error
       true ->
-        { dep, { acc, lock } }
+        { dep, acc, lock }
     end
   end
 
@@ -69,7 +69,7 @@ defmodule Mix.Dep.Fetcher do
   defp out_of_date?(%Mix.Dep{status: { :unavailable, _ }}),  do: true
   defp out_of_date?(%Mix.Dep{}),                             do: false
 
-  defp do_finalize({ all_deps, { apps, new_lock } }, old_lock, opts) do
+  defp do_finalize({ all_deps, apps, new_lock }, old_lock, opts) do
     # Let's get the loaded versions of deps
     deps = Mix.Dep.loaded_by_name(apps, all_deps, opts)
 

lib/mix/lib/mix/remote_converger.ex

@@ -15,9 +15,9 @@ defmodule Mix.RemoteConverger do
   @doc """
   Run the remote converger.
 
-  Return the converged deps.
+  Return updated lock.
   """
-  defcallback converge([Mix.Dep.t]) :: [Mix.Dep.t]
+  defcallback converge([Mix.Dep.t], map) :: map
 
   @doc """
   Get registered remote converger.

lib/mix/test/mix/dep_test.exs

@@ -74,10 +74,10 @@ defmodule Mix.DepTest do
     # the proper manager.
     Mix.Project.push DepsApp
 
-    { _, true } =
-      Mix.Dep.unloaded(false, [], fn dep, acc ->
+    { _, true, _ } =
+      Mix.Dep.unloaded(false, [], nil, fn dep, acc, lock ->
         assert nil?(dep.manager)
-        { dep, acc or true }
+        { dep, acc or true, lock }
       end)
   end
 
@@ -185,9 +185,9 @@ defmodule Mix.DepTest do
 
     def remote?(_app), do: true
 
-    def converge(deps) do
+    def converge(_deps, lock) do
       Process.put(:remote_converger, true)
-      deps
+      lock
     end
   end
 
@@ -218,13 +218,13 @@ defmodule Mix.DepTest do
     Mix.Project.push OnlyDeps
 
     in_fixture "deps_status", fn ->
-      { deps, _acc } = Mix.Dep.unloaded([], [env: :other_env], &{ &1, &2 })
+      { deps, _acc, _lock } = Mix.Dep.unloaded([], nil, [env: :other_env], &{ &1, &2, &3 })
       assert length(deps) == 2
 
-      { deps, _acc } = Mix.Dep.unloaded([], [], &{ &1, &2 })
+      { deps, _acc, _lock } = Mix.Dep.unloaded([], nil, [], &{ &1, &2, &3 })
       assert length(deps) == 2
 
-      { deps, _acc } = Mix.Dep.unloaded([], [env: :prod], &{ &1, &2 })
+      { deps, _acc, _lock } = Mix.Dep.unloaded([], nil, [env: :prod], &{ &1, &2, &3 })
       assert length(deps) == 1
       assert Enum.find deps, &match?(%Mix.Dep{app: :foo}, &1)
     end