No longer support .beam files on mix local

Author: José Valim

CHANGELOG.md

@@ -23,6 +23,7 @@
 * backwards incompatible changes
   * [File] `rm_rf` and `cp_r` now returns a tuple with three elements on failures
   * [Kernel] The quoted representation for `->` clauses changed from a tuple with two elements to a tuple with three elements to support metadata
+  * [Mix] No longer support beam files on `mix local`
 
 # v0.9.2 (2013-06-13)
 

lib/mix/lib/mix/cli.ex

@@ -52,7 +52,7 @@ defmodule Mix.CLI do
   end
 
   defp proceed(args) do
-    Mix.Local.append_tasks
+    Mix.Local.append_archives
     Mix.Local.append_paths
 
     args = load_mixfile(args)

lib/mix/lib/mix/local.ex

@@ -1,40 +1,36 @@
 defmodule Mix.Local do
   @moduledoc """
-  Module responsible to manage local .mix installation.
+  Module responsible to manage local mix archives and paths.
   """
 
   @doc """
-  The path for local tasks and archives.
+  The path for local archives.
   """
-  def tasks_path do
-    Path.join Mix.Utils.mix_home, "tasks"
+  def archives_path do
+    Path.join Mix.Utils.mix_home, "archives"
   end
 
   @doc """
-  Append local tasks and archives paths into Erlang code path.
+  Append archives paths into Erlang code path.
   """
-  def append_tasks do
-    Enum.each(all_tasks_paths, Code.append_path(&1))
+  def append_archives do
+    Enum.each(archives_ebin, Code.append_path(&1))
   end
 
   @doc """
   Append mix paths into Erlang code path.
   """
   def append_paths do
-    Enum.each(Mix.Utils.mix_path, Code.append_path(&1))
+    Enum.each(Mix.Utils.mix_paths, Code.append_path(&1))
   end
 
   @doc """
-  Returns all tasks modules in ~/.mix/tasks and archives.
+  Returns all tasks in local archives.
   """
-  def all_tasks, do: Mix.Task.load_paths(all_tasks_paths)
+  def all_tasks, do: Mix.Task.load_tasks(archives_ebin)
 
-  defp all_tasks_paths do
-    [tasks_path | archives_paths]
-  end
-
-  defp archives_paths do
-    Path.join(tasks_path, "*.ez") |> Path.wildcard |> Enum.map(archive_ebin(&1))
+  defp archives_ebin do
+    Path.join(archives_path, "*.ez") |> Path.wildcard |> Enum.map(archive_ebin(&1))
   end
 
   defp archive_ebin(archive_file) do

lib/mix/lib/mix/task.ex

@@ -25,12 +25,12 @@ defmodule Mix.Task do
   @doc """
   Loads all tasks in all code paths.
   """
-  def load_all, do: load_paths(:code.get_path)
+  def load_all, do: load_tasks(:code.get_path)
 
   @doc """
   Loads all tasks in given paths.
   """
-  def load_paths(paths) do
+  def load_tasks(paths) do
     Enum.reduce(paths, [], fn(path, matches) ->
       { :ok, files } = :erl_prim_loader.list_dir(path |> :unicode.characters_to_list)
       Enum.reduce(files, matches, match_tasks(&1, &2))

lib/mix/lib/mix/tasks/local.install.ex

@@ -6,27 +6,26 @@ defmodule Mix.Tasks.Local.Install do
   @shortdoc "Install a task or an archive locally"
 
   @moduledoc """
-  Install a task or an archive locally.
+  Install an archive locally.
 
   If no argument is supplied but there is an archive in the root
   (created with mix archive), then the archive will be installed
   locally. For example:
   
       mix do archive, local.install
 
-  The task can also be a single local beam file or a beam
-  file located at some URL.
+  The task can also be an archive located at some URL:
 
-      mix local.install http://example.com/some_task.beam
+      mix local.install http://example.com/foo.ez
 
-  After installed, the task can be invoked locally:
+  After installed, the tasks in the archive are available locally:
 
       mix some_task
 
   ## Command line options
 
   * `--force` forces installation without a shell prompt. Primarily
-    intended for automation in build systems like Make.
+    intended for automation in build systems like make.
 
   """
 
@@ -41,50 +40,16 @@ defmodule Mix.Tasks.Local.Install do
     end
 
     case Path.extname(path) do
-      ".ez"   -> install_archive(path, opts)
-      ".beam" -> install_beam(path, opts)
-      _ ->
-        raise Mix.Error, message: "mix local.install doesn't know how to install #{path}"
+      ".ez" -> install_archive(path, opts)
+      _     -> raise Mix.Error, message: "mix local.install doesn't know how to install #{path}"
     end
   end
 
-  defp install_beam(path, opts) do
-    beam = Mix.Utils.read_path(path)
-    { :module, module } = get_module(path, beam)
-
-    validate_module_name!(path, module)
-    task_name = Mix.Task.task_name(module)
-
-    if opts[:force] || Mix.shell.yes?("Are you sure you want to install task #{inspect task_name}?") do
-      tasks = Mix.Local.tasks_path
-      File.mkdir_p! tasks
-      create_file Path.join(tasks, "#{module}.beam"), beam
-    end
-  end
-
-  defp install_archive(name, opts) do
-    if opts[:force] || Mix.shell.yes?("Are you sure you want to install archive #{name}?") do
-      tasks = Mix.Local.tasks_path
-      File.mkdir_p! tasks
-      File.copy(name, Path.join(tasks, name))
-    end
-  end
-
-  defp get_module(path, beam) do
-    case :beam_lib.info(beam) do
-      list when is_list(list) ->
-        List.keyfind list, :module, 0
-      _ ->
-        raise Mix.Error, message: "could not parse beam file at #{path}"
-    end
-  end
-
-  defp validate_module_name!(path, module) do
-    case atom_to_binary(module) do
-      "Elixir.Mix.Tasks." <> _ ->
-        :ok
-      other ->
-        raise Mix.Error, message: "expected a Mix.Tasks module at #{path}, got #{other}"
+  defp install_archive(src, opts) do
+    if opts[:force] || Mix.shell.yes?("Are you sure you want to install archive #{src}?") do
+      dest = Mix.Local.archives_path
+      File.mkdir_p! dest
+      create_file Path.join(dest, Path.basename(src)), Mix.Utils.read_path(src)
     end
   end
 end

lib/mix/lib/mix/tasks/local.uninstall.ex

@@ -17,14 +17,16 @@ defmodule Mix.Tasks.Local.Uninstall do
 
   defp do_uninstall(task) do
     case Path.extname(task) do
-      ".ez" -> File.rm! Path.join(Mix.Local.tasks_path, task)
+      ".ez" -> File.rm! Path.join(Mix.Local.archives_path, task)
       _ ->
         task_module = Mix.Task.get(task)
-        if archive = in_archive('#{task_module}.beam') do
-          raise Mix.Error, message: "The task #{task} is part of archive #{archive}. " <>
-            "To uninstall this task, please run: `mix local.uninstall #{archive}`"
+        archive = in_archive('#{task_module}.beam')
+
+        if archive && Mix.shell.yes?("The task #{task} is part of archive #{archive}. " <>
+             "Do you want to remove this archive?") do
+          do_uninstall(archive)
         else
-          File.rm! Path.join(Mix.Local.tasks_path, "#{task_module}.beam")
+          raise Mix.Error, message: "cannot uninstall task #{task}"
         end
     end
   end

lib/mix/lib/mix/utils.ex

@@ -28,7 +28,7 @@ defmodule Mix.Utils do
   those paths should be separated by `;`, if on unix systems,
   use `:`.
   """
-  def mix_path do
+  def mix_paths do
     if path = System.get_env("MIX_PATH") do
       String.split(path, path_separator)
     else

lib/mix/test/mix/tasks/local_archive_test.exs

@@ -3,36 +3,45 @@ Code.require_file "../../test_helper.exs", __DIR__
 defmodule Mix.Tasks.LocalTest do
   use MixTest.Case
 
-  test "manage local tasks" do
+  test "archive" do
     File.rm_rf! tmp_path("userhome")
     System.put_env "MIX_HOME", tmp_path("userhome/.mix")
 
-    # Install it!
-    self <- { :mix_shell_input, :yes?, true }
-    Mix.Tasks.Local.Install.run [fixture_path("beams/Elixir.Mix.Tasks.Local.Sample.beam")]
-    assert File.regular? tmp_path("userhome/.mix/tasks/Elixir.Mix.Tasks.Local.Sample.beam")
-
-    # List it!
-    Mix.Local.append_tasks
-    Mix.Tasks.Local.run []
-    assert_received { :mix_shell, :info, ["mix local.sample # A local install sample"] }
-
-    # Run it!
-    Mix.Task.run "local.sample"
-    assert_received { :mix_shell, :info, ["sample"] }
-
-    # Remove it!
-    Mix.Tasks.Local.Uninstall.run ["local.sample"]
-    refute File.regular? tmp_path("userhome/.mix/tasks/Elixir.Mix.Tasks.Local.Sample.beam")
+    in_fixture "archive", fn() ->
+      # Install it!
+      Mix.Tasks.Archive.run ["--no_compile"]
+      assert File.regular? "test archive.ez"
+
+      self <- { :mix_shell_input, :yes?, true }
+      Mix.Tasks.Local.Install.run ["test archive.ez"]
+      assert File.regular? tmp_path("userhome/.mix/archives/test archive.ez")
+
+      # List it!
+      Mix.Local.append_archives
+      Mix.Tasks.Local.run []
+      assert_received { :mix_shell, :info, ["mix local.sample # A local install sample"] }
+
+      # Run it!
+      Mix.Task.run "local.sample"
+      assert_received { :mix_shell, :info, ["sample"] }
+
+      # Remove it!
+      self <- { :mix_shell_input, :yes?, true }
+      Mix.Tasks.Local.Uninstall.run ["local.sample"]
+      refute File.regular? tmp_path("userhome/.mix/archives/test archive.ez")
+    end
   end
 
-  test "manage mix paths" do
-    File.rm_rf! tmp_path("userhome")
-    System.put_env "MIX_PATH", tmp_path("userhome/.mix")
+  test "MIX_PATH" do
+    File.rm_rf! tmp_path("mixpath")
+    System.put_env "MIX_PATH", tmp_path("mixpath/ebin")
+
+    File.mkdir_p! tmp_path("mixpath/ebin")
+    Mix.Local.append_paths
 
     # Install on MIX_PATH manually
-    File.cp fixture_path("beams/Elixir.Mix.Tasks.Local.Sample.beam"),
-            tmp_path("userhome/.mix/tasks/Elixir.Mix.Tasks.Local.Sample.beam")
+    File.copy! fixture_path("beams/Elixir.Mix.Tasks.Local.Sample.beam"),
+               tmp_path("mixpath/ebin/Elixir.Mix.Tasks.Local.Sample.beam")
 
     # Run it
     Mix.Task.run "local.sample"