Mix.install: Add :config_path and :lockfile options (#12051)

Author: wojtekmach

lib/mix/lib/mix.ex

@@ -561,25 +561,31 @@ defmodule Mix do
     * `:elixir` - if set, ensures the current Elixir version matches the given
       version requirement (Default: `nil`)
 
+    * `:system_env` (since v1.13.0) - a list or a map of system environment variable
+      names with respective values as binaries. The system environment is made part
+      of the `Mix.install/2` cache, so different configurations will lead to different apps
+
     * `:config` (since v1.13.0) - a keyword list of keyword lists with application
       configuration to be set before the apps loaded. The configuration is part of
       the `Mix.install/2` cache, so different configurations will lead to different
       apps
 
-    * `:system_env` (since v1.13.0) - a list or a map of system environment variable
-      names with respective values as binaries. The system environment is made part
-      of the `Mix.install/2` cache, so different configurations will lead to different apps
+    * `:config_path` (since v1.14.0) - path to a configuration file. If a `runtime.exs`
+      file exists in the same directory as the given path, it is loaded too.
+
+    * `:lockfile` (since v1.14.0) - path to a lockfile to be used as a basis of
+      dependency resolution.
 
   ## Examples
 
-  To install `:decimal` and `:jason`:
+  Installing `:decimal` and `:jason`:
 
       Mix.install([
         :decimal,
         {:jason, "~> 1.0"}
       ])
 
-  Using `:nx`, `:exla`, and configure the underlying applications
+  Installing `:nx` & `:exla`, and configuring the underlying applications
   and environment variables:
 
       Mix.install(
@@ -592,6 +598,23 @@ defmodule Mix do
         ]
       )
 
+  Installing a Mix project as a path dependency along with its configuration
+  and deps:
+
+      # $ git clone https://github.com/hexpm/hexpm /tmp/hexpm
+      # $ cd /tmp/hexpm && mix setup
+
+      Mix.install(
+        [
+          {:hexpm, path: "/tmp/hexpm", env: :dev},
+        ],
+        config_path: "/tmp/hexpm/config/config.exs",
+        lockfile: "/tmp/hexpm/mix.lock"
+      )
+
+      Hexpm.Repo.query!("SELECT COUNT(1) from packages")
+      #=> ...
+
   ## Limitations
 
   There is one limitation to `Mix.install/2`, which is actually an Elixir
@@ -659,6 +682,7 @@ defmodule Mix do
       end)
 
     config = Keyword.get(opts, :config, [])
+    config_path = opts[:config_path] && Path.expand(opts[:config_path])
     system_env = Keyword.get(opts, :system_env, [])
     consolidate_protocols? = Keyword.get(opts, :consolidate_protocols, true)
 
@@ -675,18 +699,14 @@ defmodule Mix do
         Application.put_all_env(config, persistent: true)
         System.put_env(system_env)
 
-        installs_root =
-          System.get_env("MIX_INSTALL_DIR") || Path.join(Mix.Utils.mix_cache(), "installs")
-
-        version = "elixir-#{System.version()}-erts-#{:erlang.system_info(:version)}"
-        dir = Path.join([installs_root, version, id])
+        install_dir = install_dir(id)
 
         if opts[:verbose] do
-          Mix.shell().info("Mix.install/2 using #{dir}")
+          Mix.shell().info("Mix.install/2 using #{install_dir}")
         end
 
         if force? do
-          File.rm_rf!(dir)
+          File.rm_rf!(install_dir)
         end
 
         config = [
@@ -701,21 +721,51 @@ defmodule Mix do
           erlc_paths: ["src"],
           elixirc_paths: ["lib"],
           compilers: [],
-          consolidate_protocols: consolidate_protocols?
+          consolidate_protocols: consolidate_protocols?,
+          config_path: config_path
         ]
 
         started_apps = Application.started_applications()
         :ok = Mix.Local.append_archives()
         :ok = Mix.ProjectStack.push(@mix_install_project, config, "nofile")
-        build_dir = Path.join(dir, "_build")
+        build_dir = Path.join(install_dir, "_build")
+        external_lockfile = opts[:lockfile] && Path.expand(opts[:lockfile])
 
         try do
-          run_deps? = not File.dir?(build_dir)
-          File.mkdir_p!(dir)
+          first_build? = not File.dir?(build_dir)
+          File.mkdir_p!(install_dir)
+
+          File.cd!(install_dir, fn ->
+            if config_path do
+              Mix.Task.rerun("loadconfig")
+            end
+
+            cond do
+              external_lockfile ->
+                md5_path = Path.join(install_dir, "merge.lock.md5")
+
+                old_md5 =
+                  case File.read(md5_path) do
+                    {:ok, data} -> Base.decode64!(data)
+                    _ -> nil
+                  end
+
+                new_md5 = external_lockfile |> File.read!() |> :erlang.md5()
 
-          File.cd!(dir, fn ->
-            if run_deps? do
-              Mix.Task.rerun("deps.get")
+                if old_md5 != new_md5 do
+                  lockfile = Path.join(install_dir, "mix.lock")
+                  old_lock = Mix.Dep.Lock.read(lockfile)
+                  new_lock = Mix.Dep.Lock.read(external_lockfile)
+                  Mix.Dep.Lock.write(lockfile, Map.merge(old_lock, new_lock))
+                  File.write!(md5_path, Base.encode64(new_md5))
+                  Mix.Task.rerun("deps.get")
+                end
+
+              first_build? ->
+                Mix.Task.rerun("deps.get")
+
+              true ->
+                :ok
             end
 
             Mix.Task.rerun("deps.loadpaths")
@@ -725,6 +775,10 @@ defmodule Mix do
             stop_apps(Application.started_applications() -- started_apps)
 
             Mix.Task.rerun("compile")
+
+            if config_path do
+              Mix.Task.rerun("app.config")
+            end
           end)
 
           for %{app: app, opts: opts} <- Mix.Dep.cached(),
@@ -746,6 +800,15 @@ defmodule Mix do
     end
   end
 
+  defp install_dir(cache_id) do
+    install_root =
+      System.get_env("MIX_INSTALL_DIR") ||
+        Path.join(Mix.Utils.mix_cache(), "installs")
+
+    version = "elixir-#{System.version()}-erts-#{:erlang.system_info(:version)}"
+    Path.join([install_root, version, cache_id])
+  end
+
   @doc """
   Returns whether `Mix.install/2` was called in the current node.
   """

lib/mix/lib/mix/dep/lock.ex

@@ -9,9 +9,8 @@ defmodule Mix.Dep.Lock do
   Reads the lockfile, returns a map containing
   each app name and its current lock information.
   """
-  @spec read() :: map
-  def read() do
-    lockfile = lockfile()
+  @spec read(Path.t()) :: map()
+  def read(lockfile \\ lockfile()) do
     opts = [file: lockfile, warn_on_unnecessary_quotes: false]
 
     with {:ok, contents} <- File.read(lockfile),
@@ -27,15 +26,15 @@ defmodule Mix.Dep.Lock do
   @doc """
   Receives a map and writes it as the latest lock.
   """
-  @spec write(map) :: :ok
-  def write(map) do
+  @spec write(Path.t(), map()) :: :ok
+  def write(lockfile \\ lockfile(), map) do
     unless map == read() do
       lines =
         for {app, rev} <- Enum.sort(map), rev != nil do
           ~s(  "#{app}": #{inspect(rev, limit: :infinity)},\n)
         end
 
-      File.write!(lockfile(), ["%{\n", lines, "}\n"])
+      File.write!(lockfile, ["%{\n", lines, "}\n"])
       Mix.Task.run("will_recompile")
     end
 

lib/mix/test/mix/tasks/compile.elixir_test.exs

@@ -1638,10 +1638,4 @@ defmodule Mix.Tasks.Compile.ElixirTest do
       assert Mix.Tasks.Compile.Elixir.run(["--no-optional-deps"]) == {:ok, []}
     end)
   end
-
-  defp get_git_repo_revs(repo) do
-    File.cd!(fixture_path(repo), fn ->
-      Regex.split(~r/\r?\n/, System.cmd("git", ["log", "--format=%H"]) |> elem(0))
-    end)
-  end
 end

lib/mix/test/mix/tasks/deps.git_test.exs

@@ -483,10 +483,4 @@ defmodule Mix.Tasks.DepsGitTest do
     Mix.ProjectStack.post_config(post_config)
     Mix.Project.push(name, file)
   end
-
-  defp get_git_repo_revs(repo) do
-    File.cd!(fixture_path(repo), fn ->
-      Regex.split(~r/\r?\n/, System.cmd("git", ["log", "--format=%H"]) |> elem(0))
-    end)
-  end
 end

lib/mix/test/mix_test.exs

@@ -135,7 +135,7 @@ defmodule MixTest do
       refute Protocol.consolidated?(InstallTest.Protocol)
     end
 
-    test "config and system_env", %{tmp_dir: tmp_dir} do
+    test ":config and :system_env", %{tmp_dir: tmp_dir} do
       Mix.install(
         [
           {:install_test, path: Path.join(tmp_dir, "install_test")}
@@ -153,6 +153,130 @@ defmodule MixTest do
       Application.delete_env(:unknown_app, :foo, persistent: true)
     end
 
+    test ":config_path", %{tmp_dir: tmp_dir} do
+      config_path = Path.join(tmp_dir, "config.exs")
+
+      File.write!(config_path, """
+      import Config
+      config :myapp, :foo, 1
+      """)
+
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        config_path: config_path
+      )
+
+      assert Application.fetch_env!(:myapp, :foo) == 1
+    after
+      Application.delete_env(:myapp, :foo)
+    end
+
+    test ":config_path and runtime config", %{tmp_dir: tmp_dir} do
+      config_path = Path.join(tmp_dir, "config.exs")
+
+      File.write!(config_path, """
+      import Config
+      config :myapp, :foo, 1
+      """)
+
+      File.write!(Path.join(tmp_dir, "runtime.exs"), """
+      import Config
+      config :myapp, :bar, 2
+      """)
+
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        config_path: config_path
+      )
+
+      assert Application.fetch_env!(:myapp, :foo) == 1
+      assert Application.fetch_env!(:myapp, :bar) == 2
+    after
+      Application.delete_env(:myapp, :foo)
+      Application.delete_env(:myapp, :bar)
+    end
+
+    test ":config_path that does not exist" do
+      assert_raise File.Error, ~r/bad.exs": no such file or directory/, fn ->
+        Mix.install([], config_path: "bad.exs")
+      end
+    end
+
+    defmodule GitApp do
+      def project do
+        [
+          app: :git_app,
+          version: "0.1.0",
+          deps: [
+            {:git_repo, "0.1.0", [git: fixture_path("git_repo")]}
+          ]
+        ]
+      end
+    end
+
+    test ":lockfile with first build", %{tmp_dir: tmp_dir} do
+      Mix.Project.push(GitApp)
+      [_latest_rev, rev | _] = get_git_repo_revs("git_repo")
+      lockfile = Path.join(tmp_dir, "lock")
+      Mix.Dep.Lock.write(lockfile, %{git_repo: {:git, fixture_path("git_repo"), rev, []}})
+      Mix.ProjectStack.pop()
+
+      Mix.install(
+        [
+          {:git_repo, git: fixture_path("git_repo")}
+        ],
+        lockfile: lockfile,
+        verbose: true
+      )
+
+      assert_received {:mix_shell, :info, ["* Getting git_repo " <> _]}
+      assert_received {:mix_shell, :info, ["Mix.install/2 using " <> install_dir]}
+      assert File.read!(Path.join(install_dir, "mix.lock")) =~ rev
+    after
+      purge([GitRepo, GitRepo.MixProject])
+    end
+
+    test ":lockfile merging", %{tmp_dir: tmp_dir} do
+      [rev1, rev2 | _] = get_git_repo_revs("git_repo")
+
+      Mix.install(
+        [
+          {:git_repo, git: fixture_path("git_repo")}
+        ],
+        verbose: true
+      )
+
+      assert_received {:mix_shell, :info, ["* Getting git_repo " <> _]}
+      assert_received {:mix_shell, :info, ["Mix.install/2 using " <> install_dir]}
+      assert File.read!(Path.join(install_dir, "mix.lock")) =~ rev1
+
+      Mix.Project.push(GitApp)
+      lockfile = Path.join(tmp_dir, "lock")
+      Mix.Dep.Lock.write(lockfile, %{git_repo: {:git, fixture_path("git_repo"), rev2, []}})
+      Mix.ProjectStack.pop()
+
+      Mix.install(
+        [
+          {:git_repo, git: fixture_path("git_repo")}
+        ],
+        lockfile: lockfile
+      )
+
+      assert File.read!(Path.join(install_dir, "mix.lock")) =~ rev1
+    after
+      purge([GitRepo, GitRepo.MixProject])
+    end
+
+    test ":lockfile that does not exist" do
+      assert_raise File.Error, ~r/bad": no such file or directory/, fn ->
+        Mix.install([], lockfile: "bad")
+      end
+    end
+
     test "installed?", %{tmp_dir: tmp_dir} do
       refute Mix.installed?()
 

lib/mix/test/test_helper.exs

@@ -204,6 +204,12 @@ defmodule MixTest.Case do
     tmp = tmp_path() |> String.to_charlist()
     for path <- :code.get_path(), :string.str(path, tmp) != 0, do: :code.del_path(path)
   end
+
+  def get_git_repo_revs(repo) do
+    File.cd!(fixture_path(repo), fn ->
+      Regex.split(~r/\r?\n/, System.cmd("git", ["log", "--format=%H"]) |> elem(0), trim: true)
+    end)
+  end
 end
 
 ## Set up globals