Unify the common code involved in installing archives and escripts

Author: alco

lib/mix/lib/mix/escript.ex

@@ -3,22 +3,42 @@ defmodule Mix.Local do
 
  @public_keys_html "https://s3.amazonaws.com/s3.hex.pm/installs/public_keys.html"
 
+ @type item :: :archive | :escript
+
  @doc """
- The path for local archives.
+ Returns the name for an archive or an escript, based on on the project config.
+
+ ## Examples
+
+ iex> Mix.Local.name_for(:archive, [app: "foo", version: "0.1.0"])
+ "foo-0.1.0.ez"
+
+ iex> Mix.Local.name_for(:escript, [escript: [name: "foo"]])
+ "foo"
 
- Check `mix archive` for info.
  """
- def archives_path do
- System.get_env("MIX_ARCHIVES") ||
- Path.join(Mix.Utils.mix_home, "archives")
+ @spec name_for(item, Keyword.t) :: String.t
+ def name_for(:archive, project) do
+ version = if version = project[:version], do: "-#{version}"
+ "#{project[:app]}#{version}.ez"
  end
 
- @doc """
- The path for local escripts.
+ def name_for(:escript, project) do
+ case get_in(project, [:escript, :name]) do
+ nil -> project[:app]
+ name -> name
+ end |> to_string()
+ end
 
- Check `mix escript` for info.
+ @doc """
+ The path for local archives or escripts.
  """
- def escripts_path do
+ @spec path_for(item) :: String.t
+ def path_for(:archive) do
+ System.get_env("MIX_ARCHIVES") || Path.join(Mix.Utils.mix_home, "archives")
+ end
+
+ def path_for(:escript) do
  Path.join(Mix.Utils.mix_home, "escripts")
  end
 
@@ -61,13 +81,13 @@ defmodule Mix.Local do
  end
 
  defp archives(name, suffix) do
- archives_path()
+ path_for(:archive)
  |> Path.join(name <> suffix)
  |> Path.wildcard
  end
 
  defp archives_ebin do
- Path.join(archives_path(), "*.ez") |> Path.wildcard |> Enum.map(&Mix.Archive.ebin/1)
+ Path.join(path_for(:archive), "*.ez") |> Path.wildcard |> Enum.map(&Mix.Archive.ebin/1)
  end
 
  defp check_elixir_version_in_ebin(ebin) do

lib/mix/lib/mix/local.ex

@@ -5,65 +5,180 @@ defmodule Mix.Local.Installer do
  """
 
  @doc """
- Print a list of items in a uniform way. Used for printing the list of installed archives and
- escripts.
+ Checks that the argument given to install is supported by the respective module.
+ """
+ @callback check_path_or_url(String.t) :: :ok | {:error, String.t}
 
- ## Options
+ @doc """
+ Returns a list of already installed version of the same archive or escript.
+ """
+ @callback find_previous_versions(String.t, Path.t) :: [Path.t]
 
- * `:empty_message` - the message to print when there are no items
- * `:footnote` - the message to print after the list
+ @doc """
+ Custom actions to be performed before the actual installation.
+ """
+ @callback before_install(String.t, Path.t) :: :ok | {:error, String.t}
 
+ @doc """
+ Custom actions to be performed after the installation has succeeded.
  """
- def print_list([], options) do
- Mix.shell.info Keyword.get(options, :empty_message, "No items found.")
+ @callback after_install(Path.t, [Path.t]) :: term
+
+ @doc """
+ Common implementation of installation for archives and escripts.
+
+ Relies on a few callbacks provided by respective callback modules
+ for customizing certain steps in the installation process.
+ """
+ @spec install({module, atom}, OptionParser.argv, Keyword.t) :: boolean
+ def install({module, name}, argv, switches) do
+ {opts, args, _} = OptionParser.parse(argv, switches: switches)
+
+ case args do
+ [src] ->
+ with :ok <- check_argument(src), :ok <- module.check_path_or_url(src) do
+ do_install({module, name}, src, opts)
+ else
+ {:error, message} -> Mix.raise message <> "\n" <> usage(name)
+ end
+
+ [] ->
+ src = Mix.Local.name_for(name, Mix.Project.config)
+ if File.exists?(src) do
+ do_install({module, name}, src, opts)
+ else
+ Mix.raise "Expected an #{name} to exist in the current directory " <>
+ "or an argument to be given.\n#{usage(name)}"
+ end
+
+ _ ->
+ Mix.raise "Unexpected arguments.\n#{usage(name)}"
+ end
  end
 
- def print_list(items, options) do
- Enum.each items, fn item -> Mix.shell.info ["* ", item] end
- Mix.shell.info Keyword.get(options, :footnote, "")
+ defp check_argument(arg) do
+ if local_path?(arg) or file_url?(arg) do
+ :ok
+ else
+ {:error, "Expected a local file path or a file URL."}
+ end
  end
 
- @doc """
- A common implementation for uninstalling archives, scripts, etc.
+ defp local_path?(url_or_path) do
+ File.regular?(url_or_path)
+ end
+
+ defp file_url?(url_or_path) do
+ URI.parse(url_or_path).scheme in ["http", "https"]
+ end
+
+ defp usage(name), do: "Usage: mix #{name}.install <path or url>"
+
+ defp do_install({module, name}, src, opts) do
+ src_basename = URI.parse(src).path
+ dst_dir_path = Mix.Local.path_for(name)
+ dst_file_path = Path.join(dst_dir_path, src_basename)
+ previous_files = module.find_previous_versions(src, dst_file_path)
+
+ if opts[:force] || should_install?(name, src, previous_files) do
+ case module.before_install(src, dst_file_path) do
+ :ok -> :ok
+ {:error, message} -> Mix.raise message
+ end
+
+ case Mix.Utils.read_path(src, opts) do
+ {:ok, binary} ->
+ File.mkdir_p!(dst_dir_path)
+ File.write!(dst_file_path, binary)
+
+ :badpath ->
+ Mix.raise "Expected #{inspect src} to be a URL or a local file path"
 
- ## Options
+ {:local, message} ->
+ Mix.raise message
 
- * `:item_name` - the name of the item being uninstalled. Also the name of the task which is used
- to print a list of all such items
- * `:item_plural` - plural of item name
+  {kind, message} when kind in [:remote, :checksum] ->
+  Mix.raise """
+  #{message}
 
+ Could not fetch #{name} at:
+
+ #{src}
+
+ Please download the #{name} above manually to your current directory and run:
+
+ mix #{name}.install ./#{src_basename}
+ """
+ end
+
+ Mix.shell.info [:green, "* creating ", :reset, Path.relative_to_cwd(dst_file_path)]
+ _ = module.after_install(dst_file_path, previous_files)
+ true
+ else
+ false
+ end
+ end
+
+ defp should_install?(name, src, previous_files) do
+ message = case previous_files do
+ [] ->
+ "Are you sure you want to install #{name} #{inspect src}?"
+ [file] ->
+ "Found existing #{name}: #{file}.\n" <>
+ "Are you sure you want to replace it with #{inspect src}?"
+ files ->
+ "Found existing #{name}s: #{Enum.map_join(files, ", ", &Path.basename/1)}.\n" <>
+ "Are you sure you want to replace them with #{inspect src}?"
+ end
+ Mix.shell.yes?(message)
+ end
+
+ @doc """
+ Print a list of items in a uniform way. Used for printing the list of installed archives and
+ escripts.
+ """
+ @spec print_list(atom, [String.t]) :: :ok
+ def print_list(type, []) do
+ Mix.shell.info "No #{type}s currently installed."
+ end
+
+ def print_list(type, items) do
+ Enum.each items, fn item -> Mix.shell.info ["* ", item] end
+ item_name = String.capitalize("#{type}")
+ Mix.shell.info "#{item_name}s installed at: #{Mix.Local.path_for(type)}"
+ end
+
+ @doc """
+ A common implementation for uninstalling archives and scripts.
  """
- def uninstall(argv, root, options) do
+ @spec uninstall(atom, OptionParser.argv) :: boolean
+ def uninstall(type, argv) do
  {_, argv, _} = OptionParser.parse(argv)
 
- item_name = Keyword.fetch!(options, :item_name)
- item_plural = Keyword.fetch!(options, :item_plural)
+ item_name = "#{type}"
+ item_plural = "#{type}s"
+ root = Mix.Local.path_for(type)
 
  if name = List.first(argv) do
  path = Path.join(root, name)
  if File.regular?(path) do
- if should_uninstall?(path, item_name), do: File.rm!(path)
+ if should_uninstall?(path, item_name) do
+ File.rm!(path)
+ true
+ else
+ false
+ end
  else
  Mix.shell.error "Could not find a local #{item_name} named #{inspect name}. "<>
  "Existing #{item_plural} are:"
  Mix.Task.run item_name
+ false
  end
  else
  Mix.raise "No #{item_name} was given to #{item_name}.uninstall"
  end
  end
 
- @doc """
- Parse `path_or_url` as a URI and return its base name.
- """
- def basename(path_or_url) do
- if path = URI.parse(path_or_url).path do
- Path.basename(path)
- else
- Mix.raise "Expected #{inspect path_or_url} to be a url or a local file path"
- end
- end
-
  defp should_uninstall?(path, item_name) do
  Mix.shell.yes?("Are you sure you want to uninstall #{item_name} #{path}?")
  end

lib/mix/lib/mix/local/installer.ex

@@ -57,11 +57,12 @@ defmodule Mix.Tasks.Archive.Build do
  "please pass -i as an option"
  end
 
+ project_config = Mix.Project.config
  target = cond do
  output = opts[:output] ->
  output
- app = Mix.Project.config[:app] ->
- Mix.Archive.name(app, Mix.Project.config[:version])
+ project_config[:app] ->
+ Mix.Local.name_for(:archive, project_config)
  true ->
  Mix.raise "Cannot create archive without output file, " <>
  "please pass -o as an option"

lib/mix/lib/mix/tasks/archive.build.ex

@@ -18,13 +18,10 @@ defmodule Mix.Tasks.Archive do
  @spec run(OptionParser.argv) :: :ok
  def run(_) do
  archives =
- Mix.Local.archives_path
+ Mix.Local.path_for(:archive)
  |> Path.join("*.ez")
  |> Path.wildcard()
  |> Enum.map(&Path.basename/1)
-
- Mix.Local.Installer.print_list(archives,
- empty_message: "No archives currently installed.",
- footnote: "Archives installed at: #{Mix.Local.archives_path}")
+ Mix.Local.Installer.print_list(:archive, archives)
  end
 end