Merge branch 'jv-nerves' into v1.2

Author: José Valim

lib/elixir/lib/application.ex

@@ -133,14 +133,16 @@ defmodule Application do
   @doc """
   Returns the value for `key` in `app`'s specification.
 
-  See `spec/1` for the supporte keys. If the given
+  See `spec/1` for the supported keys. If the given
   specification parameter does not exist, this function
-  will raise.
+  will raise. Returns `nil` if the application is not loaded.
   """
-  @spec spec(app, key) :: value
+  @spec spec(app, key) :: value | nil
   def spec(app, key) when key in @application_keys do
-    {:ok, value} = :application.get_key(app, key)
-    value
+    case :application.get_key(app, key) do
+      {:ok, value} -> value
+      :undefined -> nil
+    end
   end
 
   @doc """

lib/elixir/test/elixir/application_test.exs

@@ -38,6 +38,7 @@ defmodule ApplicationTest do
   test "application specification" do
     assert is_list Application.spec(:elixir)
     assert Application.spec(:unknown) == nil
+    assert Application.spec(:unknown, :description) == nil
 
     assert Application.spec(:elixir, :description) == 'elixir'
     assert_raise FunctionClauseError, fn -> Application.spec(:elixir, :unknown) end

lib/mix/lib/mix/dep.ex

@@ -100,9 +100,12 @@ defmodule Mix.Dep do
 
     # Ensure all apps are atoms
     apps = to_app_names(given)
-
-    # We need to keep the order of deps, loaded/1 properly orders them
-    deps = Enum.filter(all_deps, &(&1.app in apps))
+    deps =
+      if opts[:include_children] do
+        get_deps_with_children(all_deps, apps)
+      else
+        get_deps(all_deps, apps)
+      end
 
     Enum.each apps, fn(app) ->
       unless Enum.any?(all_deps, &(&1.app == app)) do
@@ -113,6 +116,30 @@ defmodule Mix.Dep do
     deps
   end
 
+  defp get_deps(all_deps, apps) do
+    Enum.filter(all_deps, &(&1.app in apps))
+  end
+
+  defp get_deps_with_children(all_deps, apps) do
+    deps = get_children(all_deps, apps)
+    apps = deps |> Enum.map(& &1.app) |> Enum.uniq
+    get_deps(all_deps, apps)
+  end
+
+  defp get_children(_all_deps, []), do: []
+  defp get_children(all_deps, apps) do
+    # Current deps
+    deps = get_deps(all_deps, apps)
+
+    # Children apps
+    apps = for %{deps: children} <- deps,
+               %{app: app} <- children,
+               do: app
+
+    # Current deps + children deps
+    deps ++ get_children(all_deps, apps)
+  end
+
   @doc """
   Runs the given `fun` inside the given dependency project by
   changing the current working directory and loading the given

lib/mix/lib/mix/tasks/app.start.ex

@@ -21,6 +21,7 @@ defmodule Mix.Tasks.App.Start do
     * `--permanent` - start the application as permanent
     * `--no-compile` - do not compile even if files require compilation
     * `--no-protocols` - do not load consolidated protocols
+    * `--no-archives-check` - do not check archives
     * `--no-deps-check` - do not check dependencies
     * `--no-elixir-version-check` - do not check Elixir version
     * `--no-start` - do not start applications after compilation

lib/mix/lib/mix/tasks/archive.check.ex

@@ -0,0 +1,55 @@
+defmodule Mix.Tasks.Archive.Check do
+  use Mix.Task
+
+  @moduledoc """
+  Checks all archives are available.
+
+  Mix projects can specify required archives using
+  the `:archives` option:
+
+      archives: [{:foo, "~> 1.0.0"}]
+
+  This task guarantees this option is respected.
+  """
+  def run(_) do
+    archives = Mix.Project.config[:archives] || []
+
+    Enum.each archives, fn tuple ->
+      {archive, req} = parse_archive(tuple)
+      _   = Application.load(archive)
+      vsn = Application.spec(archive, :vsn)
+      cond do
+        is_nil(vsn) ->
+          Mix.raise "Archive \"#{archive}\" could not be found. " <>
+                    "Please make sure the archive is installed locally."
+        not Version.match?(List.to_string(vsn), req) ->
+          Mix.raise "Archive \"#{archive}-#{vsn}\" does not match requirement #{req}. " <>
+                    "Please update your archive version accordingly."
+        true ->
+          :ok
+      end
+    end
+  end
+
+  defp parse_archive({archive, req}) when is_atom(archive) and is_binary(req) do
+    case Version.parse_requirement(req) do
+      {:ok, req} ->
+        {archive, req}
+      :error ->
+        Mix.raise "Invalid requirement #{req} for archive \"#{archive}\""
+    end
+  end
+
+  defp parse_archive(other) do
+    Mix.raise """
+    Expected archive to be in the format:
+
+        {app :: atom, requirement :: binary}
+
+    got:
+
+        #{inspect other}
+
+    """
+  end
+end

lib/mix/lib/mix/tasks/clean.ex

@@ -47,7 +47,7 @@ defmodule Mix.Tasks.Clean do
 
   # Loadpaths without checks because compilers may be defined in deps.
   defp loadpaths! do
-    Mix.Task.run "loadpaths", ["--no-elixir-version-check", "--no-deps-check"]
+    Mix.Task.run "loadpaths", ["--no-elixir-version-check", "--no-deps-check", "--no-archives-check"]
     Mix.Task.reenable "loadpaths"
   end
 end

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

@@ -41,9 +41,10 @@ defmodule Mix.Tasks.Compile do
 
   ## Command line options
 
-    * `--list`          - list all enabled compilers
-    * `--no-deps-check` - skip checking of dependencies
-    * `--force`         - force compilation
+    * `--list`              - list all enabled compilers
+    * `--no-archives-check` - skip checking of archives
+    * `--no-deps-check`     - skip checking of dependencies
+    * `--force`             - force compilation
 
   """
   @spec run(OptionParser.argv) :: :ok | :noop
@@ -96,7 +97,7 @@ defmodule Mix.Tasks.Compile do
 
   # Loadpaths without checks because compilers may be defined in deps.
   defp loadpaths! do
-    Mix.Task.run "loadpaths", ["--no-elixir-version-check", "--no-deps-check"]
+    Mix.Task.run "loadpaths", ["--no-elixir-version-check", "--no-deps-check", "--no-archives-check"]
     Mix.Task.reenable "loadpaths"
   end
 

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

@@ -6,8 +6,8 @@ defmodule Mix.Tasks.Deps.Compile do
   @moduledoc """
   Compiles dependencies.
 
-  By default, compile all dependencies. A list of dependencies can
-  be given to force the compilation of specific dependencies.
+  By default, compile all dependencies. A list of dependencies
+  can be given to force the compilation of specific dependencies.
 
   This task attempts to detect if the project contains one of
   the following files and act accordingly:
@@ -22,23 +22,31 @@ defmodule Mix.Tasks.Deps.Compile do
 
       {:some_dependency, "0.1.0", compile: "command to compile"}
 
+  If a list of dependencies is given, Mix will attempt to compile
+  them as is. For example, if project `a` depends on `b`, calling
+  `mix deps.compile a` will compile `a` even if `b` is out of
+  date. This is to allow parts of the dependency tree to be
+  recompiled without propagating those changes upstream. To ensure
+  `b` is included in the compilation step, pass `--include-children`.
   """
 
   import Mix.Dep, only: [loaded: 1, available?: 1, loaded_by_name: 2,
                          format_dep: 1, make?: 1, mix?: 1]
 
+  @switches [include_children: :boolean]
+
   @spec run(OptionParser.argv) :: :ok
   def run(args) do
     Mix.Project.get!
 
-    case OptionParser.parse(args) do
+    case OptionParser.parse(args, switches: @switches) do
       {_, [], _} ->
-        # Because this command is invoked explicitly with
+        # Because this command may be invoked explicitly with
         # deps.compile, we simply try to compile any available
         # dependency.
         compile(Enum.filter(loaded(env: Mix.env), &available?/1))
-      {_, tail, _} ->
-        compile(loaded_by_name(tail, env: Mix.env))
+      {opts, tail, _} ->
+        compile(loaded_by_name(tail, [env: Mix.env] ++ opts))
     end
   end
 
@@ -47,7 +55,7 @@ defmodule Mix.Tasks.Deps.Compile do
     shell  = Mix.shell
     config = Mix.Project.deps_config
 
-    Mix.Task.run "deps.loadpaths"
+    Mix.Task.run "deps.precompile"
 
     compiled =
       Enum.map(deps, fn %Mix.Dep{app: app, status: status, opts: opts, scm: scm} = dep ->

lib/mix/lib/mix/tasks/deps.precompile.ex

@@ -0,0 +1,19 @@
+defmodule Mix.Tasks.Deps.Precompile do
+  use Mix.Task
+
+  @moduledoc """
+  Extension point for precompiling dependencies.
+
+  This is a task that can be aliased by projects
+  that need to execute certain tasks to before
+  compiling dependencies:
+
+      aliases: ["deps.precompile": ["nerves.precompile", "deps.precompile"]]
+
+  By default, this task has a single responsibility
+  of loading all dependencies paths.
+  """
+  def run(_) do
+    Mix.Task.run "deps.loadpaths"
+  end
+end

lib/mix/lib/mix/tasks/help.ex

@@ -109,7 +109,7 @@ defmodule Mix.Tasks.Help do
 
   # Loadpaths without checks because tasks may be defined in deps.
   defp loadpaths! do
-    Mix.Task.run "loadpaths", ["--no-elixir-version-check", "--no-deps-check"]
+    Mix.Task.run "loadpaths", ["--no-elixir-version-check", "--no-deps-check", "--no-archives-check"]
     Mix.Task.reenable "loadpaths"
   end