Merge pull request #1122 from ericmj/mix-rebar

Handle rebar dependencies better

Author: José Valim

lib/mix/lib/mix/deps.ex

@@ -1,5 +1,5 @@
 defrecord Mix.Dep, [ scm: nil, app: nil, requirement: nil, status: nil, opts: nil,
-                     project: nil, deps: [] ] do
+                     deps: [], source: nil, manager: nil ] do
   @moduledoc """
   This is a record that keeps information about your project
   dependencies. It keeps:
@@ -9,7 +9,9 @@ defrecord Mix.Dep, [ scm: nil, app: nil, requirement: nil, status: nil, opts: ni
   * requirements - a binary or regexp with the deps requirement;
   * status - the current status of dependency, check `Mix.Deps.format_status/1` for more info;
   * opts - the options given by the developer
-  * project - the Mix.Project for the dependency
+  * source - any possible configuration associated with the manager field,
+             rebar.config for rebar or the Mix.Project for Mix
+  * manager - the project management, possible values: :rebar / :mix / nil
   """
 end
 
@@ -81,7 +83,7 @@ defmodule Mix.Deps do
     index = Mix.Dep.__index__(:app)
     Enum.each apps, fn(app) ->
       unless List.keyfind(deps, app, index) do
-        Mix.shell.info message: "unknown dependency #{app} for env #{Mix.env}"
+        Mix.shell.info "unknown dependency #{app} for env #{Mix.env}"
       end
     end
 
@@ -93,7 +95,20 @@ defmodule Mix.Deps do
   changing the current working directory and loading the given
   project into the project stack.
   """
-  def in_dependency(Mix.Dep[app: app, opts: opts], post_config // [], fun) do
+  def in_dependency(dep, post_config // [], fun)
+
+  def in_dependency(Mix.Dep[manager: :rebar, opts: opts], post_config, fun) do
+    # Use post_config for rebar deps
+    Mix.Project.post_config(post_config)
+    Mix.Project.push(Mix.Rebar)
+    try do
+      File.cd!(opts[:dest], fn -> fun.(nil) end)
+    after
+      Mix.Project.pop
+    end
+  end
+
+  def in_dependency(Mix.Dep[app: app, opts: opts], post_config, fun) do
     env     = opts[:env] || :prod
     old_env = Mix.env
 
@@ -207,8 +222,8 @@ defmodule Mix.Deps do
   @doc """
   Returns all compile paths for the dependency.
   """
-  def compile_paths(Mix.Dep[app: app, opts: opts] = dep) do
-    if mix?(dep) do
+  def compile_paths(Mix.Dep[app: app, opts: opts, manager: manager]) do
+    if manager == :mix do
       Mix.Project.in_project app, opts[:dest], fn _ ->
         Mix.Project.compile_paths
       end
@@ -220,31 +235,38 @@ defmodule Mix.Deps do
   @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") ]
+  def load_paths(Mix.Dep[manager: :mix, app: app, opts: opts]) do
+    paths = Mix.Project.in_project app, opts[:dest], fn _ ->
+      Mix.Project.load_paths
     end
+    Enum.uniq paths
+  end
+
+  def load_paths(Mix.Dep[manager: :rebar, opts: opts, source: source]) do
+    # Add root dir and all sub dirs with ebin/ directory
+    [ opts[:dest] | (source[:sub_dirs] || []) ]
+      |> Enum.map(Path.wildcard(&1))
+      |> List.concat
+      |> Enum.map(fn path -> Path.join([opts[:dest], path, "ebin"]) end)
+      |> Enum.filter(File.dir?(&1))
+  end
+
+  def load_paths(Mix.Dep[manager: nil, opts: opts]) do
+    [ Path.join(opts[:dest], "ebin") ]
   end
 
   @doc """
   Returns true if dependency is a mix project.
   """
-  def mix?(dep) do
-    dep.project != nil
+  def mix?(Mix.Dep[manager: manager]) do
+    manager == :mix
   end
 
   @doc """
   Returns true 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
+  def rebar?(Mix.Dep[manager: manager]) do
+    manager == :rebar
   end
 
   @doc """

lib/mix/lib/mix/deps/converger.ex

@@ -20,7 +20,7 @@ defmodule Mix.Deps.Converger do
   def all(rest, callback) do
     config = [ deps_path: Path.expand(Mix.project[:deps_path]),
                root_lockfile: Path.expand(Mix.project[:lockfile]) ]
-    { main, rest } = Mix.Deps.Retriever.all(rest, config,callback)
+    { main, rest } = Mix.Deps.Retriever.all(rest, config, callback)
     { all(Enum.reverse(main), [], [], main), rest }
   end
 

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

@@ -14,7 +14,7 @@ defmodule Mix.Deps.Retriever do
   provides a dependency in the wrong format.
   """
   def all(post_config // []) do
-    { deps, _ } = all(nil, post_config, fn(dep, acc) -> { dep, acc } end)
+    { deps, _ } = all(nil, children(post_config), post_config, fn(dep, acc) -> { dep, acc } end)
     deps
   end
 
@@ -24,22 +24,36 @@ defmodule Mix.Deps.Retriever do
   in case some processing is done.
   """
   def all(rest, post_config // [], callback) do
-    Enum.map_reduce children, rest, fn (dep, rest) ->
+    all(rest, children(post_config), post_config, callback)
+  end
+
+  defp all(rest, childs, post_config, callback) do
+    Enum.map_reduce childs, rest, fn (dep, rest) ->
       { dep, rest } = callback.(dep, rest)
 
-      if Mix.Deps.available?(dep) and mixfile?(dep) do
-        { dep, rest } = Mix.Deps.in_dependency dep, post_config, fn project ->
-          { deps, rest } = all(rest, callback)
+      cond do
+        Mix.Deps.available?(dep) and mixfile?(dep) ->
+          Mix.Deps.in_dependency(dep, post_config, fn project ->
+            { deps, rest } = all(rest, children(post_config), post_config, callback)
 
-          # We need to call with_mix_project once again
-          # here in case the dependency was not available
-          # the first time and the callback hook just
-          # happened to fetch it.
-          { with_mix_project(dep, project).deps(deps), rest }
-        end
-      end
+            # We need to call with_mix_project once again
+            # here in case the dependency was not available
+            # the first time and the callback hook just
+            # happened to fetch it.
+            { with_mix_project(dep, project).deps(deps), rest }
+          end)
+
+        Mix.Deps.available?(dep) and rebarconfig?(dep) ->
+          dep = rebar_dep(dep)
 
-      { dep, rest }
+          Mix.Deps.in_dependency(dep, post_config, fn _ ->
+            { deps, rest } = all(rest, rebar_children("."), post_config, callback)
+            { dep.deps(deps), rest }
+          end)
+
+        true ->
+          { dep, rest }
+      end
     end
   end
 
@@ -48,21 +62,10 @@ defmodule Mix.Deps.Retriever do
   as a `Mix.Dep` record. Unlike with `all` the `deps`
   field is not populated.
   """
-  def children() do
-    deps = Mix.project[:deps] || []
-    scms = Mix.SCM.available
-
-    Enum.map deps, fn dep ->
-      dep = with_scm_and_status(dep, scms)
-
-      if Mix.Deps.available?(dep) and mixfile?(dep) do
-        Mix.Deps.in_dependency dep, fn project ->
-          with_mix_project(dep, project)
-        end
-      else
-        dep
-      end
-    end
+  def children(post_config // []) do
+    Mix.Project.recur(post_config, fn _ ->
+      (Mix.project[:deps] || []) |> setup_deps
+    end) |> List.concat
   end
 
   @doc """
@@ -74,16 +77,50 @@ defmodule Mix.Deps.Retriever do
 
   ## Helpers
 
-  defp with_mix_project(Mix.Dep[project: nil] = dep, project) do
+  defp rebar_children(dir) do
+    Mix.Rebar.recur(dir, fn config ->
+      Mix.Rebar.deps(config) |> setup_deps
+    end) |> List.concat
+  end
+
+  defp setup_deps(deps) do
+    scms = Mix.SCM.available
+
+    Enum.map deps, fn dep ->
+      dep = with_scm_and_status(dep, scms)
+
+      cond do
+        Mix.Deps.available?(dep) and mixfile?(dep) ->
+          Mix.Deps.in_dependency(dep, fn project ->
+            with_mix_project(dep, project)
+          end)
+
+        Mix.Deps.available?(dep) and rebarconfig?(dep) ->
+          rebar_dep(dep)
+
+        true ->
+          dep
+      end
+    end
+  end
+
+  defp with_mix_project(Mix.Dep[manager: nil] = dep, project) do
     if match?({ :noappfile, _ }, dep.status) and Mix.Project.umbrella? do
       dep = dep.update_opts(Keyword.put(&1, :app, false))
                .status({ :ok, nil })
     end
-    dep.project(project)
+    dep.manager(:mix).source(project)
   end
 
   defp with_mix_project(dep, _project), do: dep
 
+  defp rebar_dep(Mix.Dep[manager: nil, opts: opts] = dep) do
+    config = Mix.Rebar.load_config(opts[:dest])
+    dep.manager(:rebar).source(config)
+  end
+
+  defp rebar_dep(dep), do: dep
+
   defp with_scm_and_status({ app, opts }, scms) when is_atom(app) and is_list(opts) do
     with_scm_and_status({ app, nil, opts }, scms)
   end
@@ -156,6 +193,12 @@ defmodule Mix.Deps.Retriever do
   defp vsn_match?(expected, actual) when is_regex(expected),  do: actual =~ expected
 
   defp mixfile?(dep) do
-    File.regular?(Path.join dep.opts[:dest], "mix.exs")
+    File.regular?(Path.join(dep.opts[:dest], "mix.exs"))
+  end
+
+  defp rebarconfig?(dep) do
+    Enum.any?(["rebar.config", "rebar.config.script"], fn file ->
+      File.regular?(Path.join(dep.opts[:dest], file))
+    end)
   end
 end

lib/mix/lib/mix/project.ex

@@ -149,7 +149,7 @@ defmodule Mix.Project do
   use this function to transparently go through the project, regardless
   if it is an umbrella project or not.
   """
-  def recur(fun) do
+  def recur(post_config // [], fun) do
     if apps_path = config[:apps_path] do
       paths = Path.wildcard(Path.join(apps_path, "*"))
       paths = Enum.filter(paths, File.dir?(&1))
@@ -163,11 +163,12 @@ defmodule Mix.Project do
       projects = topsort_projects(projects, Path.expand(apps_path))
 
       results = Enum.map projects, fn { app, app_path } ->
-        in_project(app, app_path, fun)
+        in_project(app, app_path, post_config, fun)
       end
 
       results
     else
+      # Note that post_config isnt used for this case
       [fun.(get)]
     end
   end