Fixup: Code Review - use more usings

Author: jamill

LibGit2Sharp/Core/Proxy.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading;
+using LibGit2Sharp;
 using LibGit2Sharp.Core.Handles;
 using LibGit2Sharp.Handlers;
 
@@ -1740,17 +1741,11 @@ public static GitRebaseCommitResult git_rebase_commit(
 
             GitRebaseCommitResult commitResult = new GitRebaseCommitResult();
 
-            using (ThreadAffinity())
+            using (SignatureSafeHandle committerHandle = committer.BuildHandle())
+            using (SignatureSafeHandle authorHandle = author.SafeBuildHandle())
             {
-                SignatureSafeHandle authorHandle = null;
-                SignatureSafeHandle committerHandle = null;
-
-                try
+                using (ThreadAffinity())
                 {
-                    committerHandle = committer.BuildHandle();
-                    authorHandle = author == null ?
-                        new SignatureSafeHandle() : author.BuildHandle();
-
                     int result = NativeMethods.git_rebase_commit(ref commitResult.CommitId, rebase, authorHandle, committerHandle, IntPtr.Zero, IntPtr.Zero);
 
                     if (result == (int)GitErrorCode.Applied)
@@ -1763,14 +1758,6 @@ public static GitRebaseCommitResult git_rebase_commit(
                         Ensure.ZeroResult(result);
                     }
                 }
-                finally
-                {
-                    committerHandle.Dispose();
-                    committerHandle = null;
-
-                    authorHandle.SafeDispose();
-                    authorHandle = null;
-                }
             }
 
             return commitResult;

LibGit2Sharp/Rebase.cs

@@ -85,77 +85,44 @@ public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, S
                     "A {0} operation is already in progress.", this.repository.Info.CurrentOperation));
             }
 
-            ReferenceSafeHandle branchRefPtr = null;
-            ReferenceSafeHandle upstreamRefPtr = null;
-            ReferenceSafeHandle ontoRefPtr = null;
-
-            GitAnnotatedCommitHandle annotatedBranchCommitHandle = null;
-            GitAnnotatedCommitHandle annotatedUpstreamRefPtrCommitHandle = null;
-            GitAnnotatedCommitHandle annotatedOntoRefPtrCommitHandle = null;
-
-            RebaseSafeHandle rebaseOperationHandle = null;
-
-            try
+            Func<Branch, ReferenceSafeHandle> RefHandleFromBranch = (Branch b) =>
             {
-                branchRefPtr = (branch == null) ?
-                    this.repository.Refs.RetrieveReferencePtr(this.repository.Head.CanonicalName) :
-                    this.repository.Refs.RetrieveReferencePtr(branch.CanonicalName);
-
-                upstreamRefPtr = (upstream == null) ?
-                    null : this.repository.Refs.RetrieveReferencePtr(upstream.CanonicalName);
-
-                ontoRefPtr = (onto == null) ?
-                    null : this.repository.Refs.RetrieveReferencePtr(onto.CanonicalName);
-
-                annotatedBranchCommitHandle = (branchRefPtr == null) ?
-                    new GitAnnotatedCommitHandle() :
-                    Proxy.git_annotated_commit_from_ref(this.repository.Handle, branchRefPtr);
+                return (b == null) ?
+                    null :
+                    this.repository.Refs.RetrieveReferencePtr(b.CanonicalName);
+            };
 
-                annotatedUpstreamRefPtrCommitHandle = (upstreamRefPtr == null) ?
-                    new GitAnnotatedCommitHandle() :
-                    Proxy.git_annotated_commit_from_ref(this.repository.Handle, upstreamRefPtr);
-
-                annotatedOntoRefPtrCommitHandle = (ontoRefPtr == null) ?
+            Func<ReferenceSafeHandle, GitAnnotatedCommitHandle> AnnotatedCommitHandleFromRefHandle = 
+                (ReferenceSafeHandle refHandle) =>
+            {
+                return (refHandle == null) ?
                     new GitAnnotatedCommitHandle() :
-                    Proxy.git_annotated_commit_from_ref(this.repository.Handle, ontoRefPtr);
-
-                GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
-                {
-                    version = 1,
-                };
-
-                rebaseOperationHandle = Proxy.git_rebase_init(this.repository.Handle,
-                    annotatedBranchCommitHandle,
-                    annotatedUpstreamRefPtrCommitHandle,
-                    annotatedOntoRefPtrCommitHandle,
-                    ref gitRebaseOptions);
+                    Proxy.git_annotated_commit_from_ref(this.repository.Handle, refHandle);
+            };
 
-                RebaseResult rebaseResult =
-                    RebaseOperationImpl.Run(rebaseOperationHandle,
-                                            this.repository,
-                                            committer,
-                                            options,
-                                            true);
-                return rebaseResult;
-            }
-            finally
+            GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
             {
-                branchRefPtr.SafeDispose();
-                branchRefPtr = null;
-                upstreamRefPtr.SafeDispose();
-                upstreamRefPtr = null;
-                ontoRefPtr.SafeDispose();
-                ontoRefPtr = null;
-
-                annotatedBranchCommitHandle.SafeDispose();
-                annotatedBranchCommitHandle = null;
-                annotatedUpstreamRefPtrCommitHandle.SafeDispose();
-                annotatedUpstreamRefPtrCommitHandle = null;
-                annotatedOntoRefPtrCommitHandle.SafeDispose();
-                annotatedOntoRefPtrCommitHandle = null;
-
-                rebaseOperationHandle.SafeDispose();
-                rebaseOperationHandle = null;
+                version = 1,
+            };
+
+            using (ReferenceSafeHandle branchRefPtr   = RefHandleFromBranch(branch))
+            using (ReferenceSafeHandle upstreamRefPtr = RefHandleFromBranch(upstream))
+            using (ReferenceSafeHandle ontoRefPtr     = RefHandleFromBranch(onto))
+            using (GitAnnotatedCommitHandle annotatedBranchCommitHandle      = AnnotatedCommitHandleFromRefHandle(branchRefPtr))
+            using (GitAnnotatedCommitHandle upstreamRefAnnotatedCommitHandle = AnnotatedCommitHandleFromRefHandle(upstreamRefPtr))
+            using (GitAnnotatedCommitHandle ontoRefAnnotatedCommitHandle     = AnnotatedCommitHandleFromRefHandle(ontoRefPtr))
+            using (RebaseSafeHandle rebaseOperationHandle = Proxy.git_rebase_init(this.repository.Handle,
+                                                                                  annotatedBranchCommitHandle,
+                                                                                  upstreamRefAnnotatedCommitHandle,
+                                                                                  ontoRefAnnotatedCommitHandle,
+                                                                                  ref gitRebaseOptions))
+            {
+                RebaseResult rebaseResult = RebaseOperationImpl.Run(rebaseOperationHandle,
+                                                                    this.repository,
+                                                                    committer,
+                                                                    options,
+                                                                    true);
+                return rebaseResult;
             }
         }
 
@@ -170,10 +137,8 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
 
             options = options ?? new RebaseOptions();
 
-            RebaseSafeHandle rebase = null;
-            try
+            using (RebaseSafeHandle rebase = Proxy.git_rebase_open(repository.Handle))
             {
-                rebase = Proxy.git_rebase_open(repository.Handle);
                 var rebaseCommitResult = Proxy.git_rebase_commit(rebase, null, committer);
 
                 // Report that we just completed the step
@@ -203,29 +168,17 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
                 RebaseResult rebaseResult = RebaseOperationImpl.Run(rebase, repository, committer, options, false);
                 return rebaseResult;
             }
-            finally
-            {
-                rebase.SafeDispose();
-                rebase = null;
-            }
         }
 
         /// <summary>
         /// Abort the rebase operation.
         /// </summary>
         public virtual void Abort()
         {
-            RebaseSafeHandle rebase = null;
-            try
+            using (RebaseSafeHandle rebase = Proxy.git_rebase_open(repository.Handle))
             {
-                rebase = Proxy.git_rebase_open(repository.Handle);
                 Proxy.git_rebase_abort(rebase);
             }
-            finally
-            {
-                rebase.SafeDispose();
-                rebase = null;
-            }
         }
 
         /// <summary>
@@ -246,11 +199,8 @@ public virtual RebaseStepInfo GetCurrentStepInfo()
                 return null;
             }
 
-            RebaseSafeHandle rebaseHandle = null;
-
-            try
+            using (RebaseSafeHandle rebaseHandle = Proxy.git_rebase_open(repository.Handle))
             {
-                rebaseHandle = Proxy.git_rebase_open(repository.Handle);
                 long currentStepIndex = Proxy.git_rebase_operation_current(rebaseHandle);
                 long totalStepCount = Proxy.git_rebase_operation_entrycount(rebaseHandle);
                 GitRebaseOperation gitRebasestepInfo = Proxy.git_rebase_operation_byindex(rebaseHandle, currentStepIndex);
@@ -261,11 +211,6 @@ public virtual RebaseStepInfo GetCurrentStepInfo()
                                                   totalStepCount);
                 return stepInfo;
             }
-            finally
-            {
-                rebaseHandle.SafeDispose();
-                rebaseHandle = null;
-            }
         }
     }
 }

LibGit2Sharp/RebaseOperationImpl.cs

@@ -31,12 +31,11 @@ public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,
             Ensure.ArgumentNotNull(committer, "committer");
             Ensure.ArgumentNotNull(options, "options");
 
-            GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options);
-            GitCheckoutOpts gitCheckoutOpts = checkoutOptionsWrapper.Options;
-            RebaseResult rebaseResult = null;
-
-            try
+            using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options))
             {
+                GitCheckoutOpts gitCheckoutOpts = checkoutOptionsWrapper.Options;
+                RebaseResult rebaseResult = null;
+
                 // stepBeingApplied indicates the step that will be applied by by git_rebase_next.
                 // The current step does not get incremented until git_rebase_next (except on
                 // the initial step), but we want to report the step that will be applied.
@@ -159,14 +158,9 @@ public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,
                                                     totalStepCount,
                                                     null);
                 }
-            }
-            finally
-            {
-                checkoutOptionsWrapper.SafeDispose();
-                checkoutOptionsWrapper = null;
-            }
 
-            return rebaseResult;
+                return rebaseResult;
+            }
         }
     }
 }

LibGit2Sharp/Signature.cs

@@ -147,4 +147,23 @@ public override string ToString()
             return string.Format(CultureInfo.InvariantCulture, "{0} <{1}>", Name, Email);
         }
     }
+
+    internal static class SignatureHelpers
+    {
+        /// <summary>
+        /// Build the handle for the Signature, or return a handle
+        /// to an empty signature.
+        /// </summary>
+        /// <param name="signature"></param>
+        /// <returns></returns>
+        public static SignatureSafeHandle SafeBuildHandle(this Signature signature)
+        {
+            if (signature == null)
+            {
+                return new SignatureSafeHandle();
+            }
+
+            return signature.BuildHandle();
+        }
+    }
 }