Add Repository.Submodules

dahlbyk · nulltoken · commit 6cc285467af3 · 2013-04-11T19:40:10.000+02:00
Includes submodule support in Index.Stage() to fix #220
diff --git a/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj b/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
@@ -66,6 +66,7 @@
     <Compile Include="StashFixture.cs" />
     <Compile Include="CloneFixture.cs" />
     <Compile Include="ConflictFixture.cs" />
+    <Compile Include="SubmoduleFixture.cs" />
     <Compile Include="IgnoreFixture.cs" />
     <Compile Include="FetchHeadFixture.cs" />
     <Compile Include="MergeFixture.cs" />
diff --git a/LibGit2Sharp.Tests/SubmoduleFixture.cs b/LibGit2Sharp.Tests/SubmoduleFixture.cs
@@ -0,0 +1,139 @@
+﻿using System;
+using System.Linq;
+using LibGit2Sharp.Tests.TestHelpers;
+using Xunit;
+using Xunit.Extensions;
+
+namespace LibGit2Sharp.Tests
+{
+    public class SubmoduleFixture : BaseFixture
+    {
+        [Fact]
+        public void RetrievingSubmoduleForNormalDirectoryReturnsNull()
+        {
+            var path = CloneSubmoduleTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var submodule = repo.Submodules["just_a_dir"];
+                Assert.Null(submodule);
+            }
+        }
+
+        [Theory]
+        [InlineData("sm_added_and_uncommited", SubmoduleStatus.InConfig | SubmoduleStatus.InIndex | SubmoduleStatus.InWorkDir | SubmoduleStatus.IndexAdded)]
+        [InlineData("sm_changed_file", SubmoduleStatus.InConfig | SubmoduleStatus.InHead | SubmoduleStatus.InIndex | SubmoduleStatus.InWorkDir | SubmoduleStatus.WorkDirFilesModified)]
+        [InlineData("sm_changed_head", SubmoduleStatus.InConfig | SubmoduleStatus.InHead | SubmoduleStatus.InIndex | SubmoduleStatus.InWorkDir | SubmoduleStatus.WorkDirModified)]
+        [InlineData("sm_changed_index", SubmoduleStatus.InConfig | SubmoduleStatus.InHead | SubmoduleStatus.InIndex | SubmoduleStatus.InWorkDir | SubmoduleStatus.WorkDirFilesIndexDirty)]
+        [InlineData("sm_changed_untracked_file", SubmoduleStatus.InConfig | SubmoduleStatus.InHead | SubmoduleStatus.InIndex | SubmoduleStatus.InWorkDir | SubmoduleStatus.WorkDirFilesUntracked)]
+        [InlineData("sm_gitmodules_only", SubmoduleStatus.InConfig)]
+        [InlineData("sm_missing_commits", SubmoduleStatus.InConfig | SubmoduleStatus.InHead | SubmoduleStatus.InIndex | SubmoduleStatus.InWorkDir | SubmoduleStatus.WorkDirModified)]
+        [InlineData("sm_unchanged", SubmoduleStatus.InConfig | SubmoduleStatus.InHead | SubmoduleStatus.InIndex | SubmoduleStatus.InWorkDir)]
+        public void CanRetrieveTheStatusOfASubmodule(string name, SubmoduleStatus expectedStatus)
+        {
+            var path = CloneSubmoduleTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var submodule = repo.Submodules[name];
+                Assert.NotNull(submodule);
+                Assert.Equal(name, submodule.Name);
+                Assert.Equal(name, submodule.Path);
+
+                var status = submodule.RetrieveStatus();
+                Assert.Equal(expectedStatus, status);
+            }
+        }
+
+        [Theory]
+        [InlineData("sm_added_and_uncommited", null, "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0")]
+        [InlineData("sm_changed_file", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0")]
+        [InlineData("sm_changed_head", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0", "3d9386c507f6b093471a3e324085657a3c2b4247")]
+        [InlineData("sm_changed_index", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0")]
+        [InlineData("sm_changed_untracked_file", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0")]
+        [InlineData("sm_gitmodules_only", null, null, null)]
+        [InlineData("sm_missing_commits", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0", "5e4963595a9774b90524d35a807169049de8ccad")]
+        [InlineData("sm_unchanged", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0", "480095882d281ed676fe5b863569520e54a7d5c0")]
+        public void CanRetrieveTheCommitIdsOfASubmodule(string name, string headId, string indexId, string workDirId)
+        {
+            var path = CloneSubmoduleTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var submodule = repo.Submodules[name];
+                Assert.NotNull(submodule);
+                Assert.Equal(name, submodule.Name);
+
+                Assert.Equal((ObjectId)headId, submodule.HeadCommitId);
+                Assert.Equal((ObjectId)indexId, submodule.IndexCommitId);
+                Assert.Equal((ObjectId)workDirId, submodule.WorkDirCommitId);
+            }
+        }
+
+        [Fact]
+        public void CanEnumerateRepositorySubmodules()
+        {
+            var expectedSubmodules = new[]
+            {
+                "sm_added_and_uncommited",
+                "sm_changed_file",
+                "sm_changed_head",
+                "sm_changed_index",
+                "sm_changed_untracked_file",
+                "sm_gitmodules_only",
+                "sm_missing_commits",
+                "sm_unchanged",
+            };
+
+            var path = CloneSubmoduleTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var submodules = repo.Submodules.OrderBy(s => s.Name, StringComparer.Ordinal);
+
+                Assert.Equal(expectedSubmodules, submodules.Select(s => s.Name).ToArray());
+                Assert.Equal(expectedSubmodules, submodules.Select(s => s.Path).ToArray());
+                Assert.Equal(Enumerable.Repeat("../submodule_target_wd", expectedSubmodules.Length).ToArray(),
+                             submodules.Select(s => s.Url).ToArray());
+            }
+        }
+
+        [Theory]
+        [InlineData("sm_changed_head")]
+        [InlineData("sm_changed_head/")]
+        public void CanStageChangeInSubmoduleViaIndexStage(string submodulePath)
+        {
+            var path = CloneSubmoduleTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var submodule = repo.Submodules[submodulePath];
+
+                var statusBefore = submodule.RetrieveStatus();
+                Assert.Equal(SubmoduleStatus.WorkDirModified, statusBefore & SubmoduleStatus.WorkDirModified);
+
+                repo.Index.Stage(submodulePath);
+
+                var statusAfter = submodule.RetrieveStatus();
+                Assert.Equal(SubmoduleStatus.IndexModified, statusAfter & SubmoduleStatus.IndexModified);
+            }
+        }
+
+        [Theory]
+        [InlineData("sm_changed_head")]
+        [InlineData("sm_changed_head/")]
+        public void CanStageChangeInSubmoduleViaIndexStageWithOtherPaths(string submodulePath)
+        {
+            var path = CloneSubmoduleTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var submodule = repo.Submodules[submodulePath];
+
+                var statusBefore = submodule.RetrieveStatus();
+                Assert.Equal(SubmoduleStatus.WorkDirModified, statusBefore & SubmoduleStatus.WorkDirModified);
+
+                Touch(repo.Info.WorkingDirectory, "new-file.txt");
+
+                repo.Index.Stage(new[]{ "new-file.txt", submodulePath, "does-not-exist.txt" });
+
+                var statusAfter = submodule.RetrieveStatus();
+                Assert.Equal(SubmoduleStatus.IndexModified, statusAfter & SubmoduleStatus.IndexModified);
+            }
+        }
+    }
+}
diff --git a/LibGit2Sharp/Core/SubmoduleLazyGroup.cs b/LibGit2Sharp/Core/SubmoduleLazyGroup.cs
@@ -15,10 +15,11 @@ public SubmoduleLazyGroup(Repository repo, string name)
 
         protected override void EvaluateInternal(Action<SubmoduleSafeHandle> evaluator)
         {
-            using (var handle = Proxy.git_submodule_lookup(repo.Handle, name))
-            {
-                evaluator(handle);
-            }
+            repo.Submodules.Lookup(name, handle =>
+                                             {
+                                                 evaluator(handle);
+                                                 return default(object);
+                                             }, true);
         }
     }
 }
diff --git a/LibGit2Sharp/IRepository.cs b/LibGit2Sharp/IRepository.cs
@@ -66,6 +66,11 @@ public interface IRepository : IDisposable
         /// </summary>
         NoteCollection Notes { get; }
 
+        /// <summary>
+        ///   Submodules in the repository.
+        /// </summary>
+        SubmoduleCollection Submodules { get; }
+
         /// <summary>
         ///   Checkout the specified <see cref = "Branch" />.
         /// </summary>
diff --git a/LibGit2Sharp/Index.cs b/LibGit2Sharp/Index.cs
@@ -415,7 +415,10 @@ private static bool Enumerate(IEnumerator<string> leftEnum, IEnumerator<string>
 
         private void AddToIndex(string relativePath)
         {
-            Proxy.git_index_add_bypath(handle, relativePath);
+            if (!repo.Submodules.TryStage(relativePath, true))
+            {
+                Proxy.git_index_add_bypath(handle, relativePath);
+            }
         }
 
         private void RemoveFromIndex(string relativePath)
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -86,6 +86,8 @@
     <Compile Include="OrphanedHeadException.cs" />
     <Compile Include="StashCollection.cs" />
     <Compile Include="ExplicitPathsOptions.cs" />
+    <Compile Include="Submodule.cs" />
+    <Compile Include="SubmoduleCollection.cs" />
     <Compile Include="SubmoduleExtensions.cs" />
     <Compile Include="SubmoduleIgnore.cs" />
     <Compile Include="SubmoduleStatus.cs" />
diff --git a/LibGit2Sharp/Repository.cs b/LibGit2Sharp/Repository.cs
@@ -36,6 +36,7 @@ public class Repository : IRepository
         private readonly Lazy<Network> network;
         private readonly Stack<IDisposable> toCleanup = new Stack<IDisposable>();
         private readonly Ignore ignore;
+        private readonly SubmoduleCollection submodules;
         private static readonly Lazy<string> versionRetriever = new Lazy<string>(RetrieveVersion);
         private readonly Lazy<PathCase> pathCase;
 
@@ -118,6 +119,7 @@ public Repository(string path, RepositoryOptions options = null)
                 ignore = new Ignore(this);
                 network = new Lazy<Network>(() => new Network(this));
                 pathCase = new Lazy<PathCase>(() => new PathCase(this));
+                submodules = new SubmoduleCollection(this);
 
                 EagerlyLoadTheConfigIfAnyPathHaveBeenPassed(options);
             }
@@ -318,6 +320,14 @@ public NoteCollection Notes
             get { return notes; }
         }
 
+        /// <summary>
+        ///   Submodules in the repository.
+        /// </summary>
+        public SubmoduleCollection Submodules
+        {
+            get { return submodules; }
+        }
+
         #region IDisposable Members
 
         /// <summary>
diff --git a/LibGit2Sharp/Submodule.cs b/LibGit2Sharp/Submodule.cs
@@ -0,0 +1,159 @@
+﻿using System;
+using System.Diagnostics;
+using System.Globalization;
+using LibGit2Sharp.Core;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    ///   A Submodule.
+    /// </summary>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public class Submodule : IEquatable<Submodule>
+    {
+        private static readonly LambdaEqualityHelper<Submodule> equalityHelper =
+            new LambdaEqualityHelper<Submodule>(x => x.Name, x => x.HeadCommitId);
+
+        private readonly Repository repo;
+        private readonly string name;
+        private readonly string path;
+        private readonly string url;
+        private readonly ILazy<ObjectId> indexCommitId;
+        private readonly ILazy<ObjectId> headCommitId;
+        private readonly ILazy<ObjectId> workdirCommitId;
+        private readonly ILazy<bool> fetchRecurseSubmodulesRule;
+        private readonly ILazy<SubmoduleIgnore> ignoreRule;
+        private readonly ILazy<SubmoduleUpdate> updateRule;
+
+        /// <summary>
+        ///   Needed for mocking purposes.
+        /// </summary>
+        protected Submodule()
+        { }
+
+        internal Submodule(Repository repo, string name, string path, string url)
+        {
+            this.repo = repo;
+            this.name = name;
+            this.path = path;
+            this.url = url;
+
+            var commitIds = new SubmoduleLazyGroup(repo, name);
+            indexCommitId = commitIds.AddLazy(Proxy.git_submodule_index_id);
+            headCommitId = commitIds.AddLazy(Proxy.git_submodule_head_id);
+            workdirCommitId = commitIds.AddLazy(Proxy.git_submodule_wd_id);
+
+            var rules = new SubmoduleLazyGroup(repo, name);
+            fetchRecurseSubmodulesRule = rules.AddLazy(Proxy.git_submodule_fetch_recurse_submodules);
+            ignoreRule = rules.AddLazy(Proxy.git_submodule_ignore);
+            updateRule = rules.AddLazy(Proxy.git_submodule_update);
+        }
+
+        /// <summary>
+        ///   The name of the submodule.
+        /// </summary>
+        public virtual string Name { get { return name; } }
+
+        /// <summary>
+        ///   The path of the submodule.
+        /// </summary>
+        public virtual string Path { get { return path; } }
+
+        /// <summary>
+        ///   The URL of the submodule.
+        /// </summary>
+        public virtual string Url { get { return url; } }
+
+        /// <summary>
+        ///   The commit ID for this submodule in the index.
+        /// </summary>
+        public virtual ObjectId IndexCommitId { get { return indexCommitId.Value; } }
+
+        /// <summary>
+        ///   The commit ID for this submodule in the current HEAD tree.
+        /// </summary>
+        public virtual ObjectId HeadCommitId { get { return headCommitId.Value; } }
+
+        /// <summary>
+        ///   The commit ID for this submodule in the current working directory.
+        /// </summary>
+        public virtual ObjectId WorkDirCommitId { get { return workdirCommitId.Value; } }
+
+        /// <summary>
+        ///   The fetchRecurseSubmodules rule for the submodule.
+        ///
+        ///   Note that at this time, LibGit2Sharp does not honor this setting and the
+        ///   fetch functionality current ignores submodules.
+        /// </summary>
+        public virtual bool FetchRecurseSubmodulesRule { get { return fetchRecurseSubmodulesRule.Value; } }
+
+        /// <summary>
+        ///   The ignore rule of the submodule.
+        /// </summary>
+        public virtual SubmoduleIgnore IgnoreRule { get { return ignoreRule.Value; } }
+
+        /// <summary>
+        ///   The update rule of the submodule.
+        /// </summary>
+        public virtual SubmoduleUpdate UpdateRule { get { return updateRule.Value; } }
+
+        /// <summary>
+        ///   Retrieves the state of this submodule in the working directory compared to the staging area and the latest commmit.
+        /// </summary>
+        /// <returns></returns>
+        public virtual SubmoduleStatus RetrieveStatus()
+        {
+            using (var handle = Proxy.git_submodule_lookup(repo.Handle, Name))
+            {
+                return Proxy.git_submodule_status(handle);
+            }
+        }
+
+        /// <summary>
+        ///   Determines whether the specified <see cref = "Object" /> is equal to the current <see cref = "Submodule" />.
+        /// </summary>
+        /// <param name = "obj">The <see cref = "Object" /> to compare with the current <see cref = "Submodule" />.</param>
+        /// <returns>True if the specified <see cref = "Object" /> is equal to the current <see cref = "Submodule" />; otherwise, false.</returns>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as Submodule);
+        }
+
+        /// <summary>
+        ///   Determines whether the specified <see cref = "Submodule" /> is equal to the current <see cref = "Submodule" />.
+        /// </summary>
+        /// <param name = "other">The <see cref = "Submodule" /> to compare with the current <see cref = "Submodule" />.</param>
+        /// <returns>True if the specified <see cref = "Submodule" /> is equal to the current <see cref = "Submodule" />; otherwise, false.</returns>
+        public bool Equals(Submodule other)
+        {
+            return equalityHelper.Equals(this, other);
+        }
+
+        /// <summary>
+        ///   Returns the hash code for this instance.
+        /// </summary>
+        /// <returns>A 32-bit signed integer hash code.</returns>
+        public override int GetHashCode()
+        {
+            return equalityHelper.GetHashCode(this);
+        }
+
+        /// <summary>
+        ///   Returns the <see cref = "Name" />, a <see cref = "String" /> representation of the current <see cref = "Submodule" />.
+        /// </summary>
+        /// <returns>The <see cref = "Name" /> that represents the current <see cref = "Submodule" />.</returns>
+        public override string ToString()
+        {
+            return Name;
+        }
+
+        private string DebuggerDisplay
+        {
+            get
+            {
+                return string.Format(CultureInfo.InvariantCulture,
+                    "{0} => {1}", Name, Url);
+            }
+        }
+    }
+}
diff --git a/LibGit2Sharp/SubmoduleCollection.cs b/LibGit2Sharp/SubmoduleCollection.cs

Original file line number	Diff line number	Diff line change
`@@ -15,10 +15,11 @@ public SubmoduleLazyGroup(Repository repo, string name)`
`15`	`15`
`16`	`16`	`protected override void EvaluateInternal(Action<SubmoduleSafeHandle> evaluator)`
`17`	`17`	`{`
`18`		`- using (var handle = Proxy.git_submodule_lookup(repo.Handle, name))`
`19`		`- {`
`20`		`- evaluator(handle);`
`21`		`- }`
	`18`	`+ repo.Submodules.Lookup(name, handle =>`
	`19`	`+ {`
	`20`	`+ evaluator(handle);`
	`21`	`+ return default(object);`
	`22`	`+ }, true);`
`22`	`23`	`}`
`23`	`24`	`}`
`24`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -415,7 +415,10 @@ private static bool Enumerate(IEnumerator<string> leftEnum, IEnumerator<string>`
`415`	`415`
`416`	`416`	`private void AddToIndex(string relativePath)`
`417`	`417`	`{`
`418`		`- Proxy.git_index_add_bypath(handle, relativePath);`
	`418`	`+ if (!repo.Submodules.TryStage(relativePath, true))`
	`419`	`+ {`
	`420`	`+ Proxy.git_index_add_bypath(handle, relativePath);`
	`421`	`+ }`
`419`	`422`	`}`
`420`	`423`
`421`	`424`	`private void RemoveFromIndex(string relativePath)`