Functionality to correctly handle Symbolic References

psawey · psawey · commit f68697b7d6a8 · 2015-07-16T19:16:58.000-05:00
returned by remote ls
diff --git a/LibGit2Sharp.Tests/NetworkFixture.cs b/LibGit2Sharp.Tests/NetworkFixture.cs
@@ -22,19 +22,22 @@ public void CanListRemoteReferences(string url)
 using (var repo = new Repository(repoPath))
{
 Remote remote = repo.Network.Remotes.Add(remoteName, url);
- IList<DirectReference> references = repo.Network.ListReferences(remote).ToList();
+ IList<Reference> references = repo.Network.ListReferences(remote).ToList();
 
- foreach (var directReference in references)
+
+ foreach (var reference in references)
{
 // None of those references point to an existing
 // object in this brand new repository
- Assert.Null(directReference.Target);
+ Assert.Null(reference.ResolveToDirectReference().Target);
 }
 
 List<Tuple<string, string>> actualRefs = references.
- Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.TargetIdentifier)).ToList();
+ Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.ResolveToDirectReference()
+ .TargetIdentifier)).ToList();
 
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);
+ Assert.True(references.Single(reference => reference.CanonicalName == "HEAD") is SymbolicReference);
 for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)
{
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item2, actualRefs[i].Item2);
@@ -53,19 +56,21 @@ public void CanListRemoteReferencesFromUrl(string url)
 
 using (var repo = new Repository(repoPath))
{
- IList<DirectReference> references = repo.Network.ListReferences(url).ToList();
+ IList<Reference> references = repo.Network.ListReferences(url).ToList();
 
- foreach (var directReference in references)
+ foreach (var reference in references)
{
 // None of those references point to an existing
 // object in this brand new repository
- Assert.Null(directReference.Target);
+ Assert.Null(reference.ResolveToDirectReference().Target);
 }
 
 List<Tuple<string, string>> actualRefs = references.
- Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.TargetIdentifier)).ToList();
+ Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.ResolveToDirectReference()
+ .TargetIdentifier)).ToList();
 
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);
+ Assert.True(references.Single(reference => reference.CanonicalName == "HEAD") is SymbolicReference);
 for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)
{
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item2, actualRefs[i].Item2);
@@ -87,18 +92,22 @@ public void CanListRemoteReferenceObjects()
 using (var repo = new Repository(clonedRepoPath))
{
 Remote remote = repo.Network.Remotes[remoteName];
- IEnumerable<DirectReference> references = repo.Network.ListReferences(remote);
+ IEnumerable<Reference> references = repo.Network.ListReferences(remote).ToList();
 
 var actualRefs = new List<Tuple<string,string>>();
 
- foreach(DirectReference reference in references)
+ foreach(Reference reference in references)
{
 Assert.NotNull(reference.CanonicalName);
- Assert.NotNull(reference.Target);
- actualRefs.Add(new Tuple<string, string>(reference.CanonicalName, reference.Target.Id.Sha));
+
+ var directReference = reference.ResolveToDirectReference();
+
+ Assert.NotNull(directReference.Target);
+ actualRefs.Add(new Tuple<string, string>(reference.CanonicalName, directReference.Target.Id.Sha));
 }
 
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);
+ Assert.True(references.Single(reference => reference.CanonicalName == "HEAD") is SymbolicReference);
 for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)
{
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item1, actualRefs[i].Item1);
@@ -123,9 +132,9 @@ public void CanListRemoteReferencesWithCredentials()
 
 var references = repo.Network.ListReferences(remote, Constants.PrivateRepoCredentials);
 
- foreach (var directReference in references)
+ foreach (var reference in references)
{
- Assert.NotNull(directReference);
+ Assert.NotNull(reference);
 }
 }
 }
diff --git a/LibGit2Sharp.Tests/PushFixture.cs b/LibGit2Sharp.Tests/PushFixture.cs
@@ -199,9 +199,9 @@ public void CanForcePush()
 private static void AssertRemoteHeadTipEquals(IRepository localRepo, string sha)
{
 var remoteReferences = localRepo.Network.ListReferences(localRepo.Network.Remotes.Single());
- DirectReference remoteHead = remoteReferences.Single(r => r.CanonicalName == "HEAD");
+ Reference remoteHead = remoteReferences.Single(r => r.CanonicalName == "HEAD");
 
- Assert.Equal(sha, remoteHead.TargetIdentifier);
+ Assert.Equal(sha, remoteHead.ResolveToDirectReference().TargetIdentifier);
 }
 
 private void UpdateTheRemoteRepositoryWithANewCommit(string remoteRepoPath)
diff --git a/LibGit2Sharp.Tests/RepositoryFixture.cs b/LibGit2Sharp.Tests/RepositoryFixture.cs
@@ -679,7 +679,7 @@ public void CanListRemoteReferencesWithCredentials()
 InconclusiveIf(() => string.IsNullOrEmpty(Constants.PrivateRepoUrl),
 "Populate Constants.PrivateRepo* to run this test");
 
- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(Constants.PrivateRepoUrl,
+ IEnumerable<Reference> references = Repository.ListRemoteReferences(Constants.PrivateRepoUrl,
 Constants.PrivateRepoCredentials);
 
 foreach (var reference in references)
@@ -694,24 +694,49 @@ public void CanListRemoteReferencesWithCredentials()
 [InlineData("git://github.com/libgit2/TestGitRepository.git")]
 public void CanListRemoteReferences(string url)
{
- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(url);
+ IEnumerable<Reference> references = Repository.ListRemoteReferences(url).ToList();
 
 List<Tuple<string, string>> actualRefs = references.
- Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.TargetIdentifier)).ToList();
+ Select(reference => new Tuple<string, string>(reference.CanonicalName, reference.ResolveToDirectReference().TargetIdentifier)).ToList();
 
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);
+ Assert.True(references.Single(reference => reference.CanonicalName == "HEAD") is SymbolicReference);
 for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)
{
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item2, actualRefs[i].Item2);
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item1, actualRefs[i].Item1);
 }
 }
 
+ [Fact]
+ public void CanListRemoteReferencesWithDetachedRemoteHead()
+{
+ string originalRepoPath = SandboxStandardTestRepo();
+
+ string detachedHeadSha;
+
+ using (var originalRepo = new Repository(originalRepoPath))
+{
+ detachedHeadSha = originalRepo.Head.Tip.Sha;
+ originalRepo.Checkout(detachedHeadSha);
+
+ Assert.True(originalRepo.Info.IsHeadDetached);
+ }
+
+ IEnumerable<Reference> references = Repository.ListRemoteReferences(originalRepoPath);
+
+ Reference head = references.SingleOrDefault(reference => reference.CanonicalName == "HEAD");
+
+ Assert.NotNull(head);
+ Assert.True(head is DirectReference);
+ Assert.Equal(detachedHeadSha, head.TargetIdentifier);
+ }
+
 [Theory]
 [InlineData("http://github.com/libgit2/TestGitRepository")]
 public void ReadingReferenceRepositoryThroughListRemoteReferencesThrows(string url)
{
- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(url);
+ IEnumerable<Reference> references = Repository.ListRemoteReferences(url);
 
 foreach (var reference in references)
{
@@ -724,11 +749,14 @@ public void ReadingReferenceRepositoryThroughListRemoteReferencesThrows(string u
 [InlineData("http://github.com/libgit2/TestGitRepository")]
 public void ReadingReferenceTargetFromListRemoteReferencesThrows(string url)
{
- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(url);
+ IEnumerable<Reference> references = Repository.ListRemoteReferences(url);
 
 foreach (var reference in references)
{
- Assert.Throws<InvalidOperationException>(() => reference.Target);
+ Assert.Throws<InvalidOperationException>(() =>
+{
+ var target = reference.ResolveToDirectReference().Target;
+ });
 }
 }
 }
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -2147,7 +2147,7 @@ public static IList<string> git_remote_list(RepositorySafeHandle repo)
 }
 }
 
- public static IEnumerable<DirectReference> git_remote_ls(Repository repository, RemoteSafeHandle remote)
+ public static IEnumerable<Reference> git_remote_ls(Repository repository, RemoteSafeHandle remote)
{
 IntPtr heads;
 UIntPtr count;
@@ -2162,26 +2162,52 @@ public static IEnumerable<DirectReference> git_remote_ls(Repository repository,
 throw new OverflowException();
 }
 
- var refs = new List<DirectReference>();
+ var directRefs = new Dictionary<string, Reference>();
+ var symRefs = new Dictionary<string, string>();
+
 IntPtr currentHead = heads;
 
 for (int i = 0; i < intCount; i++)
{
 var remoteHead = Marshal.ReadIntPtr(currentHead).MarshalAs<GitRemoteHead>();
 
+ string name = LaxUtf8Marshaler.FromNative(remoteHead.NamePtr);
+ string symRefTarget = LaxUtf8Marshaler.FromNative(remoteHead.SymRefTargetPtr);
+
 // The name pointer should never be null - if it is,
 // this indicates a bug somewhere (libgit2, server, etc).
- if (remoteHead.NamePtr == IntPtr.Zero)
+ if (string.IsNullOrEmpty(name))
{
 throw new InvalidOperationException("Not expecting null value for reference name.");
 }
 
- string name = LaxUtf8Marshaler.FromNative(remoteHead.NamePtr);
- refs.Add(new DirectReference(name, repository, remoteHead.Oid));
+ if (!string.IsNullOrEmpty(symRefTarget))
+{
+ symRefs.Add(name, symRefTarget);
+ }
+ else
+{
+ directRefs.Add(name, new DirectReference(name, repository, remoteHead.Oid));
+ }
 
 currentHead = IntPtr.Add(currentHead, IntPtr.Size);
 }
 
+ for (int i = 0; i < symRefs.Count; i++)
+{
+ var symRef = symRefs.ElementAt(i);
+
+ if (!directRefs.ContainsKey(symRef.Value))
+{
+ throw new InvalidOperationException("Symbolic reference target not found in direct reference results.");
+ }
+
+ directRefs.Add(symRef.Key, new SymbolicReference(repository, symRef.Key, symRef.Value, directRefs[symRef.Value]));
+ }
+
+ var refs = directRefs.Values.ToList();
+ refs.Sort((r1, r2) => String.CompareOrdinal(r1.CanonicalName, r2.CanonicalName));
+
 return refs;
 }
 
diff --git a/LibGit2Sharp/Network.cs b/LibGit2Sharp/Network.cs
@@ -48,7 +48,7 @@ public virtual RemoteCollection Remotes
 /// </summary>
 /// <param name="remote">The <see cref="Remote"/> to list from.</param>
 /// <returns>The references in the <see cref="Remote"/> repository.</returns>
- public virtual IEnumerable<DirectReference> ListReferences(Remote remote)
+ public virtual IEnumerable<Reference> ListReferences(Remote remote)
{
 Ensure.ArgumentNotNull(remote, "remote");
 
@@ -67,7 +67,7 @@ public virtual IEnumerable<DirectReference> ListReferences(Remote remote)
 /// <param name="remote">The <see cref="Remote"/> to list from.</param>
 /// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
 /// <returns>The references in the <see cref="Remote"/> repository.</returns>
- public virtual IEnumerable<DirectReference> ListReferences(Remote remote, CredentialsHandler credentialsProvider)
+ public virtual IEnumerable<Reference> ListReferences(Remote remote, CredentialsHandler credentialsProvider)
{
 Ensure.ArgumentNotNull(remote, "remote");
 Ensure.ArgumentNotNull(credentialsProvider, "credentialsProvider");
@@ -86,7 +86,7 @@ public virtual IEnumerable<DirectReference> ListReferences(Remote remote, Creden
 /// </summary>
 /// <param name="url">The url to list from.</param>
 /// <returns>The references in the remote repository.</returns>
- public virtual IEnumerable<DirectReference> ListReferences(string url)
+ public virtual IEnumerable<Reference> ListReferences(string url)
{
 Ensure.ArgumentNotNull(url, "url");
 
@@ -105,15 +105,15 @@ public virtual IEnumerable<DirectReference> ListReferences(string url)
 /// <param name="url">The url to list from.</param>
 /// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
 /// <returns>The references in the remote repository.</returns>
- public virtual IEnumerable<DirectReference> ListReferences(string url, CredentialsHandler credentialsProvider)
+ public virtual IEnumerable<Reference> ListReferences(string url, CredentialsHandler credentialsProvider)
{
 Ensure.ArgumentNotNull(url, "url");
 Ensure.ArgumentNotNull(credentialsProvider, "credentialsProvider");
 
 return ListReferencesInternal(url, credentialsProvider);
 }
 
- private IEnumerable<DirectReference> ListReferencesInternal(string url, CredentialsHandler credentialsProvider)
+ private IEnumerable<Reference> ListReferencesInternal(string url, CredentialsHandler credentialsProvider)
{
 using (RemoteSafeHandle remoteHandle = BuildRemoteSafeHandle(repository.Handle, url))
{
diff --git a/LibGit2Sharp/Repository.cs b/LibGit2Sharp/Repository.cs
@@ -563,7 +563,7 @@ internal Commit LookupCommit(string committish)
 /// </para>
 /// <param name="url">The url to list from.</param>
 /// <returns>The references in the remote repository.</returns>
- public static IEnumerable<DirectReference> ListRemoteReferences(string url)
+ public static IEnumerable<Reference> ListRemoteReferences(string url)
{
 return ListRemoteReferences(url, null);
 }
@@ -579,7 +579,7 @@ public static IEnumerable<DirectReference> ListRemoteReferences(string url)
 /// <param name="url">The url to list from.</param>
 /// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
 /// <returns>The references in the remote repository.</returns>
- public static IEnumerable<DirectReference> ListRemoteReferences(string url, CredentialsHandler credentialsProvider)
+ public static IEnumerable<Reference> ListRemoteReferences(string url, CredentialsHandler credentialsProvider)
{
 Ensure.ArgumentNotNull(url, "url");
 

Original file line number	Diff line number	Diff line change
`@@ -22,19 +22,22 @@ public void CanListRemoteReferences(string url)`
`22`	`22`	`using(varrepo=newRepository(repoPath))`
`23`	`23`	`{`
`24`	`24`	`Remoteremote=repo.Network.Remotes.Add(remoteName,url);`
`25`		`-IList<DirectReference>references=repo.Network.ListReferences(remote).ToList();`
	`25`	`+IList<Reference>references=repo.Network.ListReferences(remote).ToList();`
`26`	`26`
`27`		`-foreach(vardirectReferenceinreferences)`
	`27`	`+`
	`28`	`+foreach(varreferenceinreferences)`
`28`	`29`	`{`
`29`	`30`	`// None of those references point to an existing`
`30`	`31`	`// object in this brand new repository`
`31`		`-Assert.Null(directReference.Target);`
	`32`	`+Assert.Null(reference.ResolveToDirectReference().Target);`
`32`	`33`	`}`
`33`	`34`
`34`	`35`	`List<Tuple<string,string>>actualRefs=references.`
`35`		`-Select(directRef =>newTuple<string,string>(directRef.CanonicalName,directRef.TargetIdentifier)).ToList();`
	`36`	`+Select(directRef =>newTuple<string,string>(directRef.CanonicalName,directRef.ResolveToDirectReference()`
	`37`	`+.TargetIdentifier)).ToList();`
`36`	`38`
`37`	`39`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count,actualRefs.Count);`
	`40`	`+Assert.True(references.Single(reference =>reference.CanonicalName=="HEAD")isSymbolicReference);`
`38`	`41`	`for(inti=0;i<TestRemoteRefs.ExpectedRemoteRefs.Count;i++)`
`39`	`42`	`{`
`40`	`43`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item2,actualRefs[i].Item2);`
`@@ -53,19 +56,21 @@ public void CanListRemoteReferencesFromUrl(string url)`
`53`	`56`
`54`	`57`	`using(varrepo=newRepository(repoPath))`
`55`	`58`	`{`
`56`		`-IList<DirectReference>references=repo.Network.ListReferences(url).ToList();`
	`59`	`+IList<Reference>references=repo.Network.ListReferences(url).ToList();`
`57`	`60`
`58`		`-foreach(vardirectReferenceinreferences)`
	`61`	`+foreach(varreferenceinreferences)`
`59`	`62`	`{`
`60`	`63`	`// None of those references point to an existing`
`61`	`64`	`// object in this brand new repository`
`62`		`-Assert.Null(directReference.Target);`
	`65`	`+Assert.Null(reference.ResolveToDirectReference().Target);`
`63`	`66`	`}`
`64`	`67`
`65`	`68`	`List<Tuple<string,string>>actualRefs=references.`
`66`		`-Select(directRef =>newTuple<string,string>(directRef.CanonicalName,directRef.TargetIdentifier)).ToList();`
	`69`	`+Select(directRef =>newTuple<string,string>(directRef.CanonicalName,directRef.ResolveToDirectReference()`
	`70`	`+.TargetIdentifier)).ToList();`
`67`	`71`
`68`	`72`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count,actualRefs.Count);`
	`73`	`+Assert.True(references.Single(reference =>reference.CanonicalName=="HEAD")isSymbolicReference);`
`69`	`74`	`for(inti=0;i<TestRemoteRefs.ExpectedRemoteRefs.Count;i++)`
`70`	`75`	`{`
`71`	`76`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item2,actualRefs[i].Item2);`
`@@ -87,18 +92,22 @@ public void CanListRemoteReferenceObjects()`
`87`	`92`	`using(varrepo=newRepository(clonedRepoPath))`
`88`	`93`	`{`
`89`	`94`	`Remoteremote=repo.Network.Remotes[remoteName];`
`90`		`-IEnumerable<DirectReference>references=repo.Network.ListReferences(remote);`
	`95`	`+IEnumerable<Reference>references=repo.Network.ListReferences(remote).ToList();`
`91`	`96`
`92`	`97`	`varactualRefs=newList<Tuple<string,string>>();`
`93`	`98`
`94`		`-foreach(DirectReferencereferenceinreferences)`
	`99`	`+foreach(Referencereferenceinreferences)`
`95`	`100`	`{`
`96`	`101`	`Assert.NotNull(reference.CanonicalName);`
`97`		`-Assert.NotNull(reference.Target);`
`98`		`-actualRefs.Add(newTuple<string,string>(reference.CanonicalName,reference.Target.Id.Sha));`
	`102`	`+`
	`103`	`+vardirectReference=reference.ResolveToDirectReference();`
	`104`	`+`
	`105`	`+Assert.NotNull(directReference.Target);`
	`106`	`+actualRefs.Add(newTuple<string,string>(reference.CanonicalName,directReference.Target.Id.Sha));`
`99`	`107`	`}`
`100`	`108`
`101`	`109`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count,actualRefs.Count);`
	`110`	`+Assert.True(references.Single(reference =>reference.CanonicalName=="HEAD")isSymbolicReference);`
`102`	`111`	`for(inti=0;i<TestRemoteRefs.ExpectedRemoteRefs.Count;i++)`
`103`	`112`	`{`
`104`	`113`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item1,actualRefs[i].Item1);`
`@@ -123,9 +132,9 @@ public void CanListRemoteReferencesWithCredentials()`
`123`	`132`
`124`	`133`	`varreferences=repo.Network.ListReferences(remote,Constants.PrivateRepoCredentials);`
`125`	`134`
`126`		`-foreach(vardirectReferenceinreferences)`
	`135`	`+foreach(varreferenceinreferences)`
`127`	`136`	`{`
`128`		`-Assert.NotNull(directReference);`
	`137`	`+Assert.NotNull(reference);`
`129`	`138`	`}`
`130`	`139`	`}`
`131`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -199,9 +199,9 @@ public void CanForcePush()`
`199`	`199`	`privatestaticvoidAssertRemoteHeadTipEquals(IRepositorylocalRepo,stringsha)`
`200`	`200`	`{`
`201`	`201`	`varremoteReferences=localRepo.Network.ListReferences(localRepo.Network.Remotes.Single());`
`202`		`-DirectReferenceremoteHead=remoteReferences.Single(r =>r.CanonicalName=="HEAD");`
	`202`	`+ReferenceremoteHead=remoteReferences.Single(r =>r.CanonicalName=="HEAD");`
`203`	`203`
`204`		`-Assert.Equal(sha,remoteHead.TargetIdentifier);`
	`204`	`+Assert.Equal(sha,remoteHead.ResolveToDirectReference().TargetIdentifier);`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`privatevoidUpdateTheRemoteRepositoryWithANewCommit(stringremoteRepoPath)`
-Original file line number
+Diff line change
 InconclusiveIf(()=>string.IsNullOrEmpty(Constants.PrivateRepoUrl),
 "Populate Constants.PrivateRepo* to run this test");
 -IEnumerable<DirectReference>references=Repository.ListRemoteReferences(Constants.PrivateRepoUrl,
 +IEnumerable<Reference>references=Repository.ListRemoteReferences(Constants.PrivateRepoUrl,
 Constants.PrivateRepoCredentials);
 foreach(varreferenceinreferences)
 [InlineData("git://github.com/libgit2/TestGitRepository.git")]
 publicvoidCanListRemoteReferences(stringurl)
+{
 -IEnumerable<DirectReference>references=Repository.ListRemoteReferences(url);
 +IEnumerable<Reference>references=Repository.ListRemoteReferences(url).ToList();
 List<Tuple<string,string>>actualRefs=references.
 -Select(directRef=>newTuple<string,string>(directRef.CanonicalName,directRef.TargetIdentifier)).ToList();
 +Select(reference=>newTuple<string,string>(reference.CanonicalName,reference.ResolveToDirectReference().TargetIdentifier)).ToList();
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count,actualRefs.Count);
 +Assert.True(references.Single(reference =>reference.CanonicalName=="HEAD")isSymbolicReference);
 for(inti=0;i<TestRemoteRefs.ExpectedRemoteRefs.Count;i++)
+{
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item2,actualRefs[i].Item2);
 Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs[i].Item1,actualRefs[i].Item1);
+}
+}
 +[Fact]
 +publicvoidCanListRemoteReferencesWithDetachedRemoteHead()
 +{
 +stringoriginalRepoPath=SandboxStandardTestRepo();
++
 +stringdetachedHeadSha;
++
 +using(varoriginalRepo=newRepository(originalRepoPath))
 +{
 +detachedHeadSha=originalRepo.Head.Tip.Sha;
 +originalRepo.Checkout(detachedHeadSha);
++
 +Assert.True(originalRepo.Info.IsHeadDetached);
 +}
++
 +IEnumerable<Reference>references=Repository.ListRemoteReferences(originalRepoPath);
++
 +Referencehead=references.SingleOrDefault(reference =>reference.CanonicalName=="HEAD");
++
 +Assert.NotNull(head);
 +Assert.True(headisDirectReference);
 +Assert.Equal(detachedHeadSha,head.TargetIdentifier);
 +}
++
 [Theory]
 [InlineData("http://github.com/libgit2/TestGitRepository")]
 publicvoidReadingReferenceRepositoryThroughListRemoteReferencesThrows(stringurl)
+{
 -IEnumerable<DirectReference>references=Repository.ListRemoteReferences(url);
 +IEnumerable<Reference>references=Repository.ListRemoteReferences(url);
 foreach(varreferenceinreferences)
+{
 [InlineData("http://github.com/libgit2/TestGitRepository")]
 publicvoidReadingReferenceTargetFromListRemoteReferencesThrows(stringurl)
+{
 -IEnumerable<DirectReference>references=Repository.ListRemoteReferences(url);
 +IEnumerable<Reference>references=Repository.ListRemoteReferences(url);
 foreach(varreferenceinreferences)
+{
 -Assert.Throws<InvalidOperationException>(()=>reference.Target);
 +Assert.Throws<InvalidOperationException>(()=>
 +{
 +vartarget=reference.ResolveToDirectReference().Target;
 +});
+}
+}
+}
-Original file line number
+Diff line change
+}
+}
 -publicstaticIEnumerable<DirectReference>git_remote_ls(Repositoryrepository,RemoteSafeHandleremote)
 +publicstaticIEnumerable<Reference>git_remote_ls(Repositoryrepository,RemoteSafeHandleremote)
+{
 IntPtrheads;
 UIntPtrcount;
 thrownewOverflowException();
+}
 -varrefs=newList<DirectReference>();
 +vardirectRefs=newDictionary<string,Reference>();
 +varsymRefs=newDictionary<string,string>();
++
 IntPtrcurrentHead=heads;
 for(inti=0;i<intCount;i++)
+{
 varremoteHead=Marshal.ReadIntPtr(currentHead).MarshalAs<GitRemoteHead>();
 +stringname=LaxUtf8Marshaler.FromNative(remoteHead.NamePtr);
 +stringsymRefTarget=LaxUtf8Marshaler.FromNative(remoteHead.SymRefTargetPtr);
++
 // The name pointer should never be null - if it is,
 // this indicates a bug somewhere (libgit2, server, etc).
 -if(remoteHead.NamePtr==IntPtr.Zero)
 +if(string.IsNullOrEmpty(name))
+{
 thrownewInvalidOperationException("Not expecting null value for reference name.");
+}
 -stringname=LaxUtf8Marshaler.FromNative(remoteHead.NamePtr);
 -refs.Add(newDirectReference(name,repository,remoteHead.Oid));
 +if(!string.IsNullOrEmpty(symRefTarget))
 +{
 +symRefs.Add(name,symRefTarget);
 +}
 +else
 +{
 +directRefs.Add(name,newDirectReference(name,repository,remoteHead.Oid));
 +}
 currentHead=IntPtr.Add(currentHead,IntPtr.Size);
+}
 +for(inti=0;i<symRefs.Count;i++)
 +{
 +varsymRef=symRefs.ElementAt(i);
++
 +if(!directRefs.ContainsKey(symRef.Value))
 +{
 +thrownewInvalidOperationException("Symbolic reference target not found in direct reference results.");
 +}
++
 +directRefs.Add(symRef.Key,newSymbolicReference(repository,symRef.Key,symRef.Value,directRefs[symRef.Value]));
 +}
++
 +varrefs=directRefs.Values.ToList();
 +refs.Sort((r1,r2)=>String.CompareOrdinal(r1.CanonicalName,r2.CanonicalName));
++
 returnrefs;
+}
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public virtual RemoteCollection Remotes`
`48`	`48`	`/// </summary>`
`49`	`49`	`/// <param name="remote">The <see cref="Remote"/> to list from.</param>`
`50`	`50`	`/// <returns>The references in the <see cref="Remote"/> repository.</returns>`
`51`		`-publicvirtualIEnumerable<DirectReference>ListReferences(Remoteremote)`
	`51`	`+publicvirtualIEnumerable<Reference>ListReferences(Remoteremote)`
`52`	`52`	`{`
`53`	`53`	`Ensure.ArgumentNotNull(remote,"remote");`
`54`	`54`
`@@ -67,7 +67,7 @@ public virtual IEnumerable<DirectReference> ListReferences(Remote remote)`
`67`	`67`	`/// <param name="remote">The <see cref="Remote"/> to list from.</param>`
`68`	`68`	`/// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>`
`69`	`69`	`/// <returns>The references in the <see cref="Remote"/> repository.</returns>`
`70`		`-publicvirtualIEnumerable<DirectReference>ListReferences(Remoteremote,CredentialsHandlercredentialsProvider)`
	`70`	`+publicvirtualIEnumerable<Reference>ListReferences(Remoteremote,CredentialsHandlercredentialsProvider)`
`71`	`71`	`{`
`72`	`72`	`Ensure.ArgumentNotNull(remote,"remote");`
`73`	`73`	`Ensure.ArgumentNotNull(credentialsProvider,"credentialsProvider");`
`@@ -86,7 +86,7 @@ public virtual IEnumerable<DirectReference> ListReferences(Remote remote, Creden`
`86`	`86`	`/// </summary>`
`87`	`87`	`/// <param name="url">The url to list from.</param>`
`88`	`88`	`/// <returns>The references in the remote repository.</returns>`
`89`		`-publicvirtualIEnumerable<DirectReference>ListReferences(stringurl)`
	`89`	`+publicvirtualIEnumerable<Reference>ListReferences(stringurl)`
`90`	`90`	`{`
`91`	`91`	`Ensure.ArgumentNotNull(url,"url");`
`92`	`92`
`@@ -105,15 +105,15 @@ public virtual IEnumerable<DirectReference> ListReferences(string url)`
`105`	`105`	`/// <param name="url">The url to list from.</param>`
`106`	`106`	`/// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>`
`107`	`107`	`/// <returns>The references in the remote repository.</returns>`
`108`		`-publicvirtualIEnumerable<DirectReference>ListReferences(stringurl,CredentialsHandlercredentialsProvider)`
	`108`	`+publicvirtualIEnumerable<Reference>ListReferences(stringurl,CredentialsHandlercredentialsProvider)`
`109`	`109`	`{`
`110`	`110`	`Ensure.ArgumentNotNull(url,"url");`
`111`	`111`	`Ensure.ArgumentNotNull(credentialsProvider,"credentialsProvider");`
`112`	`112`
`113`	`113`	`returnListReferencesInternal(url,credentialsProvider);`
`114`	`114`	`}`
`115`	`115`
`116`		`-privateIEnumerable<DirectReference>ListReferencesInternal(stringurl,CredentialsHandlercredentialsProvider)`
	`116`	`+privateIEnumerable<Reference>ListReferencesInternal(stringurl,CredentialsHandlercredentialsProvider)`
`117`	`117`	`{`
`118`	`118`	`using(RemoteSafeHandleremoteHandle=BuildRemoteSafeHandle(repository.Handle,url))`
`119`	`119`	`{`
Original file line number	Diff line number	Diff line change
`@@ -563,7 +563,7 @@ internal Commit LookupCommit(string committish)`
`563`	`563`	`/// </para>`
`564`	`564`	`/// <param name="url">The url to list from.</param>`
`565`	`565`	`/// <returns>The references in the remote repository.</returns>`
`566`		`-publicstaticIEnumerable<DirectReference>ListRemoteReferences(stringurl)`
	`566`	`+publicstaticIEnumerable<Reference>ListRemoteReferences(stringurl)`
`567`	`567`	`{`
`568`	`568`	`returnListRemoteReferences(url,null);`
`569`	`569`	`}`
`@@ -579,7 +579,7 @@ public static IEnumerable<DirectReference> ListRemoteReferences(string url)`
`579`	`579`	`/// <param name="url">The url to list from.</param>`
`580`	`580`	`/// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>`
`581`	`581`	`/// <returns>The references in the remote repository.</returns>`
`582`		`-publicstaticIEnumerable<DirectReference>ListRemoteReferences(stringurl,CredentialsHandlercredentialsProvider)`
	`582`	`+publicstaticIEnumerable<Reference>ListRemoteReferences(stringurl,CredentialsHandlercredentialsProvider)`
`583`	`583`	`{`
`584`	`584`	`Ensure.ArgumentNotNull(url,"url");`
`585`	`585`