   defp fetch_by_name(given, lock) do
     names = to_app_names(given)
 
-    fn(%Mix.Dep{app: app} = dep, acc, new_lock) ->
+    fn %Mix.Dep{app: app} = dep, acc, new_lock ->
       # Only fetch if dependency is in given names or if lock has
       # been changed for dependency by remote converger
       if app in names or lock[app] != new_lock[app] do

  defp do_with_depending(deps, all_deps) do
    dep_names = Enum.map(deps, fn dep -> dep.app end)

    parents = Enum.filter all_deps, fn dep ->
      Enum.any?(dep.deps, &(&1.app in dep_names))
    end

    do_with_depending(parents, all_deps) ++ parents
  end

  defp to_app_names(given) do
    Enum.map(given, fn(app) ->
      if is_binary(app), do: String.to_atom(app), else: app
    end)
  end

  defp show_diverged!([]), do: :ok
  defp show_diverged!(deps) do
    shell = Mix.shell
    shell.error "Dependencies have diverged:"

    Enum.each deps, fn(dep) ->
      shell.error "* #{Mix.Dep.format_dep dep}"
      shell.error "  #{Mix.Dep.format_status dep}"
    end

    Mix.raise "Can't continue due to errors on dependencies"
  end
end

    # file to it. Each build, regardless of the environment and location,
    # will compared against this .fetch file to know if the dependency
    # needs recompiling.
    _ =
      for %Mix.Dep{scm: scm, opts: opts} <- deps, scm.fetchable?() do
        File.touch!(Path.join(opts[:dest], ".fetch"))
      end

    :ok
  end

