Functionality to correctly handle Symbolic References

psawey · psawey · commit 6a1d0c5fc304 · 2015-07-10T09:19:21.000-05:00
returned by remote ls
diff --git a/LibGit2Sharp.Tests/NetworkFixture.cs b/LibGit2Sharp.Tests/NetworkFixture.cs
@@ -22,17 +22,19 @@ 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);
                 for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)
@@ -53,17 +55,18 @@ 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);
                 for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)
@@ -87,15 +90,18 @@ 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);
@@ -123,9 +129,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
@@ -659,7 +659,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)
@@ -674,10 +674,10 @@ 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);
             for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)
@@ -691,7 +691,7 @@ public void CanListRemoteReferences(string url)
         [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)
             {
@@ -704,11 +704,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
@@ -2127,7 +2127,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;
@@ -2142,26 +2142,54 @@ 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);
             }
 
+            while (symRefs.Count > 0)
+            {
+                var symRef = symRefs.First();
+
+                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]));
+
+                symRefs.Remove(symRef.Key);
+            }
+
+            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
@@ -568,7 +568,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);
         }
@@ -584,7 +584,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,17 +22,19 @@ public void CanListRemoteReferences(string url)`
`22`	`22`	`using (var repo = new Repository(repoPath))`
`23`	`23`	`{`
`24`	`24`	`Remote remote = 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 (var directReference in references)`
	`27`	`+`
	`28`	`+ foreach (var reference in references)`
`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 => new Tuple<string, string>(directRef.CanonicalName, directRef.TargetIdentifier)).ToList();`
	`36`	`+ Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.ResolveToDirectReference()`
	`37`	`+ .TargetIdentifier)).ToList();`
`36`	`38`
`37`	`39`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);`
`38`	`40`	`for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)`
`@@ -53,17 +55,18 @@ public void CanListRemoteReferencesFromUrl(string url)`
`53`	`55`
`54`	`56`	`using (var repo = new Repository(repoPath))`
`55`	`57`	`{`
`56`		`- IList<DirectReference> references = repo.Network.ListReferences(url).ToList();`
	`58`	`+ IList<Reference> references = repo.Network.ListReferences(url).ToList();`
`57`	`59`
`58`		`- foreach (var directReference in references)`
	`60`	`+ foreach (var reference in references)`
`59`	`61`	`{`
`60`	`62`	`// None of those references point to an existing`
`61`	`63`	`// object in this brand new repository`
`62`		`- Assert.Null(directReference.Target);`
	`64`	`+ Assert.Null(reference.ResolveToDirectReference().Target);`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`List<Tuple<string, string>> actualRefs = references.`
`66`		`- Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.TargetIdentifier)).ToList();`
	`68`	`+ Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.ResolveToDirectReference()`
	`69`	`+ .TargetIdentifier)).ToList();`
`67`	`70`
`68`	`71`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);`
`69`	`72`	`for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)`
`@@ -87,15 +90,18 @@ public void CanListRemoteReferenceObjects()`
`87`	`90`	`using (var repo = new Repository(clonedRepoPath))`
`88`	`91`	`{`
`89`	`92`	`Remote remote = repo.Network.Remotes[remoteName];`
`90`		`- IEnumerable<DirectReference> references = repo.Network.ListReferences(remote);`
	`93`	`+ IEnumerable<Reference> references = repo.Network.ListReferences(remote).ToList();`
`91`	`94`
`92`	`95`	`var actualRefs = new List<Tuple<string,string>>();`
`93`	`96`
`94`		`- foreach(DirectReference reference in references)`
	`97`	`+ foreach(Reference reference in references)`
`95`	`98`	`{`
`96`	`99`	`Assert.NotNull(reference.CanonicalName);`
`97`		`- Assert.NotNull(reference.Target);`
`98`		`- actualRefs.Add(new Tuple<string, string>(reference.CanonicalName, reference.Target.Id.Sha));`
	`100`	`+`
	`101`	`+ var directReference = reference.ResolveToDirectReference();`
	`102`	`+`
	`103`	`+ Assert.NotNull(directReference.Target);`
	`104`	`+ actualRefs.Add(new Tuple<string, string>(reference.CanonicalName, directReference.Target.Id.Sha));`
`99`	`105`	`}`
`100`	`106`
`101`	`107`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);`
`@@ -123,9 +129,9 @@ public void CanListRemoteReferencesWithCredentials()`
`123`	`129`
`124`	`130`	`var references = repo.Network.ListReferences(remote, Constants.PrivateRepoCredentials);`
`125`	`131`
`126`		`- foreach (var directReference in references)`
	`132`	`+ foreach (var reference in references)`
`127`	`133`	`{`
`128`		`- Assert.NotNull(directReference);`
	`134`	`+ Assert.NotNull(reference);`
`129`	`135`	`}`
`130`	`136`	`}`
`131`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -199,9 +199,9 @@ public void CanForcePush()`
`199`	`199`	`private static void AssertRemoteHeadTipEquals(IRepository localRepo, string sha)`
`200`	`200`	`{`
`201`	`201`	`var remoteReferences = localRepo.Network.ListReferences(localRepo.Network.Remotes.Single());`
`202`		`- DirectReference remoteHead = remoteReferences.Single(r => r.CanonicalName == "HEAD");`
	`202`	`+ Reference remoteHead = 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`	`private void UpdateTheRemoteRepositoryWithANewCommit(string remoteRepoPath)`
Original file line number	Diff line number	Diff line change
`@@ -659,7 +659,7 @@ public void CanListRemoteReferencesWithCredentials()`
`659`	`659`	`InconclusiveIf(() => string.IsNullOrEmpty(Constants.PrivateRepoUrl),`
`660`	`660`	`"Populate Constants.PrivateRepo* to run this test");`
`661`	`661`
`662`		`- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(Constants.PrivateRepoUrl,`
	`662`	`+ IEnumerable<Reference> references = Repository.ListRemoteReferences(Constants.PrivateRepoUrl,`
`663`	`663`	`Constants.PrivateRepoCredentials);`
`664`	`664`
`665`	`665`	`foreach (var reference in references)`
`@@ -674,10 +674,10 @@ public void CanListRemoteReferencesWithCredentials()`
`674`	`674`	`[InlineData("git://github.com/libgit2/TestGitRepository.git")]`
`675`	`675`	`public void CanListRemoteReferences(string url)`
`676`	`676`	`{`
`677`		`- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(url);`
	`677`	`+ IEnumerable<Reference> references = Repository.ListRemoteReferences(url).ToList();`
`678`	`678`
`679`	`679`	`List<Tuple<string, string>> actualRefs = references.`
`680`		`- Select(directRef => new Tuple<string, string>(directRef.CanonicalName, directRef.TargetIdentifier)).ToList();`
	`680`	`+ Select(reference => new Tuple<string, string>(reference.CanonicalName, reference.ResolveToDirectReference().TargetIdentifier)).ToList();`
`681`	`681`
`682`	`682`	`Assert.Equal(TestRemoteRefs.ExpectedRemoteRefs.Count, actualRefs.Count);`
`683`	`683`	`for (int i = 0; i < TestRemoteRefs.ExpectedRemoteRefs.Count; i++)`
`@@ -691,7 +691,7 @@ public void CanListRemoteReferences(string url)`
`691`	`691`	`[InlineData("http://github.com/libgit2/TestGitRepository")]`
`692`	`692`	`public void ReadingReferenceRepositoryThroughListRemoteReferencesThrows(string url)`
`693`	`693`	`{`
`694`		`- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(url);`
	`694`	`+ IEnumerable<Reference> references = Repository.ListRemoteReferences(url);`
`695`	`695`
`696`	`696`	`foreach (var reference in references)`
`697`	`697`	`{`
`@@ -704,11 +704,14 @@ public void ReadingReferenceRepositoryThroughListRemoteReferencesThrows(string u`
`704`	`704`	`[InlineData("http://github.com/libgit2/TestGitRepository")]`
`705`	`705`	`public void ReadingReferenceTargetFromListRemoteReferencesThrows(string url)`
`706`	`706`	`{`
`707`		`- IEnumerable<DirectReference> references = Repository.ListRemoteReferences(url);`
	`707`	`+ IEnumerable<Reference> references = Repository.ListRemoteReferences(url);`
`708`	`708`
`709`	`709`	`foreach (var reference in references)`
`710`	`710`	`{`
`711`		`- Assert.Throws<InvalidOperationException>(() => reference.Target);`
	`711`	`+ Assert.Throws<InvalidOperationException>(() =>`
	`712`	`+ {`
	`713`	`+ var target = reference.ResolveToDirectReference().Target;`
	`714`	`+ });`
`712`	`715`	`}`
`713`	`716`	`}`
`714`	`717`	`}`
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`		`- public virtual IEnumerable<DirectReference> ListReferences(Remote remote)`
	`51`	`+ public virtual IEnumerable<Reference> ListReferences(Remote remote)`
`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`		`- public virtual IEnumerable<DirectReference> ListReferences(Remote remote, CredentialsHandler credentialsProvider)`
	`70`	`+ public virtual IEnumerable<Reference> ListReferences(Remote remote, CredentialsHandler credentialsProvider)`
`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`		`- public virtual IEnumerable<DirectReference> ListReferences(string url)`
	`89`	`+ public virtual IEnumerable<Reference> ListReferences(string url)`
`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`		`- public virtual IEnumerable<DirectReference> ListReferences(string url, CredentialsHandler credentialsProvider)`
	`108`	`+ public virtual IEnumerable<Reference> ListReferences(string url, CredentialsHandler credentialsProvider)`
`109`	`109`	`{`
`110`	`110`	`Ensure.ArgumentNotNull(url, "url");`
`111`	`111`	`Ensure.ArgumentNotNull(credentialsProvider, "credentialsProvider");`
`112`	`112`
`113`	`113`	`return ListReferencesInternal(url, credentialsProvider);`
`114`	`114`	`}`
`115`	`115`
`116`		`- private IEnumerable<DirectReference> ListReferencesInternal(string url, CredentialsHandler credentialsProvider)`
	`116`	`+ private IEnumerable<Reference> ListReferencesInternal(string url, CredentialsHandler credentialsProvider)`
`117`	`117`	`{`
`118`	`118`	`using (RemoteSafeHandle remoteHandle = BuildRemoteSafeHandle(repository.Handle, url))`
`119`	`119`	`{`
Original file line number	Diff line number	Diff line change
`@@ -568,7 +568,7 @@ internal Commit LookupCommit(string committish)`
`568`	`568`	`/// </para>`
`569`	`569`	`/// <param name="url">The url to list from.</param>`
`570`	`570`	`/// <returns>The references in the remote repository.</returns>`
`571`		`- public static IEnumerable<DirectReference> ListRemoteReferences(string url)`
	`571`	`+ public static IEnumerable<Reference> ListRemoteReferences(string url)`
`572`	`572`	`{`
`573`	`573`	`return ListRemoteReferences(url, null);`
`574`	`574`	`}`
`@@ -584,7 +584,7 @@ public static IEnumerable<DirectReference> ListRemoteReferences(string url)`
`584`	`584`	`/// <param name="url">The url to list from.</param>`
`585`	`585`	`/// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>`
`586`	`586`	`/// <returns>The references in the remote repository.</returns>`
`587`		`- public static IEnumerable<DirectReference> ListRemoteReferences(string url, CredentialsHandler credentialsProvider)`
	`587`	`+ public static IEnumerable<Reference> ListRemoteReferences(string url, CredentialsHandler credentialsProvider)`
`588`	`588`	`{`
`589`	`589`	`Ensure.ArgumentNotNull(url, "url");`
`590`	`590`