Rely on print_app for mix deps.compile and ensure path deps are compiled

Author: José Valim

lib/mix/lib/mix/dep/umbrella.ex

@@ -51,7 +51,7 @@ defmodule Mix.Dep.Umbrella do
 
   defp to_umbrella_dep(paths, build) do
     Enum.map paths, fn({app, path}) ->
-      opts = [path: path, dest: Path.expand(path),
+      opts = [path: path, dest: Path.expand(path), from_umbrella: true,
               env: Mix.env, build: Path.join([build, "lib", Atom.to_string(app)])]
       %Mix.Dep{
         scm: Mix.SCM.Path,

lib/mix/lib/mix/project_stack.ex

@@ -10,14 +10,21 @@ defmodule Mix.ProjectStack do
 
   @spec start_link :: {:ok, pid}
   def start_link() do
-    Agent.start_link fn -> %{stack: [], post_config: [], cache: HashDict.new} end, name: __MODULE__
+    initial = %{stack: [], post_config: [], cache: HashDict.new}
+    Agent.start_link fn -> initial end, name: __MODULE__
   end
 
   @spec push(module, config, file) :: :ok | {:error, file}
   def push(module, config, file) do
     get_and_update fn %{stack: stack} = state ->
+      # Consider the first children to always have io_done
+      # because we don't need to print anything unless another
+      # project talks ahold of the shell.
+      io_done? = stack == []
+
       config  = Keyword.merge(config, state.post_config)
-      project = %{name: module, config: config, file: file, recursing?: false, io_done: false, tasks: HashSet.new}
+      project = %{name: module, config: config, file: file,
+                  recursing?: false, io_done: io_done?, tasks: HashSet.new}
 
       cond do
         file = find_project_named(module, stack) ->
@@ -59,11 +66,14 @@ defmodule Mix.ProjectStack do
   def print_app? do
     get_and_update fn %{stack: stack} = state ->
       case stack do
-        [h|t] ->
-          output = not h.io_done and not umbrella?(stack) and in_umbrella?(stack)
-          {output, %{state | stack: [%{h | io_done: true}|t]}}
         [] ->
           {false, state}
+        [%{io_done: true}|_] ->
+          {false, state}
+        [h|t] ->
+          h = %{h | io_done: true}
+          t = Enum.map(t, &%{&1 | io_done: false})
+          {true, %{state | stack: [h|t]}}
       end
     end
   end
@@ -130,19 +140,6 @@ defmodule Mix.ProjectStack do
     end
   end
 
-  defp in_umbrella?(stack) do
-    Enum.any?(stack, fn(%{config: conf}) ->
-      conf[:apps_path] != nil
-    end)
-  end
-
-  defp umbrella?(stack) do
-    case stack do
-      [%{name: name, config: config}|_] when name != nil -> config[:apps_path] != nil
-      _ -> false
-    end
-  end
-
   defp find_project_named(name, stack) do
     name && Enum.find_value(stack, fn
       %{name: n, file: file} when n === name -> file
@@ -165,5 +162,4 @@ defmodule Mix.ProjectStack do
   defp cast(fun) do
     Agent.cast __MODULE__, fun
   end
-
 end

lib/mix/lib/mix/scm.ex

@@ -10,7 +10,8 @@ defmodule Mix.SCM do
 
   @doc """
   Returns a boolean if the dependency can be fetched
-  or it is meant to be previously available in the filesystem.
+  or it is meant to be previously available in the
+  filesystem.
   """
   defcallback fetchable? :: boolean
 

lib/mix/lib/mix/shell/io.ex

@@ -21,7 +21,6 @@ defmodule Mix.Shell.IO do
   to stdout as it comes.
   """
   def cmd(command) do
-    print_app
     Mix.Shell.cmd(command, &IO.write(&1))
   end
 

lib/mix/lib/mix/shell/process.ex

@@ -54,7 +54,6 @@ defmodule Mix.Shell.Process do
   the current process.
   """
   def cmd(command) do
-    print_app
     Mix.Shell.cmd(command, fn(data) ->
       send self, {:mix_shell, :run, [data]}
     end)

lib/mix/lib/mix/task.ex

@@ -213,7 +213,10 @@ defmodule Mix.Task do
     recursive = recursive(module)
 
     if umbrella? && recursive && Mix.ProjectStack.enable_recursion do
-      config = [build_path: Mix.Project.build_path]
+      # Get all dependency configuration but not the deps path
+      # as we leave the control of the deps path still to the
+      # umbrella child.
+      config = Mix.Project.deps_config |> Keyword.delete(:deps_path)
       res = for %Mix.Dep{app: app, opts: opts} <- Mix.Dep.Umbrella.loaded do
         Mix.Project.in_project(app, opts[:path], config, fun)
       end

lib/mix/lib/mix/tasks/cmd.ex

@@ -16,6 +16,7 @@ defmodule Mix.Tasks.Cmd do
   than zero.
   """
   def run(args) do
+    Mix.shell.print_app
     case Mix.shell.cmd(Enum.join(args, " ")) do
       0 -> :ok
       s -> exit(s)

lib/mix/lib/mix/tasks/compile.elixir.ex

@@ -51,7 +51,7 @@ defmodule Mix.Tasks.Compile.Elixir do
     manifest = manifest()
     configs  = Mix.Project.config_files ++ Mix.Tasks.Compile.Erlang.manifests
 
-    force = opts[:force] || path_deps_changed?(manifest)
+    force = opts[:force] || local_deps_changed?(manifest)
               || Mix.Utils.stale?(configs, [manifest])
 
     result = Mix.Compilers.Elixir.compile(manifest, srcs, [:ex], dest, force, fn ->
@@ -85,16 +85,13 @@ defmodule Mix.Tasks.Compile.Elixir do
     Code.compiler_options Keyword.merge(opts, extra)
   end
 
-  defp path_deps_changed?(manifest) do
+  defp local_deps_changed?(manifest) do
     manifest = Path.absname(manifest)
 
-    deps = Enum.filter(Mix.Dep.children([]), fn dep ->
-      dep.scm == Mix.SCM.Path
-    end)
-
-    Enum.any?(deps, fn(dep) ->
-      Mix.Dep.in_dependency(dep, fn(_) ->
-        Mix.Utils.stale?(Mix.Tasks.Compile.manifests, [manifest])
+    Enum.any?(Mix.Dep.children([]), fn(dep) ->
+      not dep.scm.fetchable? and Mix.Dep.in_dependency(dep, fn(_) ->
+        files = Mix.Project.config_files ++ Mix.Tasks.Compile.manifests
+        Mix.Utils.stale?(files, [manifest])
       end)
     end)
   end

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

@@ -14,11 +14,10 @@ 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])
+    {opts, _, _} = OptionParser.parse(args)
     lock = Mix.Dep.Lock.read
     all  = Enum.map(loaded(env: Mix.env), &check_lock(&1, lock))
 
@@ -41,16 +40,21 @@ defmodule Mix.Tasks.Deps.Check do
 
   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)
+      compile?(dep)            -> partition_deps(deps, not_ok, [dep|compile])
+      ok?(dep) and local?(dep) -> partition_deps(deps, not_ok, [dep|compile])
+      ok?(dep)                 -> partition_deps(deps, not_ok, compile)
+      true                     -> partition_deps(deps, [dep|not_ok], compile)
     end
   end
 
   defp partition_deps([], not_ok, compile) do
     {Enum.reverse(not_ok), Enum.reverse(compile)}
   end
 
+  defp local?(dep) do
+    not dep.scm.fetchable? and dep.opts[:from_umbrella] != true
+  end
+
   defp compile?(%Mix.Dep{status: {:elixirlock, _}}), do: true
   defp compile?(%Mix.Dep{status: {:noappfile, _}}), do: true
   defp compile?(%Mix.Dep{status: :compile}), do: true

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

@@ -21,10 +21,6 @@ defmodule Mix.Tasks.Deps.Compile do
 
       {:some_dependency, "0.1.0", git: "...", compile: "command to compile"}
 
-  ## Command line options
-
-  * `--quiet` - do not output verbose messages
-
   """
 
   import Mix.Dep, only: [loaded: 1, available?: 1, loaded_by_name: 2,
@@ -33,7 +29,7 @@ defmodule Mix.Tasks.Deps.Compile do
   def run(args) do
     Mix.Project.get! # Require the project to be available
 
-    case OptionParser.parse(args, switches: [quiet: :boolean]) do
+    case OptionParser.parse(args) do
       {opts, [], _} ->
         compile(Enum.filter(loaded(env: Mix.env), &compilable?/1), opts)
       {opts, tail, _} ->
@@ -42,18 +38,14 @@ defmodule Mix.Tasks.Deps.Compile do
   end
 
   @doc false
-  def compile(deps, run_opts) do
+  def compile(deps, _opts) do
     shell  = Mix.shell
     config = Mix.Project.deps_config
 
     compiled =
       Enum.map(deps, fn %Mix.Dep{app: app, status: status, opts: opts} = dep ->
         check_unavailable!(app, status)
 
-        unless run_opts[:quiet] || opts[:compile] == false do
-          shell.info "* Compiling #{app}"
-        end
-
         compiled = cond do
           not nil?(opts[:compile]) ->
             do_compile dep