Clone recursively

LibGit2Sharp.Tests/CloneFixture.cs

@@ -157,5 +157,29 @@ public void CanCloneWithCredentials()
                 Assert.False(repo.Info.IsBare);
             }
         }
+
+        [Fact]
+        public void CanCloneRecursively()
+        {
+            string sourcePath = BareSubmoduleTestRepoPath;
+            var scd = BuildSelfCleaningDirectory();
+
+            Repository.Clone(sourcePath, scd.DirectoryPath, new CloneOptions()
+            {
+                Recursive = true
+            });
+
+            using (var repo = new Repository(scd.DirectoryPath))
+            {
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+            }
+
+            string clonedSubmodulePath = Path.Combine(scd.DirectoryPath, "testrepo");
+            using (var repo = new Repository(clonedSubmodulePath))
+            {
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+                Assert.True(File.Exists(Path.Combine(clonedSubmodulePath, "new.txt")));
+            }
+        }
     }
 }

LibGit2Sharp.Tests/Resources/submodules.git/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

LibGit2Sharp.Tests/Resources/submodules.git/config

@@ -0,0 +1,7 @@
+[core]
+	repositoryformatversion = 0
+	filemode = false
+	bare = true
+	symlinks = false
+	ignorecase = true
+	hideDotFiles = dotGitOnly

LibGit2Sharp.Tests/Resources/submodules.git/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.

LibGit2Sharp.Tests/Resources/submodules.git/info/exclude

@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

LibGit2Sharp.Tests/Resources/submodules.git/packed-refs

@@ -0,0 +1,2 @@
+# pack-refs with: peeled fully-peeled 
+9d4e659e2429c884eb50193880bd09613a8ddba5 refs/heads/master

LibGit2Sharp.Tests/TestHelpers/BaseFixture.cs

@@ -31,6 +31,7 @@ static BaseFixture()
         public static string MergedTestRepoWorkingDirPath { get; private set; }
         public static string MergeTestRepoWorkingDirPath { get; private set; }
         public static string SubmoduleTestRepoWorkingDirPath { get; private set; }
+        public static string BareSubmoduleTestRepoPath { get; private set; }
         public static DirectoryInfo ResourcesDirectory { get; private set; }
 
         public static bool IsFileSystemCaseSensitive { get; private set; }
@@ -64,6 +65,7 @@ private static void SetUpTestEnvironment()
             MergedTestRepoWorkingDirPath = Path.Combine(ResourcesDirectory.FullName, "mergedrepo_wd");
             MergeTestRepoWorkingDirPath = Path.Combine(ResourcesDirectory.FullName, "merge_testrepo_wd");
             SubmoduleTestRepoWorkingDirPath = Path.Combine(ResourcesDirectory.FullName, "submodule_wd");
+            BareSubmoduleTestRepoPath = Path.Combine(ResourcesDirectory.FullName, "submodules.git");
         }
 
         private static bool IsFileSystemCaseSensitiveInternal()

LibGit2Sharp/CloneOptions.cs

@@ -26,6 +26,11 @@ public CloneOptions()
         /// </summary>
         public bool Checkout { get; set; }
 
+        /// <summary>
+        /// True to init and update submodules recursively after checkout
+        /// </summary>
+        public bool Recursive { get; set; }
+
         /// <summary>
         /// Handler for network transfer and indexing progress information
         /// </summary>

LibGit2Sharp/Core/GitRepositoryInitOptions.cs

@@ -16,26 +16,23 @@ internal class GitRepositoryInitOptions : IDisposable
         public IntPtr InitialHead;
         public IntPtr OriginUrl;
 
-        public static GitRepositoryInitOptions BuildFrom(FilePath workdirPath, bool isBare)
+        public static GitRepositoryInitOptions BuildFrom(FilePath workdirPath, GitRepositoryInitFlags flags)
         {
+            flags |= GitRepositoryInitFlags.GIT_REPOSITORY_INIT_MKPATH;
+
             var opts = new GitRepositoryInitOptions
                            {
-                               Flags = GitRepositoryInitFlags.GIT_REPOSITORY_INIT_MKPATH,
+                               Flags = flags,
                                Mode = 0  /* GIT_REPOSITORY_INIT_SHARED_UMASK  */
                            };
 
             if (workdirPath != null)
             {
-                Debug.Assert(!isBare);
+                Debug.Assert((flags & GitRepositoryInitFlags.GIT_REPOSITORY_INIT_BARE) == 0);
 
                 opts.WorkDirPath = StrictFilePathMarshaler.FromManaged(workdirPath);
             }
 
-            if (isBare)
-            {
-                opts.Flags |= GitRepositoryInitFlags.GIT_REPOSITORY_INIT_BARE;
-            }
-
             return opts;
         }
 

LibGit2Sharp/Core/NativeMethods.cs

@@ -239,6 +239,14 @@ internal static extern int git_clone(
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string origin_url,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictFilePathMarshaler))] FilePath workdir_path,
             ref GitCloneOptions opts);
+
+        [DllImport(libgit2)]
+        internal static extern int git_clone_into(
+            RepositorySafeHandle repo,
+            RemoteSafeHandle remote,
+            ref GitCheckoutOpts co_opts,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string branch,
+            SignatureSafeHandle signature);
 
         [DllImport(libgit2)]
         internal static extern IntPtr git_commit_author(GitObjectSafeHandle commit);
@@ -1360,6 +1368,12 @@ internal static extern int git_submodule_reload(
         internal static extern int git_submodule_status(
             out SubmoduleStatus status,
             SubmoduleSafeHandle submodule);
+
+        [DllImport(libgit2)]
+        internal static extern int git_submodule_resolve_url(
+            GitBuf buffer,
+            RepositorySafeHandle repo,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string url);
 
         [DllImport(libgit2)]
         internal static extern int git_tag_annotation_create(

LibGit2Sharp/Core/Proxy.cs

@@ -289,6 +289,23 @@ public static RepositorySafeHandle git_clone(
             }
         }
 
+        public static RepositorySafeHandle git_clone_into(
+            RepositorySafeHandle repo,
+            RemoteSafeHandle remote,
+            GitCheckoutOpts checkoutOptions,
+            string branch,
+            Signature signature)
+        {
+            using (ThreadAffinity())
+            using (SignatureSafeHandle signatureHandle = signature.BuildHandle())
+            {
+                int res = NativeMethods.git_clone_into(repo, remote, ref checkoutOptions, 
+                    branch, signatureHandle);
+                Ensure.ZeroResult(res);
+                return repo;
+            }
+        }
+
         #endregion
 
         #region git_commit_
@@ -1987,10 +2004,10 @@ public static IndexSafeHandle git_repository_index(RepositorySafeHandle repo)
         public static RepositorySafeHandle git_repository_init_ext(
             FilePath workdirPath,
             FilePath gitdirPath,
-            bool isBare)
+            GitRepositoryInitFlags flags)
         {
             using (ThreadAffinity())
-            using (var opts = GitRepositoryInitOptions.BuildFrom(workdirPath, isBare))
+            using (var opts = GitRepositoryInitOptions.BuildFrom(workdirPath, flags))
             {
                 RepositorySafeHandle repo;
                 int res = NativeMethods.git_repository_init_ext(out repo, gitdirPath, opts);
@@ -2000,6 +2017,20 @@ public static RepositorySafeHandle git_repository_init_ext(
             }
         }
 
+        public static RepositorySafeHandle git_repository_init_ext(
+            FilePath workdirPath,
+            FilePath gitdirPath,
+            bool isBare)
+        {
+            GitRepositoryInitFlags flags = 0;
+            if (isBare)
+            {
+                flags |= GitRepositoryInitFlags.GIT_REPOSITORY_INIT_BARE;
+            }
+
+            return git_repository_init_ext(workdirPath, gitdirPath, flags);
+        }
+
         public static bool git_repository_is_bare(RepositorySafeHandle repo)
         {
             return RepositoryStateChecker(repo, NativeMethods.git_repository_is_bare);
@@ -2557,6 +2588,19 @@ public static SubmoduleStatus git_submodule_status(SubmoduleSafeHandle submodule
             }
         }
 
+        public static string git_submodule_resolve_url(RepositorySafeHandle repo, string relativeURL)
+        {
+            using (ThreadAffinity())
+            {
+                using (GitBuf buffer = new GitBuf())
+                {
+                    int result = NativeMethods.git_submodule_resolve_url(buffer, repo, relativeURL);
+                    Ensure.ZeroResult(result);
+                    return LaxUtf8Marshaler.FromNative(buffer.ptr);
+                }
+            }
+        }
+
         #endregion
 
         #region git_tag_

LibGit2Sharp/Repository.cs

@@ -578,6 +578,14 @@ public static string Clone(string sourceUrl, string workdirPath,
                 repoPath = Proxy.git_repository_path(repo);
             }
 
+            if (options.Recursive && !options.IsBare)
+            {
+                using (Repository repo = new Repository(repoPath.ToString()))
+                {
+                    repo.submodules.InitAndUpdateRecursively(options);
+                }
+            }
+
             return repoPath.Native;
         }
 

LibGit2Sharp/Submodule.cs

@@ -2,6 +2,8 @@
 using System.Diagnostics;
 using System.Globalization;
 using LibGit2Sharp.Core;
+using LibGit2Sharp.Core.Handles;
+using LibGit2Sharp.Handlers;
 
 namespace LibGit2Sharp
 {
@@ -55,10 +57,20 @@ internal Submodule(Repository repo, string name, string path, string url)
         public virtual string Name { get { return name; } }
 
         /// <summary>
-        /// The path of the submodule.
+        /// The path of the submodule relative to the workdir of the parent repository.
         /// </summary>
         public virtual string Path { get { return path; } }
 
+        /// <summary>
+        /// Gets the absolute path to the working directory of the submodule.
+        /// </summary>
+        public virtual string WorkingDirectory
+        { 
+            get { 
+                return System.IO.Path.Combine(repo.Info.WorkingDirectory, Path); 
+            } 
+        }
+
         /// <summary>
         /// The URL of the submodule.
         /// </summary>
@@ -155,5 +167,47 @@ private string DebuggerDisplay
                     "{0} => {1}", Name, Url);
             }
         }
+
+        /// <summary>
+        /// Inits this submodule
+        /// </summary>
+        /// <param name="options"></param>
+        internal void Init(CloneOptions options)
+        {
+            var remoteCallbacks = new RemoteCallbacks(null, options.OnTransferProgress, null,
+                options.Credentials);
+            GitRemoteCallbacks gitRemoteCallbacks = remoteCallbacks.GenerateCallbacks();
+
+            string gitdirPath = System.IO.Path.Combine(System.IO.Path.Combine(repo.Info.Path, "modules"), Path);
+            string remoteURL = Proxy.git_submodule_resolve_url(repo.Handle, Url);
+            string fetchRefspec = "+refs/heads/*:refs/remotes/origin/*";
+            Signature signature = repo.Config.BuildSignature(DateTimeOffset.Now);
+
+            GitCheckoutOpts opts = new GitCheckoutOpts() {
+                    version = 1,
+                    checkout_strategy = CheckoutStrategy.GIT_CHECKOUT_NONE
+            };
+
+            using (RepositorySafeHandle subrepo = Proxy.git_repository_init_ext(
+                WorkingDirectory, gitdirPath, GitRepositoryInitFlags.GIT_REPOSITORY_INIT_NO_DOTGIT_DIR))
+            using (RemoteSafeHandle remote = Proxy.git_remote_create_anonymous(subrepo, remoteURL, fetchRefspec))
+            {
+                Proxy.git_remote_set_callbacks(remote, ref gitRemoteCallbacks);
+                Proxy.git_clone_into(subrepo, remote, opts, null /* no branch */, signature);
+            }
+        }
+
+        /// <summary>
+        /// Checks out the HEAD revision
+        /// </summary>
+        internal void Update(CloneOptions options)
+        {
+            using (Repository subrepo = new Repository(WorkingDirectory))
+            {
+                subrepo.Checkout(HeadCommitId.Sha, CheckoutModifiers.None, options.OnCheckoutProgress, null);
+                // This is required because Checkout() does not actually checkout the files
+                subrepo.Reset(ResetMode.Hard);
+            }
+        }
     }
 }

LibGit2Sharp/SubmoduleCollection.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using LibGit2Sharp.Core;
 using LibGit2Sharp.Core.Handles;
+using System.IO;
 
 namespace LibGit2Sharp
 {
@@ -109,5 +110,21 @@ private string DebuggerDisplay
                                      "Count = {0}", this.Count());
             }
         }
+
+        /// <summary>
+        /// Initializes and updates all submodules, and their submodules recursively
+        /// </summary>
+        internal void InitAndUpdateRecursively(CloneOptions options)
+        {
+            foreach (Submodule module in this)
+            {
+                module.Init(options);
+                module.Update(options);
+                using (Repository subrepo = new Repository(module.WorkingDirectory))
+                {
+                    subrepo.Submodules.InitAndUpdateRecursively(options);
+                }
+            }
+        }
     }
 }