Exceptions: refactor native exceptions to include code

Include the error code as a first-class citizen of exceptions that
correspond to libgit2 errors.  Previously, we would store the error
code in exception data when creating the exception from a libgit2 native
error.  However, we may also want to _generate_ these exceptions and
have them converted to a libgit2 error.  (For example, a callback may
want to return GIT_EUSER, and so throw a `UserCancelledException`.)

Therefore, provide exceptions with knowledge of their corresponding
libgit2 error code so that we can round-trip that data.

Author: ethomson

LibGit2Sharp/AmbiguousSpecificationException.cs

@@ -1,3 +1,4 @@
+using LibGit2Sharp.Core;
 using System;
 using System.Runtime.Serialization;
 
@@ -7,7 +8,7 @@ namespace LibGit2Sharp
     /// The exception that is thrown when the provided specification cannot uniquely identify a reference, an object or a path.
     /// </summary>
     [Serializable]
-    public class AmbiguousSpecificationException : LibGit2SharpException
+    public class AmbiguousSpecificationException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="AmbiguousSpecificationException"/> class.
@@ -50,5 +51,13 @@ public AmbiguousSpecificationException(string message, Exception innerException)
         protected AmbiguousSpecificationException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.Ambiguous;
+            }
+        }
     }
 }

LibGit2Sharp/BareRepositoryException.cs

@@ -9,7 +9,7 @@ namespace LibGit2Sharp
     /// working directory is performed against a bare repository.
     /// </summary>
     [Serializable]
-    public class BareRepositoryException : LibGit2SharpException
+    public class BareRepositoryException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="LibGit2Sharp.BareRepositoryException"/> class.
@@ -52,8 +52,16 @@ protected BareRepositoryException(SerializationInfo info, StreamingContext conte
             : base(info, context)
         { }
 
-        internal BareRepositoryException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal BareRepositoryException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.BareRepo;
+            }
+        }
     }
 }

LibGit2Sharp/CheckoutConflictException.cs

@@ -10,7 +10,7 @@ namespace LibGit2Sharp
     /// in the working directory.
     /// </summary>
     [Serializable]
-    public class CheckoutConflictException : LibGit2SharpException
+    public class CheckoutConflictException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="LibGit2Sharp.CheckoutConflictException"/> class.
@@ -53,8 +53,16 @@ protected CheckoutConflictException(SerializationInfo info, StreamingContext con
             : base(info, context)
         { }
 
-        internal CheckoutConflictException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal CheckoutConflictException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.Conflict;
+            }
+        }
     }
 }

LibGit2Sharp/Core/Ensure.cs

@@ -114,20 +114,20 @@ public static void ArgumentIsExpectedIntPtr(IntPtr argumentValue, IntPtr expecte
             }
         }
 
-        private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException>>
+        private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCategory, LibGit2SharpException>>
             GitErrorsToLibGit2SharpExceptions =
-                new Dictionary<GitErrorCode, Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException>>
+                new Dictionary<GitErrorCode, Func<string, GitErrorCategory, LibGit2SharpException>>
                 {
-                    { GitErrorCode.User, (m, r, c) => new UserCancelledException(m, r, c) },
-                    { GitErrorCode.BareRepo, (m, r, c) => new BareRepositoryException(m, r, c) },
-                    { GitErrorCode.Exists, (m, r, c) => new NameConflictException(m, r, c) },
-                    { GitErrorCode.InvalidSpecification, (m, r, c) => new InvalidSpecificationException(m, r, c) },
-                    { GitErrorCode.UnmergedEntries, (m, r, c) => new UnmergedIndexEntriesException(m, r, c) },
-                    { GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },
-                    { GitErrorCode.Conflict, (m, r, c) => new CheckoutConflictException(m, r, c) },
-                    { GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },
-                    { GitErrorCode.NotFound, (m, r, c) => new NotFoundException(m, r, c) },
-                    { GitErrorCode.Peel, (m, r, c) => new PeelException(m, r, c)  },
+                    { GitErrorCode.User, (m, c) => new UserCancelledException(m, c) },
+                    { GitErrorCode.BareRepo, (m, c) => new BareRepositoryException(m, c) },
+                    { GitErrorCode.Exists, (m, c) => new NameConflictException(m, c) },
+                    { GitErrorCode.InvalidSpecification, (m, c) => new InvalidSpecificationException(m, c) },
+                    { GitErrorCode.UnmergedEntries, (m, c) => new UnmergedIndexEntriesException(m, c) },
+                    { GitErrorCode.NonFastForward, (m, c) => new NonFastForwardException(m, c) },
+                    { GitErrorCode.Conflict, (m, c) => new CheckoutConflictException(m, c) },
+                    { GitErrorCode.LockedFile, (m, c) => new LockedFileException(m, c) },
+                    { GitErrorCode.NotFound, (m, c) => new NotFoundException(m, c) },
+                    { GitErrorCode.Peel, (m, c) => new PeelException(m, c) },
                 };
 
         private static unsafe void HandleError(int result)
@@ -145,13 +145,13 @@ private static unsafe void HandleError(int result)
                 errorMessage = LaxUtf8Marshaler.FromNative(error->Message);
             }
 
-            Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException> exceptionBuilder;
+            Func<string, GitErrorCategory, LibGit2SharpException> exceptionBuilder;
             if (!GitErrorsToLibGit2SharpExceptions.TryGetValue((GitErrorCode)result, out exceptionBuilder))
             {
-                exceptionBuilder = (m, r, c) => new LibGit2SharpException(m, r, c);
+                exceptionBuilder = (m, c) => new LibGit2SharpException(m, c);
             }
 
-            throw exceptionBuilder(errorMessage, (GitErrorCode)result, errorCategory);
+            throw exceptionBuilder(errorMessage, errorCategory);
         }
 
         /// <summary>

LibGit2Sharp/InvalidSpecificationException.cs

@@ -11,7 +11,7 @@ namespace LibGit2Sharp
     /// create a branch from a blob, or peeling a blob to a commit).
     /// </summary>
     [Serializable]
-    public class InvalidSpecificationException : LibGit2SharpException
+    public class InvalidSpecificationException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="InvalidSpecificationException"/> class.
@@ -54,8 +54,16 @@ protected InvalidSpecificationException(SerializationInfo info, StreamingContext
             : base(info, context)
         { }
 
-        internal InvalidSpecificationException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal InvalidSpecificationException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.InvalidSpecification;
+            }
+        }
     }
 }

LibGit2Sharp/LibGit2SharpException.cs

@@ -52,11 +52,5 @@ public LibGit2SharpException(string format, params object[] args)
         protected LibGit2SharpException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         { }
-
-        internal LibGit2SharpException(string message, GitErrorCode code, GitErrorCategory category) : this(message)
-        {
-            Data.Add("libgit2.code", (int)code);
-            Data.Add("libgit2.category", (int)category);
-        }
     }
 }

LibGit2Sharp/LockedFileException.cs

@@ -8,7 +8,7 @@ namespace LibGit2Sharp
     /// The exception that is thrown attempting to open a locked file.
     /// </summary>
     [Serializable]
-    public class LockedFileException : LibGit2SharpException
+    public class LockedFileException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="LibGit2Sharp.LockedFileException"/> class.
@@ -51,8 +51,16 @@ protected LockedFileException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         { }
 
-        internal LockedFileException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal LockedFileException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.LockedFile;
+            }
+        }
     }
 }

LibGit2Sharp/NameConflictException.cs

@@ -8,7 +8,7 @@ namespace LibGit2Sharp
     /// The exception that is thrown when a reference, a remote, a submodule... with the same name already exists in the repository
     /// </summary>
     [Serializable]
-    public class NameConflictException : LibGit2SharpException
+    public class NameConflictException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="NameConflictException"/> class.
@@ -51,8 +51,16 @@ protected NameConflictException(SerializationInfo info, StreamingContext context
             : base(info, context)
         { }
 
-        internal NameConflictException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal NameConflictException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.Exists;
+            }
+        }
     }
 }

LibGit2Sharp/NativeException.cs

@@ -0,0 +1,46 @@
+using LibGit2Sharp.Core;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// An exception thrown that corresponds to a libgit2 (native library) error.
+    /// </summary>
+    [Serializable]
+    public abstract class NativeException : LibGit2SharpException
+    {
+        /// <summary>
+        /// Needed for mocking purposes.
+        /// </summary>
+        protected NativeException()
+        { }
+
+        internal NativeException(string message)
+            : base(message)
+        { }
+
+        internal NativeException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        internal NativeException(string format, params object[] args)
+            : base(format, args)
+        {
+        }
+
+        internal NativeException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
+
+        internal NativeException(string message, GitErrorCategory category) : this(message)
+        {
+            Data.Add("libgit2.category", (int)category);
+        }
+
+        internal abstract GitErrorCode ErrorCode { get; }
+    }
+}

LibGit2Sharp/NonFastForwardException.cs

@@ -9,7 +9,7 @@ namespace LibGit2Sharp
     /// against the remote without losing commits.
     /// </summary>
     [Serializable]
-    public class NonFastForwardException : LibGit2SharpException
+    public class NonFastForwardException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="LibGit2Sharp.NonFastForwardException"/> class.
@@ -52,8 +52,16 @@ protected NonFastForwardException(SerializationInfo info, StreamingContext conte
             : base(info, context)
         { }
 
-        internal NonFastForwardException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal NonFastForwardException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.NonFastForward;
+            }
+        }
     }
 }