Support aliases in Mix.Task.run/2

Author: José Valim

lib/mix/lib/mix/cli.ex

@@ -60,7 +60,7 @@ defmodule Mix.CLI do
       # If the task is not available, let's try to
       # compile the repository and then run it again.
       cond do
-        match?({:ok, _}, Mix.Task.get(name)) ->
+        Mix.Task.get(name) ->
           Mix.Task.run(name, args)
         Mix.Project.get ->
           Mix.Task.run("compile")

lib/mix/lib/mix/project.ex

@@ -57,7 +57,7 @@ defmodule Mix.Project do
         :ok
       {:error, other} when is_binary(other) ->
         Mix.raise "Trying to load #{inspect atom} from #{inspect file}" <>
-          " but another project with the same name was already defined at #{inspect other}"
+                  " but another project with the same name was already defined at #{inspect other}"
     end
   end
 
@@ -359,7 +359,8 @@ defmodule Mix.Project do
   end
 
   defp default_config do
-    [build_per_environment: true,
+    [aliases: [],
+     build_per_environment: true,
      default_task: "run",
      deps: [],
      deps_path: "deps",

lib/mix/lib/mix/task.ex

@@ -150,14 +150,11 @@ defmodule Mix.Task do
   Otherwise returns `{:error, :invalid}` in case the module
   exists but it isn't a task or `{:error, :not_found}`.
   """
-  @spec get(task_name) :: {:ok, task_module} | {:error, :invalid} | {:error, :not_found}
-
-  def get(task) when is_binary(task) or is_atom(task) do
-    case Mix.Utils.command_to_module(to_string(task), Mix.Tasks) do
-      {:module, module} ->
-        if task?(module), do: {:ok, module}, else: {:error, :invalid}
-      {:error, _} ->
-        {:error, :not_found}
+  @spec get(task_name) :: task_module | nil
+  def get(task) do
+    case fetch(task) do
+      {:ok, module} -> module
+      {:error, _}   -> nil
     end
   end
 
@@ -172,7 +169,7 @@ defmodule Mix.Task do
   """
   @spec get!(task_name) :: task_module | no_return
   def get!(task) do
-    case get(task) do
+    case fetch(task) do
       {:ok, module} ->
         module
       {:error, :invalid} ->
@@ -182,6 +179,15 @@ defmodule Mix.Task do
     end
   end
 
+  defp fetch(task) when is_binary(task) or is_atom(task) do
+    case Mix.Utils.command_to_module(to_string(task), Mix.Tasks) do
+      {:module, module} ->
+        if task?(module), do: {:ok, module}, else: {:error, :invalid}
+      {:error, _} ->
+        {:error, :not_found}
+    end
+  end
+
   @doc """
   Runs a `task` with the given `args`.
 
@@ -197,62 +203,101 @@ defmodule Mix.Task do
   @spec run(task_name, [any]) :: any
   def run(task, args \\ []) when is_binary(task) or is_atom(task) do
     task = to_string(task)
+    proj = Mix.Project.get
+
+    alias = Mix.Project.config[:aliases][String.to_atom(task)]
+
+    cond do
+      alias && Mix.TasksServer.run({:alias, task, proj}) ->
+        res = run_alias(List.wrap(alias), args, :ok)
+        Mix.TasksServer.put({:task, task, proj})
+        res
+      Mix.TasksServer.run({:task, task, proj}) ->
+        run_task(task, args)
+      true ->
+        :noop
+    end
+  end
 
-    if Mix.TasksServer.run_task(task, Mix.Project.get) do
-      module = get!(task)
+  defp run_task(task, args) do
+    module = get!(task)
 
-      recur module, fn proj ->
-        Mix.TasksServer.put_task(task, proj)
-        module.run(args)
-      end
+    fun = fn proj ->
+      Mix.TasksServer.put({:task, task, proj})
+      module.run(args)
+    end
+
+    if recursive(module) and Mix.Project.umbrella? and Mix.ProjectStack.enable_recursion do
+      res = recur(fun)
+      Mix.ProjectStack.disable_recursion
+      res
     else
-      :noop
+      fun.(Mix.Project.get)
     end
   end
 
+  defp run_alias([h|t], alias_args, _res) when is_binary(h) do
+    [task|args] = OptionParser.split(h)
+    res = Mix.Task.run task, join_args(args, alias_args, t)
+    run_alias(t, alias_args, res)
+  end
+
+  defp run_alias([h|t], alias_args, _res) when is_function(h, 1) do
+    res = h.(join_args([], alias_args, t))
+    run_alias(t, alias_args, res)
+  end
+
+  defp run_alias([], _alias_task, res) do
+    res
+  end
+
+  defp join_args(args, alias_args, []), do: args ++ alias_args
+  defp join_args(args, _alias_args, _), do: args
+
   @doc """
   Clears all invoked tasks, allowing them to be reinvoked.
+
+  This operation is not recursive.
   """
   @spec clear :: :ok
   def clear do
-    Mix.TasksServer.clear_tasks
+    Mix.TasksServer.clear
   end
 
   @doc """
   Reenables a given task so it can be executed again down the stack.
 
-  If an umbrella project reenables a task it is reenabled for all sub projects.
+  Both alias and the regular stack are reenabled when this function
+  is called.
+
+  If an umbrella project reenables a task, it is reenabled for all
+  children projects.
   """
   @spec reenable(task_name) :: :ok
   def reenable(task) when is_binary(task) or is_atom(task) do
-    task   = to_string(task)
-    module = get!(task)
+    task = to_string(task)
+    proj = Mix.Project.get
 
-    Mix.TasksServer.delete_task(task, Mix.Project.get)
+    Mix.TasksServer.delete_many([{:task, task, proj},
+                                 {:alias, task, proj}])
 
-    recur module, fn project ->
-      Mix.TasksServer.delete_task(task, project)
+    if (module = get(task)) && recursive(module) && Mix.Project.umbrella? do
+      recur fn proj ->
+        Mix.TasksServer.delete_many([{:task, task, proj},
+                                     {:alias, task, proj}])
+      end
     end
 
     :ok
   end
 
-  defp recur(module, fun) do
-    umbrella? = Mix.Project.umbrella?
-    recursive = recursive(module)
-
-    if umbrella? && recursive && Mix.ProjectStack.enable_recursion do
-      # 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
-      Mix.ProjectStack.disable_recursion
-      res
-    else
-      fun.(Mix.Project.get)
+  defp recur(fun) do
+    # 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)
+    for %Mix.Dep{app: app, opts: opts} <- Mix.Dep.Umbrella.loaded do
+      Mix.Project.in_project(app, opts[:path], config, fun)
     end
   end
 

lib/mix/lib/mix/tasks_server.ex

@@ -5,23 +5,22 @@ defmodule Mix.TasksServer do
     Agent.start_link(fn -> HashSet.new end, name: __MODULE__)
   end
 
-  def clear_tasks() do
+  def clear() do
     update fn _ -> HashSet.new end
   end
 
-  def run_task(task, proj) do
-    run_item = { task, proj }
+  def run(tuple) do
     get_and_update fn set ->
-      { not(run_item in set), Set.put(set, run_item) }
+      {not(tuple in set), Set.put(set, tuple)}
     end
   end
 
-  def put_task(task, proj) do
-    update &Set.put(&1, { task, proj })
+  def put(tuple) do
+    update &Set.put(&1, tuple)
   end
 
-  def delete_task(task, proj) do
-    update &Set.delete(&1, { task, proj })
+  def delete_many(many) do
+    update &Enum.reduce(many, &1, fn x, acc -> Set.delete(acc, x) end)
   end
 
   defp get_and_update(fun) do

lib/mix/test/mix/aliases_test.exs

@@ -0,0 +1,47 @@
+Code.require_file "../test_helper.exs", __DIR__
+
+defmodule Mix.AliasesTest do
+  use MixTest.Case
+
+  defmodule Aliases do
+    def project do
+      [aliases: [h: "hello",
+                 p: &inspect/1,
+                 compile: "hello",
+                 "nested.h": [&Mix.shell.info(inspect(&1)), "h foo bar"]]]
+    end
+  end
+
+  setup do
+    Mix.Project.push Aliases
+    :ok
+  end
+
+  test "runs string aliases" do
+    assert Mix.Task.run("h", []) == "Hello, World!"
+    assert Mix.Task.run("h", []) == :noop
+    assert Mix.Task.run("hello", []) == :noop
+
+    Mix.Task.reenable "h"
+    Mix.Task.reenable "hello"
+    assert Mix.Task.run("h", ["foo", "bar"]) == "Hello, foo bar!"
+  end
+
+  test "runs function aliases" do
+    assert Mix.Task.run("p", []) == "[]"
+    assert Mix.Task.run("p", []) == :noop
+
+    Mix.Task.reenable "p"
+    assert Mix.Task.run("p", ["foo", "bar"]) == "[\"foo\", \"bar\"]"
+  end
+
+  test "runs list aliases" do
+    assert Mix.Task.run("nested.h", ["baz"]) == "Hello, foo bar baz!"
+    assert_received {:mix_shell, :info, ["[]"]}
+  end
+
+  test "run alias override" do
+    assert Mix.Task.run("compile", []) == "Hello, World!"
+    assert Mix.Task.run("compile", []) == :noop
+  end
+end

lib/mix/test/mix/task_test.exs

@@ -1,40 +1,9 @@
 Code.require_file "../test_helper.exs", __DIR__
 
-path = MixTest.Case.tmp_path("beams")
-File.rm_rf!(path)
-File.mkdir_p!(path)
-
-write_beam = fn {:module, name, bin, _} ->
-  path
-  |> Path.join(Atom.to_string(name) <> ".beam")
-  |> File.write!(bin)
-end
-
-defmodule Mix.Tasks.Hello do
-  use Mix.Task
-  @shortdoc "This is short documentation, see"
-
-  @moduledoc """
-  A test task.
-  """
-
-  def run(_) do
-    "Hello, World!"
-  end
-end |> write_beam.()
-
-defmodule Mix.Tasks.Invalid do
-end |> write_beam.()
-
 defmodule Mix.TaskTest do
   use MixTest.Case
 
-  setup do
-    Code.prepend_path unquote(path)
-    :ok
-  end
-
-  test :run do
+  test "run/1" do
     assert Mix.Task.run("hello") == "Hello, World!"
     assert Mix.Task.run("hello") == :noop
 
@@ -47,19 +16,19 @@ defmodule Mix.TaskTest do
     end
   end
 
-  test :clear do
+  test "clear/0" do
     assert Mix.Task.run("hello") == "Hello, World!"
     Mix.Task.clear
     assert Mix.Task.run("hello") == "Hello, World!"
   end
 
-  test :reenable do
+  test "reenable/1" do
     assert Mix.Task.run("hello") == "Hello, World!"
     Mix.Task.reenable("hello")
     assert Mix.Task.run("hello") == "Hello, World!"
   end
 
-  test "reenable for umbrella" do
+  test "reenable/1 for umbrella" do
     in_fixture "umbrella_dep/deps/umbrella", fn ->
       Mix.Project.in_project(:umbrella, ".", fn _ ->
         assert [:ok, :ok] = Mix.Task.run "clean"
@@ -72,7 +41,7 @@ defmodule Mix.TaskTest do
     end
   end
 
-  test :get! do
+  test "get!" do
     assert Mix.Task.get!("hello") == Mix.Tasks.Hello
 
     assert_raise Mix.NoTaskError, "The task unknown could not be found", fn ->
@@ -84,18 +53,19 @@ defmodule Mix.TaskTest do
     end
   end
 
-  test :all_modules do
+  test "all_modules/0" do
     Mix.Task.load_all
     modules = Mix.Task.all_modules
     assert Mix.Tasks.Hello in modules
     assert Mix.Tasks.Compile in modules
   end
 
-  test :moduledoc do
+  test "moduledoc/1" do
+    Code.prepend_path MixTest.Case.tmp_path("beams")
     assert Mix.Task.moduledoc(Mix.Tasks.Hello) == "A test task.\n"
   end
 
-  test :shortdoc do
+  test "shortdoc/1" do
     assert Mix.Task.shortdoc(Mix.Tasks.Hello) == "This is short documentation, see"
   end
 end