Check the elixir req for dependencies too

Also streamline the workflow for deps.get and deps.update.

Author: José Valim

lib/mix/lib/mix/deps.ex

@@ -145,8 +145,8 @@ defmodule Mix.Deps do
   provided in the project are in the wrong format.
   """
   def unfetched(acc, callback) do
-    { _deps, acc } = Mix.Deps.Converger.all(acc, callback)
-    acc
+    { deps, acc } = Mix.Deps.Converger.all(acc, callback)
+    { Mix.Deps.Converger.topsort(deps), acc }
   end
 
   @doc """
@@ -170,32 +170,6 @@ defmodule Mix.Deps do
     end)
   end
 
-  @doc """
-  Receives a list of dependencies and returns the given list
-  with their depending dependencies, recursively. It is expected
-  the given list of dependencies to contain only fetched dependencies
-  (since unfetched dependencies did not have their dependencies
-  retrieved yet).
-  """
-  def with_depending(deps, all_deps // fetched) do
-    (deps ++ do_with_depending(deps, all_deps))
-    |> Enum.uniq(&(&1.app))
-  end
-
-  defp do_with_depending([], _all_deps) do
-    []
-  end
-
-  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, fn child_dep -> child_dep.app in dep_names end)
-    end
-
-    do_with_depending(parents, all_deps) ++ parents
-  end
-
   @doc """
   Runs the given `fun` inside the given dependency project by
   changing the current working directory and loading the given
@@ -240,7 +214,7 @@ defmodule Mix.Deps do
   def format_status(Mix.Dep[status: { :noappfile, path }]),
     do: "could not find an app file at #{Path.relative_to_cwd(path)}, " <>
         "this may happen when you specified the wrong application name in your deps " <>
-        "or if the dependency failed to compile (which can be amended with `mix deps.compile`)"
+        "or if the dependency did not compile (which can be amended with `mix deps.compile`)"
 
   def format_status(Mix.Dep[status: { :invalidapp, path }]),
     do: "the app file at #{Path.relative_to_cwd(path)} is invalid"
@@ -278,6 +252,9 @@ defmodule Mix.Deps do
   def format_status(Mix.Dep[status: { :elixirlock, _ }]),
     do: "the dependency is built with an out-of-date elixir version, run `mix deps.get`"
 
+  def format_status(Mix.Dep[status: { :elixirreq, req }]),
+    do: "the dependency requires Elixir #{req} but you are running on v#{System.version}"
+
   defp dep_status(Mix.Dep[app: app, requirement: req, opts: opts, from: from]) do
     info = { app, req, Dict.drop(opts, [:dest, :lock, :env]) }
     "\n  > In #{Path.relative_to_cwd(from)}:\n    #{inspect info}\n"
@@ -308,26 +285,37 @@ defmodule Mix.Deps do
   Check if a dependency is ok.
   """
   def ok?(Mix.Dep[status: { :ok, _ }]), do: true
-  def ok?(_), do: false
+  def ok?(Mix.Dep[]), do: false
 
   @doc """
-  Check if a dependency is available.
+  Check if a dependency is available. Available dependencies
+  are the ones that can be compiled, loaded, etc.
   """
   def available?(Mix.Dep[status: { :overriden, _ }]),    do: false
   def available?(Mix.Dep[status: { :diverged, _ }]),     do: false
+  def available?(Mix.Dep[status: { :elixirreq, _ }]),    do: false
   def available?(Mix.Dep[status: { :unavailable, _ }]),  do: false
-  def available?(_), do: true
+  def available?(Mix.Dep[]), do: true
 
   @doc """
-  Check if a dependency is out of date considering its
+  Check if a dependency can be updated.
+  """
+  def updatable?(Mix.Dep[status: { :elixirreq, _ }]), do: true
+  def updatable?(dep), do: available?(dep)
+
+  @doc """
+  Check if a dependency is out of date, also considering its
   lock status. Therefore, be sure to call `check_lock` before
   invoking this function.
+
+  Out of date dependencies are fixed by simply running `deps.get`.
   """
   def out_of_date?(Mix.Dep[status: { :lockmismatch, _ }]), do: true
   def out_of_date?(Mix.Dep[status: :lockoutdated]),        do: true
   def out_of_date?(Mix.Dep[status: :nolock]),              do: true
   def out_of_date?(Mix.Dep[status: { :elixirlock, _ }]),   do: true
-  def out_of_date?(dep),                                   do: not available?(dep)
+  def out_of_date?(Mix.Dep[status: { :unavailable, _ }]),  do: true
+  def out_of_date?(Mix.Dep[]),                             do: false
 
   @doc """
   Formats a dependency for printing.
@@ -406,6 +394,53 @@ defmodule Mix.Deps do
 
   ## Helpers
 
+  @doc false
+  # Called by deps.get and deps.update
+  def finalize(all_deps, apps, lock, opts) do
+    deps = fetched_by_name(apps, all_deps)
+
+    # Do not attempt to compile dependencies that are not available.
+    # mix deps.check at the end will emit proper status in case they failed.
+    deps = Enum.filter(deps, &available?/1)
+
+    # Note we only retrieve the parent dependencies of the updated
+    # deps if all dependencies are available. This is because if a
+    # dependency is missing, it could be a children of the parent
+    # (aka a sibling) which would make parent compilation fail.
+    if Enum.all?(all_deps, &available?/1) do
+      deps = with_depending(deps, all_deps)
+    end
+
+    apps = Enum.map(deps, &(&1.app))
+    Mix.Deps.Lock.write(lock)
+
+    unless opts[:no_compile] do
+      args = if opts[:quiet], do: ["--quiet"|apps], else: apps
+      Mix.Task.run("deps.compile", args)
+      unless opts[:no_deps_check] do
+        Mix.Task.run("deps.check", [])
+      end
+    end
+  end
+
+  defp with_depending(deps, all_deps) do
+    (deps ++ do_with_depending(deps, all_deps)) |> Enum.uniq(&(&1.app))
+  end
+
+  defp do_with_depending([], _all_deps) do
+    []
+  end
+
+  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, fn child_dep -> child_dep.app in dep_names end)
+    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: binary_to_atom(app), else: app

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

@@ -128,15 +128,21 @@ defmodule Mix.Deps.Retriever do
 
   defp mix_dep(Mix.Dep[opts: opts, app: app, status: status] = dep, config) do
     Mix.Deps.in_dependency(dep, config, fn _ ->
+      config  = Mix.project
       default =
         if Mix.Project.umbrella? do
           false
         else
-          Path.join(Mix.project[:compile_path], "#{app}.app")
+          Path.join(config[:compile_path], "#{app}.app")
         end
 
       opts = Keyword.put_new(opts, :app, default)
-      stat = if vsn = old_elixir_lock(), do: { :elixirlock, vsn }, else: status
+      stat = cond do
+        vsn = old_elixir_lock() -> { :elixirlock, vsn }
+        req = old_elixir_req(config) -> { :elixirreq, req }
+        true -> status
+      end
+
       dep.manager(:mix).opts(opts).deps(children).status(stat)
     end)
   end
@@ -191,7 +197,7 @@ defmodule Mix.Deps.Retriever do
   end
 
   defp vsn_match?(nil, _actual), do: true
-  defp vsn_match?(req, actual) when is_regex(req),  do: actual =~ req
+  defp vsn_match?(req, actual) when is_regex(req), do: actual =~ req
   defp vsn_match?(req, actual) when is_binary(req) do
     Version.match?(actual, req)
   end
@@ -202,4 +208,11 @@ defmodule Mix.Deps.Retriever do
       old_vsn
     end
   end
+
+  defp old_elixir_req(config) do
+    req = config[:elixir]
+    if req && not Version.match?(System.version, req) do
+      req
+    end
+  end
 end

lib/mix/lib/mix/tasks/deps.check.ex

@@ -1,7 +1,7 @@
 defmodule Mix.Tasks.Deps.Check do
   use Mix.Task
 
-  import Mix.Deps, only: [fetched: 0, format_dep: 1, format_status: 1, check_lock: 2, out_of_date?: 1]
+  import Mix.Deps, only: [fetched: 0, format_dep: 1, format_status: 1, check_lock: 2]
 
   @hidden true
   @shortdoc "Check if all dependencies are valid"

lib/mix/lib/mix/tasks/deps.compile.ex

@@ -27,9 +27,8 @@ defmodule Mix.Tasks.Deps.Compile do
 
   """
 
-  import Mix.Deps, only: [ fetched: 0, available?: 1, fetched_by_name: 2, compile_path: 1,
-                           with_depending: 2, format_dep: 1, make?: 1, mix?: 1,
-                           rebar?: 1 ]
+  import Mix.Deps, only: [fetched: 0, available?: 1, fetched_by_name: 1, compile_path: 1,
+                          format_dep: 1, make?: 1, mix?: 1, rebar?: 1]
 
   def run(args) do
     Mix.Project.get! # Require the project to be available
@@ -38,9 +37,7 @@ defmodule Mix.Tasks.Deps.Compile do
       { opts, [], _ } ->
         do_run(Enum.filter(fetched, &available?/1), opts)
       { opts, tail, _ } ->
-        all_deps = fetched
-        deps = fetched_by_name(tail, all_deps) |> with_depending(all_deps)
-        do_run(deps, opts)
+        do_run(fetched_by_name(tail), opts)
     end
   end
 
@@ -111,7 +108,8 @@ defmodule Mix.Tasks.Deps.Compile do
     catch
       kind, reason ->
         Mix.shell.error "could not compile dependency #{app}, mix compile failed. " <>
-          "If you want to recompile this dependency, please run: mix deps.compile #{app}"
+          "You can recompile this dependency with `mix deps.compile #{app}` or " <>
+          "update it with `mix deps.update #{app}`"
         :erlang.raise(kind, reason, System.stacktrace)
     after
       Mix.env(old_env)

lib/mix/lib/mix/tasks/deps.get.ex

@@ -15,7 +15,8 @@ defmodule Mix.Tasks.Deps.Get do
 
   """
 
-  import Mix.Deps, only: [unfetched: 2, unfetched_by_name: 3, format_dep: 1, check_lock: 2, out_of_date?: 1]
+  import Mix.Deps, only: [unfetched: 2, unfetched_by_name: 3, format_dep: 1,
+                          check_lock: 2, out_of_date?: 1]
 
   def run(args) do
     Mix.Project.get! # Require the project to be available
@@ -35,22 +36,11 @@ defmodule Mix.Tasks.Deps.Get do
     { [], Mix.Deps.Lock.read }
   end
 
-  defp finalize_get({ apps, lock }, opts) do
-    apps = Enum.reverse(apps)
+  defp finalize_get({ all_deps, { apps, lock } }, opts) do
+    Mix.Deps.finalize(all_deps, apps, lock, opts)
 
-    if apps == [] do
-      unless opts[:no_deps_check], do: Mix.Task.run("deps.check", [])
-      unless opts[:quiet], do: Mix.shell.info "All dependencies up to date"
-    else
-      Mix.Deps.Lock.write(lock)
-
-      unless opts[:no_compile] do
-        args = if opts[:quiet], do: ["--quiet"|apps], else: apps
-        Mix.Task.run("deps.compile", args)
-        unless opts[:no_deps_check] do
-          Mix.Task.run("deps.check", [])
-        end
-      end
+    if apps == [] && !opts[:quiet] do
+      Mix.shell.info "All dependencies up to date"
     end
   end
 

lib/mix/lib/mix/tasks/deps.update.ex

@@ -20,7 +20,7 @@ defmodule Mix.Tasks.Deps.Update do
 
   """
 
-  import Mix.Deps, only: [ unfetched: 2, unfetched_by_name: 3, available?: 1, format_dep: 1 ]
+  import Mix.Deps, only: [unfetched: 2, unfetched_by_name: 3, updatable?: 1, format_dep: 1]
 
   def run(args) do
     Mix.Project.get! # Require the project to be available
@@ -43,21 +43,12 @@ defmodule Mix.Tasks.Deps.Update do
     { [], Mix.Deps.Lock.read }
   end
 
-  defp finalize_update({ apps, lock }, opts) do
-    apps = Enum.reverse(apps)
-    Mix.Deps.Lock.write(lock)
-
-    unless opts[:no_compile] do
-      args = if opts[:quiet], do: ["--quiet"|apps], else: apps
-      Mix.Task.run("deps.compile", args)
-      unless opts[:no_deps_check] do
-        Mix.Task.run("deps.check", [])
-      end
-    end
+  defp finalize_update({ all_deps, { apps, lock } }, opts) do
+    Mix.Deps.finalize(all_deps, apps, lock, opts)
   end
 
   defp deps_updater(dep, { acc, lock }) do
-    if available?(dep) do
+    if updatable?(dep) do
       Mix.Dep[app: app, scm: scm, opts: opts] = dep
       Mix.shell.info "* Updating #{format_dep(dep)}"
 

lib/mix/test/mix/tasks/deps_test.exs

@@ -88,6 +88,29 @@ defmodule Mix.Tasks.DepsTest do
     Mix.Project.pop
   end
 
+  test "prints list of dependencies including elixir req mismatches" do
+    Mix.Project.push ReqDepsApp
+
+    in_fixture "deps_status", fn ->
+      File.write!("deps/ok/mix.exs", """)
+      defmodule Deps.OkApp do
+        use Mix.Project
+
+        def project do
+          [elixir: "~> 0.1.0", app: :ok, version: "2.0"]
+        end
+      end
+      """
+
+      Mix.Tasks.Deps.run []
+      assert_received { :mix_shell, :info, ["* ok (deps/ok)"] }
+      message = "  the dependency requires Elixir ~> 0.1.0 but you are running on v#{System.version}"
+      assert_received { :mix_shell, :info, [^message] }
+    end
+  after
+    Mix.Project.pop
+  end
+
   test "prints list of dependencies and their lock status" do
     Mix.Project.push DepsApp