Update libgit2 binaries to 11f8336

nulltoken · nulltoken · commit 7b7042341db1 · 2013-09-25T23:19:00.000+02:00
libgit2/libgit2@32e4992...11f8336
diff --git a/Lib/NativeBinaries/amd64/git2-11f8336.dll b/Lib/NativeBinaries/amd64/git2-11f8336.dll
diff --git a/Lib/NativeBinaries/amd64/git2-11f8336.pdb b/Lib/NativeBinaries/amd64/git2-11f8336.pdb
diff --git a/Lib/NativeBinaries/amd64/git2-32e4992.dll b/Lib/NativeBinaries/amd64/git2-32e4992.dll
diff --git a/Lib/NativeBinaries/x86/git2-11f8336.dll b/Lib/NativeBinaries/x86/git2-11f8336.dll
diff --git a/Lib/NativeBinaries/x86/git2-11f8336.pdb b/Lib/NativeBinaries/x86/git2-11f8336.pdb
diff --git a/Lib/NativeBinaries/x86/git2-32e4992.dll b/Lib/NativeBinaries/x86/git2-32e4992.dll
diff --git a/LibGit2Sharp.Tests/CheckoutFixture.cs b/LibGit2Sharp.Tests/CheckoutFixture.cs
@@ -361,9 +361,9 @@ public void CheckingOutAgainstAnUnbornBranchThrows()
 
             using (var repo = new Repository(repoPath))
             {
-                Assert.True(repo.Info.IsHeadOrphaned);
+                Assert.True(repo.Info.IsHeadUnborn);
 
-                Assert.Throws<OrphanedHeadException>(() => repo.Checkout(repo.Head));
+                Assert.Throws<UnbornBranchException>(() => repo.Checkout(repo.Head));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/CommitFixture.cs b/LibGit2Sharp.Tests/CommitFixture.cs
@@ -640,7 +640,7 @@ public void CanCommitALittleBit()
                 AssertBlobContent(commit[relativeFilepath], "nulltoken\n");
 
                 Assert.Equal(0, commit.Parents.Count());
-                Assert.False(repo.Info.IsHeadOrphaned);
+                Assert.False(repo.Info.IsHeadUnborn);
 
                 // Assert a reflog entry is created on HEAD
                 Assert.Equal(1, repo.Refs.Log("HEAD").Count());
@@ -804,7 +804,7 @@ public void CanNotAmendAnEmptyRepository()
 
             using (var repo = new Repository(repoPath))
             {
-                Assert.Throws<OrphanedHeadException>(() => repo.Commit("I can not amend anything !:(", Constants.Signature, Constants.Signature, true));
+                Assert.Throws<UnbornBranchException>(() => repo.Commit("I can not amend anything !:(", Constants.Signature, Constants.Signature, true));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/RepositoryFixture.cs b/LibGit2Sharp.Tests/RepositoryFixture.cs
@@ -228,7 +228,7 @@ private static void AssertInitializedRepository(Repository repo, string expected
         {
             Assert.NotNull(repo.Info.Path);
             Assert.False(repo.Info.IsHeadDetached);
-            Assert.True(repo.Info.IsHeadOrphaned);
+            Assert.True(repo.Info.IsHeadUnborn);
 
             Reference headRef = repo.Refs.Head;
             Assert.NotNull(headRef);
@@ -541,13 +541,13 @@ public void CanDetectIfTheHeadIsOrphaned()
             {
                 string branchName = repo.Head.CanonicalName;
 
-                Assert.False(repo.Info.IsHeadOrphaned);
+                Assert.False(repo.Info.IsHeadUnborn);
 
                 repo.Refs.Add("HEAD", "refs/heads/orphan", true);
-                Assert.True(repo.Info.IsHeadOrphaned);
+                Assert.True(repo.Info.IsHeadUnborn);
 
                 repo.Refs.Add("HEAD", branchName, true);
-                Assert.False(repo.Info.IsHeadOrphaned);
+                Assert.False(repo.Info.IsHeadUnborn);
             }
         }
 
diff --git a/LibGit2Sharp.Tests/TagFixture.cs b/LibGit2Sharp.Tests/TagFixture.cs
@@ -602,7 +602,7 @@ public void CanListAllTagsInAEmptyRepository()
 
             using (var repo = new Repository(repoPath))
             {
-                Assert.True(repo.Info.IsHeadOrphaned);
+                Assert.True(repo.Info.IsHeadUnborn);
                 Assert.Equal(0, repo.Tags.Count());
             }
         }
diff --git a/LibGit2Sharp.Tests/UnstageFixture.cs b/LibGit2Sharp.Tests/UnstageFixture.cs
@@ -162,7 +162,7 @@ public void UnstagingUnknownPathsAgainstAnOrphanedHeadWithStrictUnmatchedExplici
             using (var repo = new Repository(CloneStandardTestRepo()))
             {
                 repo.Refs.UpdateTarget("HEAD", "refs/heads/orphaned");
-                Assert.True(repo.Info.IsHeadOrphaned);
+                Assert.True(repo.Info.IsHeadUnborn);
 
                 Assert.Equal(currentStatus, repo.Index.RetrieveStatus(relativePath));
 
@@ -178,7 +178,7 @@ public void CanUnstageUnknownPathsAgainstAnOrphanedHeadWithLaxUnmatchedExplicitP
             using (var repo = new Repository(CloneStandardTestRepo()))
             {
                 repo.Refs.UpdateTarget("HEAD", "refs/heads/orphaned");
-                Assert.True(repo.Info.IsHeadOrphaned);
+                Assert.True(repo.Info.IsHeadUnborn);
 
                 Assert.Equal(currentStatus, repo.Index.RetrieveStatus(relativePath));
 
diff --git a/LibGit2Sharp/Core/GitCloneOptions.cs b/LibGit2Sharp/Core/GitCloneOptions.cs
@@ -9,6 +9,7 @@ internal class GitCloneOptions
         public uint Version = 1;
 
         public GitCheckoutOpts CheckoutOpts;
+        public IntPtr InitOptions;
         public int Bare;
         public NativeMethods.git_transfer_progress_callback TransferProgressCallback;
         public IntPtr TransferProgressPayload;
diff --git a/LibGit2Sharp/Core/GitErrorCategory.cs b/LibGit2Sharp/Core/GitErrorCategory.cs
@@ -23,5 +23,9 @@ internal enum GitErrorCategory
         Thread,
         Stash,
         Checkout,
+        FetchHead,
+        Merge,
+        Ssh,
+        Filter,
     }
 }
diff --git a/LibGit2Sharp/Core/GitOdbBackendStream.cs b/LibGit2Sharp/Core/GitOdbBackendStream.cs
@@ -22,6 +22,9 @@ static GitOdbBackendStream()
         public GitOdbBackendStreamMode Mode;
         public IntPtr HashCtx;
 
+        public UIntPtr DeclaredSize;
+        public UIntPtr ReceivedBytes;
+
         public read_callback Read;
         public write_callback Write;
         public finalize_write_callback FinalizeWrite;
diff --git a/LibGit2Sharp/Core/NativeDllName.cs b/LibGit2Sharp/Core/NativeDllName.cs
@@ -2,6 +2,6 @@ namespace LibGit2Sharp.Core
 {
 	internal static class NativeDllName
 	{
-		public const string Name = "git2-32e4992";
+		public const string Name = "git2-11f8336";
 	}
 }
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -879,7 +879,7 @@ internal static extern int git_repository_fetchhead_foreach(
         internal static extern int git_repository_head_detached(RepositorySafeHandle repo);
 
         [DllImport(libgit2)]
-        internal static extern int git_repository_head_orphan(RepositorySafeHandle repo);
+        internal static extern int git_repository_head_unborn(RepositorySafeHandle repo);
 
         [DllImport(libgit2)]
         internal static extern int git_repository_index(out IndexSafeHandle index, RepositorySafeHandle repo);
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -1556,9 +1556,9 @@ public static void git_repository_free(IntPtr repo)
             NativeMethods.git_repository_free(repo);
         }
 
-        public static bool git_repository_head_orphan(RepositorySafeHandle repo)
+        public static bool git_repository_head_unborn(RepositorySafeHandle repo)
         {
-            return RepositoryStateChecker(repo, NativeMethods.git_repository_head_orphan);
+            return RepositoryStateChecker(repo, NativeMethods.git_repository_head_unborn);
         }
 
         public static IndexSafeHandle git_repository_index(RepositorySafeHandle repo)
diff --git a/LibGit2Sharp/Index.cs b/LibGit2Sharp/Index.cs
@@ -212,7 +212,7 @@ public virtual void Unstage(IEnumerable<string> paths, ExplicitPathsOptions expl
         {
             Ensure.ArgumentNotNull(paths, "paths");
 
-            if (repo.Info.IsHeadOrphaned)
+            if (repo.Info.IsHeadUnborn)
             {
                 var compareOptions = new CompareOptions { SkipPatchBuilding = true };
                 TreeChanges changes = repo.Diff.Compare(null, DiffTargets.Index, paths, explicitPathsOptions, compareOptions);
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -72,6 +72,7 @@
     <Compile Include="CommitFilter.cs" />
     <Compile Include="CommitSortStrategies.cs" />
     <Compile Include="CompareOptions.cs" />
+    <Compile Include="UnbornBranchException.cs" />
     <Compile Include="LockedFileException.cs" />
     <Compile Include="Core\GitRepositoryInitOptions.cs" />
     <Compile Include="Core\HistoryRewriter.cs" />
diff --git a/LibGit2Sharp/OrphanedHeadException.cs b/LibGit2Sharp/OrphanedHeadException.cs
@@ -8,7 +8,8 @@ namespace LibGit2Sharp
     /// branch is performed against an unborn branch.
     /// </summary>
     [Serializable]
-    public class OrphanedHeadException : LibGit2SharpException
+    [Obsolete("This type will be removed in the next release. Please use UnbornBranchException instead.")]
+    public class OrphanedHeadException : UnbornBranchException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="OrphanedHeadException"/> class.
diff --git a/LibGit2Sharp/Repository.cs b/LibGit2Sharp/Repository.cs
@@ -665,7 +665,7 @@ public Branch Checkout(Branch branch, CheckoutModifiers checkoutModifiers, Check
             // Make sure this is not an unborn branch.
             if (branch.Tip == null)
             {
-                throw new OrphanedHeadException(
+                throw new UnbornBranchException(
                     string.Format(CultureInfo.InvariantCulture,
                     "The tip of branch '{0}' is null. There's nothing to checkout.", branch.Name));
             }
@@ -865,11 +865,11 @@ public void Reset(Commit commit, IEnumerable<string> paths = null, ExplicitPaths
         /// <returns>The generated <see cref="Commit"/>.</returns>
         public Commit Commit(string message, Signature author, Signature committer, bool amendPreviousCommit = false)
         {
-            bool isHeadOrphaned = Info.IsHeadOrphaned;
+            bool isHeadOrphaned = Info.IsHeadUnborn;
 
             if (amendPreviousCommit && isHeadOrphaned)
             {
-                throw new OrphanedHeadException("Can not amend anything. The Head doesn't point at any commit.");
+                throw new UnbornBranchException("Can not amend anything. The Head doesn't point at any commit.");
             }
 
             var treeId = Proxy.git_tree_create_fromindex(Index);
@@ -925,7 +925,7 @@ private IEnumerable<Commit> RetrieveParentsOfTheCommitBeingCreated(bool amendPre
                 return Head.Tip.Parents;
             }
 
-            if (Info.IsHeadOrphaned)
+            if (Info.IsHeadUnborn)
             {
                 return Enumerable.Empty<Commit>();
             }
diff --git a/LibGit2Sharp/RepositoryInformation.cs b/LibGit2Sharp/RepositoryInformation.cs
@@ -1,4 +1,5 @@
-﻿using LibGit2Sharp.Core;
+﻿using System;
+using LibGit2Sharp.Core;
 
 namespace LibGit2Sharp
 {
@@ -62,9 +63,19 @@ public virtual bool IsHeadDetached
         /// <summary>
         /// Indicates whether the Head points to a reference which doesn't exist.
         /// </summary>
+        [Obsolete("This property will be removed in the next release. Please use IsHeadUnborn instead.")]
         public virtual bool IsHeadOrphaned
         {
-            get { return Proxy.git_repository_head_orphan(repo.Handle); }
+            get { return IsHeadUnborn; }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the Head points to a reference which doesn't exist.
+        /// </summary>
+        public virtual bool IsHeadUnborn
+        {
+            get { return Proxy.git_repository_head_unborn(repo.Handle); }
         }
 
         /// <summary>
diff --git a/LibGit2Sharp/UnbornBranchException.cs b/LibGit2Sharp/UnbornBranchException.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// The exception that is thrown when a operation requiring an existing
+    /// branch is performed against an unborn branch.
+    /// </summary>
+    [Serializable]
+    public class UnbornBranchException : LibGit2SharpException
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OrphanedHeadException"/> class.
+        /// </summary>
+        public UnbornBranchException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnbornBranchException"/> class with a specified error message.
+        /// </summary>
+        /// <param name="message">A message that describes the error.</param>
+        public UnbornBranchException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnbornBranchException"/> class with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception. If the <paramref name="innerException"/> parameter is not a null reference, the current exception is raised in a catch block that handles the inner exception.</param>
+        public UnbornBranchException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnbornBranchException"/> class with a serialized data.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo "/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        protected UnbornBranchException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}
diff --git a/LibGit2Sharp/libgit2_hash.txt b/LibGit2Sharp/libgit2_hash.txt
@@ -1 +1 @@
-32e49929725a76d9871038f30e2ea67fe0e4a4f8
+11f8336ec93ea3a270c9fe80c4bbb68aa4729423
diff --git a/libgit2 b/libgit2
@@ -1 +1 @@
-Subproject commit 32e49929725a76d9871038f30e2ea67fe0e4a4f8
+Subproject commit 11f8336ec93ea3a270c9fe80c4bbb68aa4729423

Original file line number	Diff line number	Diff line change
`@@ -361,9 +361,9 @@ public void CheckingOutAgainstAnUnbornBranchThrows()`
`361`	`361`
`362`	`362`	`using (var repo = new Repository(repoPath))`
`363`	`363`	`{`
`364`		`- Assert.True(repo.Info.IsHeadOrphaned);`
	`364`	`+ Assert.True(repo.Info.IsHeadUnborn);`
`365`	`365`
`366`		`- Assert.Throws<OrphanedHeadException>(() => repo.Checkout(repo.Head));`
	`366`	`+ Assert.Throws<UnbornBranchException>(() => repo.Checkout(repo.Head));`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`
Original file line number	Diff line number	Diff line change
`@@ -640,7 +640,7 @@ public void CanCommitALittleBit()`
`640`	`640`	`AssertBlobContent(commit[relativeFilepath], "nulltoken\n");`
`641`	`641`
`642`	`642`	`Assert.Equal(0, commit.Parents.Count());`
`643`		`- Assert.False(repo.Info.IsHeadOrphaned);`
	`643`	`+ Assert.False(repo.Info.IsHeadUnborn);`
`644`	`644`
`645`	`645`	`// Assert a reflog entry is created on HEAD`
`646`	`646`	`Assert.Equal(1, repo.Refs.Log("HEAD").Count());`
`@@ -804,7 +804,7 @@ public void CanNotAmendAnEmptyRepository()`
`804`	`804`
`805`	`805`	`using (var repo = new Repository(repoPath))`
`806`	`806`	`{`
`807`		`- Assert.Throws<OrphanedHeadException>(() => repo.Commit("I can not amend anything !:(", Constants.Signature, Constants.Signature, true));`
	`807`	`+ Assert.Throws<UnbornBranchException>(() => repo.Commit("I can not amend anything !:(", Constants.Signature, Constants.Signature, true));`
`808`	`808`	`}`
`809`	`809`	`}`
`810`	`810`
Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,7 @@ private static void AssertInitializedRepository(Repository repo, string expected`
`228`	`228`	`{`
`229`	`229`	`Assert.NotNull(repo.Info.Path);`
`230`	`230`	`Assert.False(repo.Info.IsHeadDetached);`
`231`		`- Assert.True(repo.Info.IsHeadOrphaned);`
	`231`	`+ Assert.True(repo.Info.IsHeadUnborn);`
`232`	`232`
`233`	`233`	`Reference headRef = repo.Refs.Head;`
`234`	`234`	`Assert.NotNull(headRef);`
`@@ -541,13 +541,13 @@ public void CanDetectIfTheHeadIsOrphaned()`
`541`	`541`	`{`
`542`	`542`	`string branchName = repo.Head.CanonicalName;`
`543`	`543`
`544`		`- Assert.False(repo.Info.IsHeadOrphaned);`
	`544`	`+ Assert.False(repo.Info.IsHeadUnborn);`
`545`	`545`
`546`	`546`	`repo.Refs.Add("HEAD", "refs/heads/orphan", true);`
`547`		`- Assert.True(repo.Info.IsHeadOrphaned);`
	`547`	`+ Assert.True(repo.Info.IsHeadUnborn);`
`548`	`548`
`549`	`549`	`repo.Refs.Add("HEAD", branchName, true);`
`550`		`- Assert.False(repo.Info.IsHeadOrphaned);`
	`550`	`+ Assert.False(repo.Info.IsHeadUnborn);`
`551`	`551`	`}`
`552`	`552`	`}`
`553`	`553`
Original file line number	Diff line number	Diff line change
`@@ -602,7 +602,7 @@ public void CanListAllTagsInAEmptyRepository()`
`602`	`602`
`603`	`603`	`using (var repo = new Repository(repoPath))`
`604`	`604`	`{`
`605`		`- Assert.True(repo.Info.IsHeadOrphaned);`
	`605`	`+ Assert.True(repo.Info.IsHeadUnborn);`
`606`	`606`	`Assert.Equal(0, repo.Tags.Count());`
`607`	`607`	`}`
`608`	`608`	`}`