Allow git migration to and from sparse

Signed-off-by: José Valim <jose.valim@plataformatec.com.br>

Author: José Valim

lib/mix/lib/mix/dep.ex

@@ -267,7 +267,7 @@ defmodule Mix.Dep do
     do: "the dependency was built with another SCM, run \"#{mix_env_var}mix deps.compile\""
 
   defp dep_status(%Mix.Dep{app: app, requirement: req, manager: manager, opts: opts, from: from}) do
-    opts = Keyword.drop(opts, [:dest, :build, :lock, :manager])
+    opts = Keyword.drop(opts, [:dest, :build, :lock, :manager, :checkout])
     opts = opts ++ (if manager, do: [manager: manager], else: [])
     info = if req, do: {app, req, opts}, else: {app, opts}
     "\n  > In #{Path.relative_to_cwd(from)}:\n    #{inspect info}\n"

lib/mix/lib/mix/scm/git.ex

@@ -25,7 +25,11 @@ defmodule Mix.SCM.Git do
   end
 
   def accepts_options(_app, opts) do
-    opts = sparse_opts(opts)
+    opts =
+      opts
+      |> Keyword.put(:checkout, opts[:dest])
+      |> sparse_opts()
+
     cond do
       gh = opts[:github] ->
         opts
@@ -42,7 +46,7 @@ defmodule Mix.SCM.Git do
 
   def checked_out?(opts) do
     # Are we inside a Git repository?
-    git_dest(opts)
+    opts[:checkout]
     |> Path.join(".git/HEAD")
     |> File.regular?
   end
@@ -53,7 +57,7 @@ defmodule Mix.SCM.Git do
 
     cond do
       lock_rev = get_lock_rev(lock, opts) ->
-        File.cd!(git_dest(opts), fn ->
+        File.cd!(opts[:checkout], fn ->
           %{origin: origin, rev: rev} = get_rev_info()
           if get_lock_repo(lock) == origin and lock_rev == rev do
             :ok
@@ -79,129 +83,100 @@ defmodule Mix.SCM.Git do
 
   def checkout(opts) do
     assert_git!()
-
-    path     = git_dest(opts)
-    location = opts[:git]
-
-    _ = File.rm_rf!(path)
-
-    fun =
-      if opts[:sparse] do
-        sparse_check(git_version())
-        File.mkdir_p!(path)
-        fn -> init_sparse(opts) end
-      else
-        git!(~s(clone --no-checkout --progress "#{location}" "#{path}"))
-        fn -> do_checkout(opts) end
-      end
-
-    File.cd! path, fun
+    path = opts[:checkout]
+    File.rm_rf!(path)
+    File.mkdir_p!(path)
+    File.cd!(path, fn ->
+      git!("init --quiet")
+      git!("--git-dir=.git remote add origin \"#{opts[:git]}\"")
+      checkout(path, opts)
+    end)
   end
 
   def update(opts) do
     assert_git!()
+    path = opts[:checkout]
+    File.cd! path, fn -> checkout(path, opts) end
+  end
 
-    File.cd! git_dest(opts), fn ->
-      sparse_toggle(opts)
+  defp checkout(_path, opts) do
+    # Set configuration
+    sparse_toggle(opts)
+    update_origin(opts[:git])
 
-      location = opts[:git]
-      update_origin(location)
+    # Fetch external data
+    command = IO.iodata_to_binary(["--git-dir=.git fetch --force --quiet",
+                                   progress_switch(git_version()),
+                                   tags_switch(opts[:tag])])
+    git!(command)
 
-      command = IO.iodata_to_binary(["--git-dir=.git fetch --force",
-                                     progress_switch(git_version()),
-                                     tags_switch(opts[:tag])])
+    # Migrate the git repo
+    rev = get_lock_rev(opts[:lock], opts) || get_opts_rev(opts)
+    git!("--git-dir=.git checkout --quiet #{rev}")
 
-      git!(command)
-      do_checkout(opts)
+    if opts[:submodules] do
+      git!("--git-dir=.git submodule update --init --recursive")
     end
+
+    # Get the new repo lock
+    get_lock(opts)
   end
 
   defp sparse_opts(opts) do
     if opts[:sparse] do
       dest = Path.join(opts[:dest], opts[:sparse])
-      opts
-      |> Keyword.put(:git_dest, opts[:dest])
-      |> Keyword.put(:dest, dest)
+      Keyword.put(opts, :dest, dest)
     else
       opts
     end
   end
 
+  defp sparse_toggle(opts) do
+    cond do
+      sparse = opts[:sparse] ->
+        sparse_check(git_version())
+        git!("--git-dir=.git config core.sparsecheckout true")
+        File.write!(".git/info/sparse-checkout", sparse)
+      File.exists?(".git/info/sparse-checkout") ->
+        File.write!(".git/info/sparse-checkout", "*")
+        git!("--git-dir=.git read-tree -mu HEAD")
+        git!("--git-dir=.git config core.sparsecheckout false")
+        File.rm(".git/info/sparse-checkout")
+      true ->
+        :ok
+    end
+  end
+
   defp sparse_check(version) do
     unless {1, 7, 0} <= version do
-      version =
-        version
-        |> Tuple.to_list
-        |> Enum.join(".")
+      version = version |> Tuple.to_list |> Enum.join(".")
       Mix.raise "Git >= 1.7.0 is required to use sparse checkout. " <>
-                 "You are running version #{version}"
+                "You are running version #{version}"
     end
   end
 
-  defp sparse_toggle(opts) do
-    git!("config core.sparsecheckout #{opts[:sparse] != nil}")
-  end
-
-
   defp progress_switch(version) when {1, 7, 1} <= version, do: " --progress"
   defp progress_switch(_),                                 do: ""
 
   defp tags_switch(nil), do: ""
   defp tags_switch(_), do: " --tags"
 
-  defp git_dest(opts) do
-    if opts[:git_dest] do
-      opts[:git_dest]
-    else
-      opts[:dest]
-    end
-  end
-
   ## Helpers
 
   defp validate_git_options(opts) do
     err = "You should specify only one of branch, ref or tag, and only once. " <>
           "Error on Git dependency: #{opts[:git]}"
     validate_single_uniq(opts, [:branch, :ref, :tag], err)
-
-    err = "You should specify only one sparse path. " <>
-          "Error on Git dependency: #{opts[:git]}"
-    validate_single_uniq(opts, [:sparse], err)
   end
 
   defp validate_single_uniq(opts, take, error) do
     case Keyword.take(opts, take) do
-      [] -> opts
+      []  -> opts
       [_] -> opts
       _   -> Mix.raise error
     end
   end
 
-  defp init_sparse(opts) do
-    git!("init --quiet")
-    git!("remote add origin #{opts[:git]} --fetch")
-    sparse_toggle(opts)
-
-    sparse_info =
-      File.cwd!
-      |> Path.join(".git/info/sparse-checkout")
-
-    File.write(sparse_info, opts[:sparse])
-
-    do_checkout(opts)
-  end
-
-  defp do_checkout(opts) do
-    rev = get_lock_rev(opts[:lock], opts) || get_opts_rev(opts)
-    git!("--git-dir=.git checkout --quiet #{rev}")
-
-    if opts[:submodules] do
-      git!("--git-dir=.git submodule update --init --recursive")
-    end
-
-    get_lock(opts)
-  end
-
   defp get_lock(opts) do
     %{rev: rev} = get_rev_info()
     {:git, opts[:git], rev, get_lock_opts(opts)}
@@ -217,13 +192,7 @@ defmodule Mix.SCM.Git do
   defp get_lock_rev(_, _), do: nil
 
   defp get_lock_opts(opts) do
-    lock_opts = Keyword.take(opts, [:branch, :ref, :tag])
-    lock_opts =
-      if opts[:sparse] do
-        lock_opts ++ [sparse: opts[:sparse]]
-      else
-        lock_opts
-      end
+    lock_opts = Keyword.take(opts, [:branch, :ref, :tag, :sparse])
 
     if opts[:submodules] do
       lock_opts ++ [submodules: true]

lib/mix/test/fixtures/rebar_dep/rebar.config

@@ -1,7 +1,3 @@
 {sub_dirs, ["apps/*"]}.
 
-{deps, [
-    {git_rebar, "0.1..*", {git, "../../test/fixtures/git_rebar", master}}
-]}.
-
 {overrides, [{add, rebar_dep, [{src_dirs, ["apps/rebar_dep/src"]}]}]}.

lib/mix/test/fixtures/rebar_dep/rebar.config.script

@@ -1 +1 @@
-CONFIG ++ [{'SCRIPT', SCRIPT}].
+CONFIG ++ [{'SCRIPT', SCRIPT}] ++ [{deps, [{git_rebar, "0.1..*", {git, filename:absname("../../test/fixtures/git_rebar"), master}}]}].

lib/mix/test/fixtures/rebar_override/rebar.config

@@ -0,0 +1,8 @@
+[
+  {deps, [
+    {git_rebar, {git, filename:absname("../../test/fixtures/git_rebar")}}
+  ]},
+  {overrides, [
+    {override, git_rebar, [{deps, [{git_repo, {git, filename:absname("../../test/fixtures/git_repo")}}]}]}
+  ]}
+].

lib/mix/test/fixtures/rebar_override/rebar.config.script

@@ -106,7 +106,7 @@ defmodule Mix.RebarTest do
 
     assert Enum.find(deps, fn %Mix.Dep{app: app, opts: opts} ->
       if app == :git_rebar do
-        assert Enum.find(opts, &match?({:git, "../../test/fixtures/git_rebar"}, &1))
+        assert Enum.find(opts, &match?({:git, _}, &1))
         assert Enum.find(opts, &match?({:ref, "master"}, &1))
         true
       end
@@ -155,7 +155,7 @@ defmodule Mix.RebarTest do
 
     in_tmp "get and compile dependencies for Rebar", fn ->
       Mix.Tasks.Deps.Get.run []
-      assert_received {:mix_shell, :info, ["* Getting git_rebar (../../test/fixtures/git_rebar)"]}
+      assert_received {:mix_shell, :info, ["* Getting git_rebar" <> _]}
 
       Mix.Tasks.Deps.Compile.run []
       assert_received {:mix_shell, :run, ["==> git_rebar (compile)\n"]}
@@ -185,7 +185,7 @@ defmodule Mix.RebarTest do
 
     in_tmp "get and compile dependencies for rebar3", fn ->
       Mix.Tasks.Deps.Get.run []
-      assert_received {:mix_shell, :info, ["* Getting git_rebar (../../test/fixtures/git_rebar)"]}
+      assert_received {:mix_shell, :info, ["* Getting git_rebar " <> _]}
 
       Mix.Tasks.Deps.Compile.run []
       assert_received {:mix_shell, :run, ["===> Compiling git_rebar\n"]}

lib/mix/test/mix/rebar_test.exs

@@ -30,10 +30,6 @@ defmodule Mix.SCM.GitTest do
     assert_raise Mix.Error, ~r/You should specify only one of branch, ref or tag/, fn ->
       Mix.SCM.Git.accepts_options(nil, [git: "/repo", branch: "master", branch: "develop"])
     end
-
-    assert_raise Mix.Error, ~r/You should specify only one sparse path/, fn ->
-      Mix.SCM.Git.accepts_options(nil, [git: "/repo", sparse: "/a", sparse: "/b", dest: "/repo"])
-    end
   end
 
   defp lock(opts \\ []) do