Use LazyGroup

Author: dahlbyk

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);
             }
         }

LibGit2Sharp/Submodule.cs

@@ -2,8 +2,6 @@
 using System.Diagnostics;
 using System.Globalization;
 using LibGit2Sharp.Core;
-using LibGit2Sharp.Core.Compat;
-using LibGit2Sharp.Core.Handles;
 
 namespace LibGit2Sharp
 {
@@ -16,22 +14,39 @@ public class Submodule : IEquatable<Submodule>
         private static readonly LambdaEqualityHelper<Submodule> equalityHelper =
             new LambdaEqualityHelper<Submodule>(x => x.Name, x => x.HeadCommitId);
 
-        private readonly SubmoduleSafeHandle handle;
+        private readonly Repository repo;
         private readonly string name;
-        private readonly Lazy<string> lazyPath;
+        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()
         { }
 
-        private Submodule(SubmoduleSafeHandle handle, string name)
+        internal Submodule(Repository repo, string name, string path, string url)
         {
-            this.handle = handle;
+            this.repo = repo;
             this.name = name;
-
-            lazyPath = new Lazy<string>(() => Proxy.git_submodule_path(handle));
+            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>
@@ -42,65 +57,56 @@ private Submodule(SubmoduleSafeHandle handle, string name)
         /// <summary>
         ///   The path of the submodule.
         /// </summary>
-        public virtual string Path { get { return lazyPath.Value; } }
+        public virtual string Path { get { return path; } }
 
         /// <summary>
-        ///   The commit ID for this submodule in the index.
+        ///   The URL of the submodule.
         /// </summary>
-        public virtual ObjectId IndexCommitId { get { return Proxy.git_submodule_index_id(handle); } }
+        public virtual string Url { get { return url; } }
 
         /// <summary>
-        ///   The commit ID for this submodule in the current HEAD tree.
+        ///   The commit ID for this submodule in the index.
         /// </summary>
-        public virtual ObjectId HeadCommitId { get { return Proxy.git_submodule_head_id(handle); } }
+        public virtual ObjectId IndexCommitId { get { return indexCommitId.Value; } }
 
         /// <summary>
-        ///   The commit ID for this submodule in the current working directory.
+        ///   The commit ID for this submodule in the current HEAD tree.
         /// </summary>
-        public virtual ObjectId WorkDirCommitId { get { return Proxy.git_submodule_wd_id(handle); } }
+        public virtual ObjectId HeadCommitId { get { return headCommitId.Value; } }
 
         /// <summary>
-        ///   The URL of the submodule.
+        ///   The commit ID for this submodule in the current working directory.
         /// </summary>
-        public virtual string Url
-        {
-            get { return Proxy.git_submodule_url(handle); }
-        }
+        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 Proxy.git_submodule_fetch_recurse_submodules(handle); }
-        }
+        public virtual bool FetchRecurseSubmodulesRule { get { return fetchRecurseSubmodulesRule.Value; } }
 
         /// <summary>
         ///   The ignore rule of the submodule.
         /// </summary>
-        public virtual SubmoduleIgnore IgnoreRule
-        {
-            get { return Proxy.git_submodule_ignore(handle); }
-        }
+        public virtual SubmoduleIgnore IgnoreRule { get { return ignoreRule.Value; } }
 
         /// <summary>
         ///   The update rule of the submodule.
         /// </summary>
-        public virtual SubmoduleUpdate UpdateRule
-        {
-            get { return Proxy.git_submodule_update(handle); }
-        }
+        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()
         {
-            return Proxy.git_submodule_status(handle);
+            using (var handle = Proxy.git_submodule_lookup(repo.Handle, Name))
+            {
+                return Proxy.git_submodule_status(handle);
+            }
         }
 
         /// <summary>
@@ -141,11 +147,6 @@ public override string ToString()
             return Name;
         }
 
-        internal static Submodule BuildFromPtr(SubmoduleSafeHandle handle, string name)
-        {
-            return handle == null ? null : new Submodule(handle, name);
-        }
-
         private string DebuggerDisplay
         {
             get

LibGit2Sharp/SubmoduleCollection.cs

@@ -39,7 +39,10 @@ public virtual Submodule this[string name]
             {
                 Ensure.ArgumentNotNullOrEmptyString(name, "name");
 
-                return Submodule.BuildFromPtr(repo.RegisterForCleanup(Proxy.git_submodule_lookup(repo.Handle, name)), name);
+                using (var handle = Proxy.git_submodule_lookup(repo.Handle, name))
+                {
+                    return handle == null ? null : new Submodule(repo, name, Proxy.git_submodule_path(handle), Proxy.git_submodule_url(handle));
+                }
             }
         }