Merge pull request #1040 from ericmj/umbrella-as-dep

Add support for umbrella project as dependency

Author: José Valim

lib/mix/lib/mix/deps.ex

@@ -168,4 +168,54 @@ defmodule Mix.Deps do
 
     "#{app} #{version}#{inspect scm.format(opts)}"
   end
+
+  @doc """
+  Returns all compile paths for the dependency.
+  """
+  def compile_paths(Mix.Dep[app: app, opts: opts] = dep) do
+    if mix?(dep) do
+      Mix.Project.in_project app, opts[:dest], fn _ ->
+        Mix.Project.compile_paths
+      end
+    else
+      [ Path.join(opts[:dest], "ebin") ]
+    end
+  end
+
+  @doc """
+  Returns all load paths for the dependency.
+  """
+  def load_paths(Mix.Dep[app: app, opts: opts] = dep) do
+    if mix?(dep) do
+      paths = Mix.Project.in_project app, opts[:dest], fn _ ->
+        Mix.Project.load_paths
+      end
+      Enum.uniq paths
+    else
+      [ Path.join(opts[:dest], "ebin") ]
+    end
+  end
+
+  @doc """
+  Returns if dependency is a mix project.
+  """
+  def mix?(dep) do
+    dep.project != nil
+  end
+
+  @doc """
+  Returns if dependency is a rebar project.
+  """
+  def rebar?(dep) do
+    Enum.any? ["rebar.config", "rebar.config.script"], fn file ->
+      File.regular? Path.join(dep.opts[:dest], file)
+    end
+  end
+
+  @doc """
+  Returns if dependency is a make project.
+  """
+  def make?(dep) do
+    File.regular? Path.join(dep.opts[:dest], "Makefile")
+  end
 end

lib/mix/lib/mix/project.ex

@@ -184,28 +184,54 @@ defmodule Mix.Project do
     end
 
     projects = topsort_projects(projects)
-    old_tasks = Mix.Task.clear
     results = Enum.map projects, fn { app, app_path } ->
-      for_project(app, app_path, fun)
+      in_project(app, app_path, fun)
     end
 
-    Mix.Task.set_tasks(old_tasks)
     results
   end
 
-  # Run function with project on the stack
-  defp for_project(app, app_path, fun) do
+  @doc """
+  Run fun in the context of project app and working directory app_path.
+  Optionally takes a post_config.
+  """
+  def in_project(app, app_path, post_config // [], fun) do
     umbrella_path = apps_path
 
     File.cd! app_path, fn ->
-      Mix.Project.load_project(app)
-      result = fun.(umbrella_path)
-      Mix.Project.pop
-      Mix.Task.clear
+      load_project(app, post_config)
+      result = try do
+        fun.(umbrella_path)
+      after
+        Mix.Project.pop
+      end
       result
     end
   end
 
+  @doc """
+  Returns the paths this project compiles to.
+  """
+  def compile_paths do
+    if umbrella? do
+      List.flatten recursive(fn _ -> compile_paths end)
+    else
+      [ Path.expand config[:compile_path] ]
+    end
+  end
+
+  @doc """
+  Returns all load paths for this project.
+  """
+  def load_paths do
+    paths = if umbrella? do
+      List.flatten recursive(fn _ -> load_paths end)
+    else
+      Enum.map config[:load_paths], Path.expand(&1)
+    end
+    paths ++ compile_paths
+  end
+
   # Sort projects in dependency order
   defp topsort_projects(projects) do
     graph = :digraph.new
@@ -215,7 +241,7 @@ defmodule Mix.Project do
     end
 
     Enum.each projects, fn { app, app_path } ->
-      for_project app, app_path, fn apps_path ->
+      in_project app, app_path, fn apps_path ->
         Enum.each Mix.Deps.children, fn dep ->
           if Mix.Deps.available?(dep) and Mix.Deps.in_umbrella?(dep, apps_path) do
             :digraph.add_edge(graph, dep.app, app)
@@ -246,6 +272,7 @@ defmodule Mix.Project do
       elixirc_exts: [:ex],
       elixirc_paths: ["lib"],
       elixirc_watch_exts: [:ex, :eex, :exs],
+      load_paths: [],
       lockfile: "mix.lock",
       erlc_paths: ["src"],
       erlc_include_path: "include",

lib/mix/lib/mix/server.ex

@@ -74,13 +74,7 @@ defmodule Mix.Server do
   def handle_call(:output_app?, _from, config) do
     # Check that we haven't already outputted app and that we are part of an
     # umbrella project
-    umbrella = case config.projects do
-      [{ h, conf }|_] when h != nil -> conf[:apps_path] != nil
-      _ -> false
-    end
-    in_umbrella = Enum.any?(config.projects, fn { _, conf } -> conf[:apps_path] != nil end)
-    output = !config.io_done && !umbrella && in_umbrella
-
+    output = not config.io_done and not umbrella?(config) and in_umbrella?(config)
     { :reply, output, config.io_done(true) }
   end
 
@@ -139,4 +133,17 @@ defmodule Mix.Server do
   def handle_cast(request, config) do
     super(request, config)
   end
+
+  # Returns if project is part of an umbrella project
+  defp in_umbrella?(config) do
+    Enum.any? config.projects, fn { _, conf } -> conf[:apps_path] != nil end
+  end
+
+  # Returns if project is an umbrella project
+  defp umbrella?(config) do
+    case config.projects do
+      [ { h, conf } | _ ] when h != nil -> conf[:apps_path] != nil
+      _ -> false
+    end
+  end
 end

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

@@ -24,7 +24,8 @@ defmodule Mix.Tasks.Deps.Compile do
 
   """
 
-  import Mix.Deps, only: [all: 0, available?: 1, by_name!: 1, format_dep: 1]
+  import Mix.Deps, only: [ all: 0, available?: 1, by_name!: 1, compile_paths: 1,
+                           format_dep: 1, make?: 1, mix?: 1, rebar?: 1 ]
 
   def run(args) do
     case OptionParser.parse(args) do
@@ -45,10 +46,6 @@ defmodule Mix.Tasks.Deps.Compile do
       shell.info "* Compiling #{app}"
 
       deps_path = opts[:dest]
-      ebin = Path.join(deps_path, "ebin") |> binary_to_list
-
-      # Avoid compilation conflicts
-      :code.del_path(ebin |> Path.expand)
 
       root_path = Path.expand(Mix.project[:deps_path])
 
@@ -57,27 +54,26 @@ defmodule Mix.Tasks.Deps.Compile do
         root_lockfile: Path.expand(Mix.project[:lockfile])
       ]
 
-      File.cd! deps_path, fn ->
-        cond do
-          opts[:compile] -> do_compile app, opts[:compile]
-          mix?           -> do_mix dep, config
-          rebar?         -> do_rebar app, root_path
-          make?          -> do_command app, "make"
-          true           -> shell.error "Could not compile #{app}, no mix.exs, rebar.config or Makefile " <>
-                             "(pass :compile as an option to customize compilation, set it to :noop to do nothing)"
-        end
+      ebins = Enum.map compile_paths(dep), binary_to_list(&1)
+
+      # Avoid compilation conflicts
+      Enum.each ebins, fn ebin -> :code.del_path(ebin |> Path.expand) end
+
+      cond do
+        opts[:compile] -> File.cd! deps_path, fn -> do_compile app, opts[:compile] end
+        mix?(dep)      -> File.cd! deps_path, fn -> do_mix dep, config end
+        rebar?(dep)    -> File.cd! deps_path, fn -> do_rebar app, root_path end
+        make?(dep)     -> File.cd! deps_path, fn -> do_command app, "make" end
+        true           -> shell.error "Could not compile #{app}, no mix.exs, rebar.config or Makefile " <>
+                           "(pass :compile as an option to customize compilation, set it to :noop to do nothing)"
       end
 
-      Code.prepend_path ebin
+      Enum.each ebins, Code.prepend_path &1
     end
 
     Mix.Deps.Lock.touch
   end
 
-  defp mix?,   do: File.regular?("mix.exs")
-  defp rebar?, do: Enum.any? ["rebar.config", "rebar.config.script"], File.regular?(&1)
-  defp make?,  do: File.regular?("Makefile")
-
   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.loadpaths.ex

@@ -1,7 +1,7 @@
 defmodule Mix.Tasks.Deps.Loadpaths do
   use Mix.Task
 
-  import Mix.Deps, only: [all: 0, ok?: 1]
+  import Mix.Deps, only: [all: 0, load_paths: 1, ok?: 1]
 
   @hidden true
   @shortdoc "Load all dependencies paths"
@@ -19,7 +19,7 @@ defmodule Mix.Tasks.Deps.Loadpaths do
     end
 
     lc dep inlist all, ok?(dep) do
-      Code.prepend_path Path.join(dep.opts[:dest], "ebin")
+      Enum.each load_paths(dep), Code.prepend_path(&1)
     end
   end
 end

lib/mix/lib/mix/tasks/loadpaths.ex

@@ -21,10 +21,6 @@ defmodule Mix.Tasks.Loadpaths do
       Mix.Task.run "deps.loadpaths", args
     end
 
-    paths = Mix.project[:load_paths] || []
-    Enum.each paths, Code.prepend_path(&1)
-
-    ebin  = Mix.project[:compile_path] || "ebin"
-    Code.prepend_path(ebin)
+    Enum.each Mix.Project.load_paths, Code.prepend_path(&1)
   end
-end
+end

lib/mix/test/fixtures/umbrella/apps/bar/lib/bar.ex renamed to lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/bar/lib/bar.ex

@@ -0,0 +1,12 @@
+defmodule UmbrellaDep.Mixfile do
+  use Mix.Project
+
+  def project do
+    [ app: :umbrella_dep,
+      deps: deps ]
+  end
+
+  defp deps do
+    [ { :umbrella, path: "deps/umbrella", app: false } ]
+  end
+end

lib/mix/test/fixtures/umbrella/apps/bar/mix.exs renamed to lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/bar/mix.exs

@@ -4,7 +4,7 @@ defmodule Mix.UmbrellaTest do
   use MixTest.Case
 
   test "compile umbrella" do
-    in_fixture "umbrella", fn ->
+    in_fixture "umbrella_dep/deps/umbrella", fn ->
       Mix.Project.load_project(:umbrella)
       Mix.Task.run "compile"
 
@@ -17,6 +17,19 @@ defmodule Mix.UmbrellaTest do
     end
   after
     Mix.Project.pop
-    purge [Umbrella.Mixfile]
+    purge [Umbrella.Mixfile, Foo, Foo.Mix, Bar, Bar.Mix]
+  end
+
+  test "umbrella as dependency" do
+    in_fixture "umbrella_dep", fn ->
+      Mix.Project.load_project(:umbrella_dep)
+      Mix.Tasks.Deps.Compile.run []
+      Mix.Tasks.Deps.Loadpaths.run []
+
+      assert "hello world" == Bar.bar
+    end
+  after
+    Mix.Project.pop
+    purge [UmbrellaDep.Mixfile, Umbrella.Mixfile, Foo, Foo.Mix, Bar, Bar.Mix]
   end
 end