Do not compile after deps.get and deps.update

Author: José Valim

lib/mix/lib/mix/deps.ex

@@ -295,6 +295,12 @@ defmodule Mix.Deps do
     end
   end
 
+  @doc """
+  Returns true if the dependency is ok.
+  """
+  def ok?(Mix.Dep[status: { :ok, _ }]), do: true
+  def ok?(Mix.Dep[]), do: false
+
   @doc """
   Checks if a dependency is available. Available dependencies
   are the ones that can be loaded.

lib/mix/lib/mix/deps/fetcher.ex

@@ -7,21 +7,21 @@
 defmodule Mix.Deps.Fetcher do
   @moduledoc false
 
-  import Mix.Deps, only: [format_dep: 1, check_lock: 2, out_of_date?: 1, available?: 1]
+  import Mix.Deps, only: [format_dep: 1, check_lock: 2, out_of_date?: 1, available?: 1, ok?: 1]
 
   @doc """
   Fetches all dependencies.
   """
-  def all(old_lock, new_lock, opts) do
-    { apps, _deps } = do_finalize Mix.Deps.unloaded({ [], new_lock }, &do_fetch/2), old_lock, opts
+  def all(old_lock, new_lock) do
+    { apps, _deps } = do_finalize Mix.Deps.unloaded({ [], new_lock }, &do_fetch/2), old_lock
     apps
   end
 
   @doc """
   Fetches the dependencies with the given names and their children recursively.
   """
-  def by_name(names, old_lock, new_lock, opts) do
-    { apps, deps } = do_finalize Mix.Deps.unloaded_by_name(names, { [], new_lock }, &do_fetch/2), old_lock, opts
+  def by_name(names, old_lock, new_lock) do
+    { apps, deps } = do_finalize Mix.Deps.unloaded_by_name(names, { [], new_lock }, &do_fetch/2), old_lock
     Mix.Deps.loaded_by_name(names, deps) # Check all given dependencies are loaded or fail
     apps
   end
@@ -57,12 +57,11 @@ defmodule Mix.Deps.Fetcher do
     end
   end
 
-  defp do_finalize({ all_deps, { apps, new_lock } }, old_lock, opts) do
+  defp do_finalize({ all_deps, { apps, new_lock } }, old_lock) do
     # Let's get the loaded versions of deps
     deps = Mix.Deps.loaded_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.
+    # Do not mark dependencies that are not available
     deps = Enum.filter(deps, &available?/1)
 
     # Note we only retrieve the parent dependencies of the updated
@@ -84,38 +83,17 @@ defmodule Mix.Deps.Fetcher do
     Mix.Deps.Lock.write(lock)
 
     require_compilation(deps)
-    do_compile(deps, opts)
     { apps, all_deps }
   end
 
   defp require_compilation(deps) do
-    envs = Mix.Project.build_path
-           |> Path.join("*/lib")
-           |> Path.wildcard()
+    envs = Path.wildcard("_build/*/lib")
 
     lc Mix.Dep[app: app] inlist deps, env inlist envs do
       File.touch Path.join [env, app, ".compile"]
     end
   end
 
-  defp do_compile(deps, opts) do
-    apps = Enum.map(deps, &(&1.app)) |> Enum.uniq
-
-    unless opts[:no_compile] do
-      if apps != [] do
-        args = if opts[:quiet], do: ["--quiet"|apps], else: apps
-        Mix.Task.run "deps.compile", args
-      end
-
-      unless opts[:no_deps_check] do
-        Mix.Task.run "deps.check", ["--no-compile"]
-      end
-    end
-  end
-
-  defp ok?(Mix.Dep[status: { :ok, _ }]), do: true
-  defp ok?(Mix.Dep[]), do: false
-
   defp with_depending(deps, all_deps) do
     (deps ++ do_with_depending(deps, all_deps)) |> Enum.uniq(&(&1.app))
   end

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

@@ -1,7 +1,8 @@
 defmodule Mix.Tasks.Deps.Check do
   use Mix.Task
 
-  import Mix.Deps, only: [loaded: 0, format_dep: 1, format_status: 1, check_lock: 2]
+  import Mix.Deps, only: [loaded: 0, loaded_by_name: 1, format_dep: 1,
+                          format_status: 1, check_lock: 2, ok?: 1]
 
   @moduledoc """
   Checks if all dependencies are valid and if not, abort.
@@ -13,9 +14,11 @@ defmodule Mix.Tasks.Deps.Check do
   ## Command line options
 
   * `--no-compile` - do not compile dependencies
+  * `--quiet` - do not output on compilation
 
   """
   def run(args) do
+    { opts, _, _ } = OptionParser.parse(args, switches: [quiet: :boolean])
     lock = Mix.Deps.Lock.read
     all  = Enum.map loaded, &check_lock(&1, lock)
 
@@ -24,36 +27,33 @@ defmodule Mix.Tasks.Deps.Check do
 
     cond do
       not_ok != [] ->
-        shell = Mix.shell
-        shell.error "Unchecked dependencies for environment #{Mix.env}:"
-
-        Enum.each not_ok, fn(dep) ->
-          shell.error "* #{format_dep(dep)}"
-          shell.error "  #{format_status dep}"
-        end
-
-        raise Mix.Error, message: "Can't continue due to errors on dependencies"
-      compile == [] or "--no-compile" in args ->
+        show_not_ok(not_ok)
+      compile == [] or opts[:no_compile] ->
         :ok
       true ->
-        Mix.Task.run "deps.compile", Enum.map(compile, & &1.app)
+        Mix.Tasks.Deps.Compile.compile(compile, opts)
+        show_not_ok compile
+                    |> Enum.map(& &1.app)
+                    |> loaded_by_name
+                    |> Enum.filter(&(not ok?(&1)))
     end
   end
 
-  defp partition_deps([Mix.Dep[status: { :ok, _ }]|deps], not_ok, compile),
-    do: partition_deps(deps, not_ok, compile)
-
-  defp partition_deps([Mix.Dep[status: :compile] = dep|deps], not_ok, compile),
-    do: partition_deps(deps, not_ok, [dep|compile])
-
-  defp partition_deps([Mix.Dep[status: { :noappfile, _ }] = dep|deps], not_ok, compile),
-    do: partition_deps(deps, not_ok, [dep|compile])
+  defp partition_deps([dep|deps], not_ok, compile) do
+    cond do
+      ok?(dep)      -> partition_deps(deps, not_ok, compile)
+      compile?(dep) -> partition_deps(deps, not_ok, [dep|compile])
+      true          -> partition_deps(deps, [dep|not_ok], compile)
+    end
+  end
 
-  defp partition_deps([dep|deps], not_ok, compile),
-    do: partition_deps(deps, [dep|not_ok], compile)
+  defp partition_deps([], not_ok, compile) do
+    { not_ok, compile }
+  end
 
-  defp partition_deps([], not_ok, compile),
-    do: { not_ok, compile }
+  defp compile?(Mix.Dep[status: { :noappfile, _ }]), do: true
+  defp compile?(Mix.Dep[status: :compile]), do: true
+  defp compile?(_), do: false
 
   # If the build is per environment, we should be able to look
   # at all dependencies and remove the builds that no longer
@@ -79,4 +79,20 @@ defmodule Mix.Tasks.Deps.Check do
       end)
     end
   end
+
+  defp show_not_ok([]) do
+    :ok
+  end
+
+  defp show_not_ok(deps) do
+    shell = Mix.shell
+    shell.error "Unchecked dependencies for environment #{Mix.env}:"
+
+    Enum.each deps, fn(dep) ->
+      shell.error "* #{format_dep(dep)}"
+      shell.error "  #{format_status dep}"
+    end
+
+    raise Mix.Error, message: "Can't continue due to errors on dependencies"
+  end
 end

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

@@ -35,19 +35,14 @@ defmodule Mix.Tasks.Deps.Compile do
 
     case OptionParser.parse(args, switches: [quiet: :boolean]) do
       { opts, [], _ } ->
-        do_run(Enum.filter(loaded, &compilable?/1), opts)
+        compile(Enum.filter(loaded, &compilable?/1), opts)
       { opts, tail, _ } ->
-        do_run(loaded_by_name(tail), opts)
+        compile(loaded_by_name(tail), opts)
     end
   end
 
-  # All available dependencies can be compiled
-  # except for umbrella applications.
-  defp compilable?(Mix.Dep[manager: manager, extra: extra] = dep) do
-    available?(dep) and (manager != :mix or !extra[:umbrella?])
-  end
-
-  defp do_run(deps, run_opts) do
+  @doc false
+  def compile(deps, run_opts) do
     shell  = Mix.shell
     config = Mix.Project.deps_config
 
@@ -82,6 +77,12 @@ defmodule Mix.Tasks.Deps.Compile do
     if Enum.any?(compiled), do: Mix.Deps.Lock.touch
   end
 
+  # All available dependencies can be compiled
+  # except for umbrella applications.
+  defp compilable?(Mix.Dep[manager: manager, extra: extra] = dep) do
+    available?(dep) and (manager != :mix or !extra[:umbrella?])
+  end
+
   defp check_unavailable!(app, { :unavailable, _ }) do
     raise Mix.Error, message: "Cannot compile dependency #{app} because " <>
       "it isn't available, run `mix deps.get` first"

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

@@ -9,21 +9,17 @@ defmodule Mix.Tasks.Deps.Get do
 
   ## Command line options
 
-  * `--no-compile` - skip compilation of dependencies
-  * `--no-deps-check` - skip dependency check
   * `--quiet` - do not output verbose messages
-
   """
-
   def run(args) do
     Mix.Project.get! # Require the project to be available
     { opts, rest, _ } = OptionParser.parse(args, switches: [no_compile: :boolean, quiet: :boolean])
 
     apps =
       if rest != [] do
-        Mix.Deps.Fetcher.by_name(rest, [], Mix.Deps.Lock.read, opts)
+        Mix.Deps.Fetcher.by_name(rest, [], Mix.Deps.Lock.read)
       else
-        Mix.Deps.Fetcher.all([], Mix.Deps.Lock.read, opts)
+        Mix.Deps.Fetcher.all([], Mix.Deps.Lock.read)
       end
 
     if apps == [] && !opts[:quiet] do

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

@@ -14,22 +14,17 @@ defmodule Mix.Tasks.Deps.Update do
   ## Command line options
 
   * `--all` - update all dependencies
-  * `--no-compile` - skip compilation of dependencies
-  * `--no-deps-check` - skip dependency check
-  * `--quiet` - do not output verbose messages
-
   """
-
   def run(args) do
     Mix.Project.get! # Require the project to be available
     { opts, rest, _ } = OptionParser.parse(args, switches: [no_compile: :boolean, all: :boolean])
 
     cond do
       opts[:all] ->
-        Mix.Deps.Fetcher.all(Mix.Deps.Lock.read, [], opts)
+        Mix.Deps.Fetcher.all(Mix.Deps.Lock.read, [])
       rest != [] ->
         { old, new } = Dict.split(Mix.Deps.Lock.read, to_app_names(rest))
-        Mix.Deps.Fetcher.by_name(rest, old, new, opts)
+        Mix.Deps.Fetcher.by_name(rest, old, new)
       true ->
         raise Mix.Error, message: "mix deps.update expects dependencies as arguments or " <>
                                   "the --all option to update all dependencies"

lib/mix/test/mix/tasks/deps.git_test.exs

@@ -48,21 +48,11 @@ defmodule Mix.Tasks.DepsGitTest do
       Mix.Tasks.Deps.Get.run []
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received { :mix_shell, :info, [^message] }
-      assert_received { :mix_shell, :info, ["* Compiling git_repo"] }
-      assert_received { :mix_shell, :info, ["Compiled lib/git_repo.ex"] }
-      assert_received { :mix_shell, :info, ["Generated git_repo.app"] }
-      assert File.exists?("_build/dev/lib/git_repo/ebin/Elixir.GitRepo.beam")
       assert File.read!("mix.lock") =~ ~r/"git_repo": {:git, #{inspect fixture_path("git_repo")}, "[a-f0-9]+", \[\]}/
 
-      purge [GitRepo]
-      File.touch!("_build/dev/lib/git_repo/.compile.elixir", { { 2010, 4, 17 }, { 14, 0, 0 } })
-      Mix.Task.clear
-
       Mix.Tasks.Deps.Update.run ["--all"]
       message = "* Updating git_repo (#{fixture_path("git_repo")})"
       assert_received { :mix_shell, :info, [^message] }
-      assert_received { :mix_shell, :info, ["* Compiling git_repo"] }
-      assert_received { :mix_shell, :info, ["Compiled lib/git_repo.ex"] }
     end
   end
 
@@ -74,12 +64,9 @@ defmodule Mix.Tasks.DepsGitTest do
 
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received { :mix_shell, :info, [^message] }
-      assert_received { :mix_shell, :info, ["* Compiling git_repo"] }
-
 
       message = "* Getting deps_on_git_repo (#{fixture_path("deps_on_git_repo")})"
       assert_received { :mix_shell, :info, [^message] }
-      assert_received { :mix_shell, :info, ["* Compiling deps_on_git_repo"] }
 
       assert File.exists?("deps/deps_on_git_repo/mix.exs")
       assert File.exists?("deps/git_repo/mix.exs")
@@ -99,6 +86,7 @@ defmodule Mix.Tasks.DepsGitTest do
       # We can compile just fine
       Mix.Task.clear
       Mix.Tasks.Run.run ["-e", "1+2"]
+      assert_received { :mix_shell, :info, ["* Compiling git_repo"] }
 
       # Now let's add a submodules option
       Mix.Project.pop
@@ -141,32 +129,13 @@ defmodule Mix.Tasks.DepsGitTest do
     purge [GitRepo, GitRepo.Mix]
   end
 
-  test "does not recompiles dependencies if nothing changed" do
-    Mix.Project.push GitApp
-
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Deps.Get.run []
-      message = "* Getting git_repo (#{fixture_path("git_repo")})"
-      assert File.rm("_build/dev/lib/git_app/.compile.lock") == :ok
-      assert_received { :mix_shell, :info, [^message] }
-
-      Mix.Tasks.Deps.Compile.run ["git_repo"]
-      refute_received { :mix_shell, :info, ["Compiled lib/a.ex"] }
-      refute File.exists?("_build/dev/lib/git_app/.compile.lock")
-    end
-  after
-    purge [GitRepo, GitRepo.Mix]
-  end
-
   test "all up to date dependencies" do
     Mix.Project.push GitApp
 
     in_fixture "no_mixfile", fn ->
       Mix.Tasks.Deps.Get.run []
-
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received { :mix_shell, :info, [^message] }
-      assert_received { :mix_shell, :info, ["* Compiling git_repo"] }
 
       Mix.Tasks.Deps.Get.run []
       assert_received { :mix_shell, :info, ["All dependencies up to date"] }
@@ -175,18 +144,6 @@ defmodule Mix.Tasks.DepsGitTest do
     purge [GitRepo, GitRepo.Mix]
   end
 
-  test "requires dependencies before compilation" do
-    Mix.Project.push GitApp
-
-    in_fixture "no_mixfile", fn ->
-      assert_raise Mix.Error, fn ->
-        Mix.Tasks.Compile.run []
-      end
-    end
-  after
-    purge [GitRepo, GitRepo.Mix]
-  end
-
   test "updates the lock when the repo updates" do
     Mix.Project.push GitApp