Add Repository.Submodules

dahlbyk · dahlbyk · commit ac4a5f67d7e5 · 2013-04-08T22:09:38.000-05:00
Includes submodule support in Index.Stage() to fix #220
diff --git a/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj b/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
@@ -64,6 +64,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,117 @@
+﻿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/")] // AmbiguousSpecificationException - Do we want to support this?
+        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);
+            }
+        }
+    }
+}
diff --git a/LibGit2Sharp/Core/SubmoduleLazyGroup.cs b/LibGit2Sharp/Core/SubmoduleLazyGroup.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using LibGit2Sharp.Core.Handles;
 
 namespace LibGit2Sharp.Core
@@ -17,6 +18,13 @@ protected override void EvaluateInternal(Action<SubmoduleSafeHandle> evaluator)
         {
             using (var handle = Proxy.git_submodule_lookup(repo.Handle, name))
             {
+                if (handle == null)
+                {
+                    throw new LibGit2SharpException(string.Format(
+                        CultureInfo.InvariantCulture,
+                        "Submodule lookup failed for '{0}'.", name));
+                }
+
                 evaluator(handle);
             }
         }
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
@@ -170,7 +170,7 @@ public virtual void Stage(IEnumerable<string> paths)
                 {
                     RemoveFromIndex(relativePath);
                 }
-                else
+                else if (!repo.Submodules.TryStage(relativePath, true))
                 {
                     AddToIndex(relativePath);
                 }
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -79,6 +79,8 @@
     <Compile Include="StashOptions.cs" />
     <Compile Include="OrphanedHeadException.cs" />
     <Compile Include="StashCollection.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 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
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Globalization;`
`2`	`3`	`using LibGit2Sharp.Core.Handles;`
`3`	`4`
`4`	`5`	`namespace LibGit2Sharp.Core`
`@@ -17,6 +18,13 @@ protected override void EvaluateInternal(Action<SubmoduleSafeHandle> evaluator)`
`17`	`18`	`{`
`18`	`19`	`using (var handle = Proxy.git_submodule_lookup(repo.Handle, name))`
`19`	`20`	`{`
	`21`	`+ if (handle == null)`
	`22`	`+ {`
	`23`	`+ throw new LibGit2SharpException(string.Format(`
	`24`	`+ CultureInfo.InvariantCulture,`
	`25`	`+ "Submodule lookup failed for '{0}'.", name));`
	`26`	`+ }`
	`27`	`+`
`20`	`28`	`evaluator(handle);`
`21`	`29`	`}`
`22`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ public virtual void Stage(IEnumerable<string> paths)`
`170`	`170`	`{`
`171`	`171`	`RemoveFromIndex(relativePath);`
`172`	`172`	`}`
`173`		`- else`
	`173`	`+ else if (!repo.Submodules.TryStage(relativePath, true))`
`174`	`174`	`{`
`175`	`175`	`AddToIndex(relativePath);`
`176`	`176`	`}`