Short-circuit Committishes for simple identifiers

Author: dahlbyk

LibGit2Sharp/RepositoryExtensions.cs

@@ -365,57 +365,67 @@ private static bool AllowOrphanReference(IRepository repo, string identifier)
                    || string.Equals(identifier, repo.Head.CanonicalName, StringComparison.Ordinal);
         }
 
-        /// <summary>
-        /// Dereferences the passed identifier to a commit. If the identifier is enumerable, all items are dereferenced.
-        /// </summary>
-        /// <param name="repo">Repository to search</param>
-        /// <param name="identifier">Committish to dereference</param>
-        /// <param name="throwIfNotFound">If true, allow thrown exceptions to propagate. If false, exceptions will be swallowed and null returned.</param>
-        /// <returns>A series of commit <see cref="ObjectId"/>s which identify commit objects.</returns>
-        internal static IEnumerable<ObjectId> Committishes(this Repository repo, object identifier, bool throwIfNotFound = false)
+        private static ObjectId SingleCommittish(this Repository repo, object identifier)
         {
-            ObjectId singleReturnValue = null;
+            if (ReferenceEquals(identifier, null))
+            {
+                return null;
+            }
 
             if (identifier is string)
             {
-                singleReturnValue = DereferenceToCommit(repo, identifier as string);
+                return DereferenceToCommit(repo, (string)identifier);
             }
 
             if (identifier is ObjectId)
             {
-                singleReturnValue = DereferenceToCommit(repo, ((ObjectId) identifier).Sha);
+                return DereferenceToCommit(repo, ((ObjectId)identifier).Sha);
             }
 
             if (identifier is Commit)
             {
-                singleReturnValue = ((Commit) identifier).Id;
+                return ((Commit)identifier).Id;
             }
 
             if (identifier is TagAnnotation)
             {
-                singleReturnValue = DereferenceToCommit(repo, ((TagAnnotation) identifier).Target.Id.Sha);
+                return DereferenceToCommit(repo, ((TagAnnotation)identifier).Target.Id.Sha);
             }
 
             if (identifier is Tag)
             {
-                singleReturnValue = DereferenceToCommit(repo, ((Tag) identifier).Target.Id.Sha);
+                return DereferenceToCommit(repo, ((Tag)identifier).Target.Id.Sha);
             }
 
-            if (identifier is Branch)
+            var branch = identifier as Branch;
+            if (branch != null)
             {
-                var branch = (Branch) identifier;
                 if (branch.Tip != null || !branch.IsCurrentRepositoryHead)
                 {
                     Ensure.GitObjectIsNotNull(branch.Tip, branch.CanonicalName);
-                    singleReturnValue = branch.Tip.Id;
+                    return branch.Tip.Id;
                 }
             }
 
             if (identifier is Reference)
             {
-                singleReturnValue = DereferenceToCommit(repo, ((Reference) identifier).CanonicalName);
+                return DereferenceToCommit(repo, ((Reference)identifier).CanonicalName);
             }
 
+            return null;
+        }
+
+        /// <summary>
+        /// Dereferences the passed identifier to a commit. If the identifier is enumerable, all items are dereferenced.
+        /// </summary>
+        /// <param name="repo">Repository to search</param>
+        /// <param name="identifier">Committish to dereference</param>
+        /// <param name="throwIfNotFound">If true, allow thrown exceptions to propagate. If false, exceptions will be swallowed and null returned.</param>
+        /// <returns>A series of commit <see cref="ObjectId"/>s which identify commit objects.</returns>
+        internal static IEnumerable<ObjectId> Committishes(this Repository repo, object identifier, bool throwIfNotFound = false)
+        {
+            var singleReturnValue = repo.SingleCommittish(identifier);
+
             if (singleReturnValue != null)
             {
                 yield return singleReturnValue;