move methods from RepositoryExtensions

arturcic · arturcic · commit c23179e956d8 · 2021-01-07T15:22:46.000+01:00
diff --git a/src/GitVersionCore.Tests/Core/RepositoryExtensionsTests.cs b/src/GitVersionCore.Tests/Core/RepositoryExtensionsTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using GitVersion;
 using GitVersion.Extensions;
 using GitVersion.Logging;
@@ -13,14 +14,65 @@ namespace GitVersionCore.Tests
     [TestFixture]
     public class RepositoryExtensionsTests : TestBase
     {
+        private static void EnsureLocalBranchExistsForCurrentBranch(IGitRepository repo, ILog log, Remote remote, string currentBranch)
+        {
+            if (log is null)
+            {
+                throw new ArgumentNullException(nameof(log));
+            }
+
+            if (remote is null)
+            {
+                throw new ArgumentNullException(nameof(remote));
+            }
+
+            if (string.IsNullOrEmpty(currentBranch)) return;
+
+            var isRef = currentBranch.Contains("refs");
+            var isBranch = currentBranch.Contains("refs/heads");
+            var localCanonicalName = !isRef
+                ? "refs/heads/" + currentBranch
+                : isBranch
+                    ? currentBranch
+                    : currentBranch.Replace("refs/", "refs/heads/");
+
+            var repoTip = repo.Head.Tip;
+
+            // We currently have the rep.Head of the *default* branch, now we need to look up the right one
+            var originCanonicalName = $"{remote.Name}/{currentBranch}";
+            var originBranch = repo.Branches[originCanonicalName];
+            if (originBranch != null)
+            {
+                repoTip = originBranch.Tip;
+            }
+
+            var repoTipId = repoTip.Id;
+
+            if (repo.Branches.All(b => !b.CanonicalName.IsEquivalentTo(localCanonicalName)))
+            {
+                log.Info(isBranch ? $"Creating local branch {localCanonicalName}"
+                    : $"Creating local branch {localCanonicalName} pointing at {repoTipId}");
+                repo.Refs.Add(localCanonicalName, repoTipId);
+            }
+            else
+            {
+                log.Info(isBranch ? $"Updating local branch {localCanonicalName} to point at {repoTip.Sha}"
+                    : $"Updating local branch {localCanonicalName} to match ref {currentBranch}");
+                var localRef = repo.Refs[localCanonicalName];
+                repo.Refs.UpdateTarget(localRef, repoTipId);
+            }
+
+            repo.Commands.Checkout(localCanonicalName);
+        }
+
         [Test]
         public void EnsureLocalBranchExistsForCurrentBranch_CaseInsensitivelyMatchesBranches()
         {
             var log = Substitute.For<ILog>();
             var repository = MockRepository();
             var remote = MockRemote(repository);
 
-            repository.EnsureLocalBranchExistsForCurrentBranch(log, remote, "refs/heads/featurE/feat-test");
+            EnsureLocalBranchExistsForCurrentBranch(repository, log, remote, "refs/heads/featurE/feat-test");
         }
 
         private IGitRepository MockRepository()
diff --git a/src/GitVersionCore.Tests/Extensions/GitToolsTestingExtensions.cs b/src/GitVersionCore.Tests/Extensions/GitToolsTestingExtensions.cs
@@ -31,10 +31,7 @@ public static void DumpGraph(this IRepository repository, Action<string> writer
 
         public static VersionVariables GetVersion(this RepositoryFixtureBase fixture, Config configuration = null, IRepository repository = null, string commitId = null, bool onlyTrackedBranches = true, string branch = null)
         {
-            if (configuration == null)
-            {
-                configuration = new ConfigurationBuilder().Build();
-            }
+            configuration ??= new ConfigurationBuilder().Build();
 
             repository ??= fixture.Repository;
 
diff --git a/src/GitVersionCore/Core/GitPreparer.cs b/src/GitVersionCore/Core/GitPreparer.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using GitVersion.Extensions;
@@ -208,9 +209,9 @@ private void NormalizeGitDirectory(string gitDirectory, bool noFetch, string cur
 
             try
             {
-                var remote = repository.EnsureOnlyOneRemoteIsDefined(log);
+                var remote = EnsureOnlyOneRemoteIsDefined(repository, log);
 
-                repository.AddMissingRefSpecs(log, remote);
+                AddMissingRefSpecs(repository, log, remote);
 
                 //If noFetch is enabled, then GitVersion will assume that the git repository is normalized before execution, so that fetching from remotes is not required.
                 if (noFetch)
@@ -223,8 +224,8 @@ private void NormalizeGitDirectory(string gitDirectory, bool noFetch, string cur
                     repository.Commands.Fetch(remote.Name, new string[0], authentication.ToFetchOptions(), null);
                 }
 
-                repository.EnsureLocalBranchExistsForCurrentBranch(log, remote, currentBranch);
-                repository.CreateOrUpdateLocalBranchesFromRemoteTrackingOnes(log, remote.Name);
+                EnsureLocalBranchExistsForCurrentBranch(repository, log, remote, currentBranch);
+                CreateOrUpdateLocalBranchesFromRemoteTrackingOnes(repository, log, remote.Name);
 
                 // Bug fix for https://github.com/GitTools/GitVersion/issues/1754, head maybe have been changed
                 // if this is a dynamic repository. But only allow this in case the branches are different (branch switch)
@@ -294,7 +295,7 @@ private void NormalizeGitDirectory(string gitDirectory, bool noFetch, string cur
                 else if (localBranchesWhereCommitShaIsHead.Count == 0)
                 {
                     log.Info($"No local branch pointing at the commit '{headSha}'. Fake branch needs to be created.");
-                    repository.CreateFakeBranchPointingAtThePullRequestTip(log, authentication);
+                    CreateFakeBranchPointingAtThePullRequestTip(repository, log, authentication);
                 }
                 else
                 {
@@ -318,5 +319,194 @@ To disable this error set an environmental variable called IGNORE_NORMALISATION_
                 }
             }
         }
+
+        private static void CreateOrUpdateLocalBranchesFromRemoteTrackingOnes(IGitRepository repo, ILog log, string remoteName)
+        {
+            var prefix = $"refs/remotes/{remoteName}/";
+            var remoteHeadCanonicalName = $"{prefix}HEAD";
+            var remoteTrackingReferences = repo.Refs
+                .FromGlob(prefix + "*")
+                .Where(r => !r.CanonicalName.IsEquivalentTo(remoteHeadCanonicalName));
+
+            foreach (var remoteTrackingReference in remoteTrackingReferences)
+            {
+                var remoteTrackingReferenceName = remoteTrackingReference.CanonicalName;
+                var branchName = remoteTrackingReferenceName.Substring(prefix.Length);
+                var localCanonicalName = "refs/heads/" + branchName;
+
+                // We do not want to touch our current branch
+                if (branchName.IsEquivalentTo(repo.Head.FriendlyName)) continue;
+
+                if (repo.Refs.Any(x => x.CanonicalName.IsEquivalentTo(localCanonicalName)))
+                {
+                    var localRef = repo.Refs[localCanonicalName];
+                    var remotedirectReference = remoteTrackingReference.ResolveToDirectReference();
+                    if (localRef.ResolveToDirectReference().TargetIdentifier == remotedirectReference.TargetIdentifier)
+                    {
+                        log.Info($"Skipping update of '{remoteTrackingReference.CanonicalName}' as it already matches the remote ref.");
+                        continue;
+                    }
+                    var remoteRefTipId = remotedirectReference.Target.Id;
+                    log.Info($"Updating local ref '{localRef.CanonicalName}' to point at {remoteRefTipId}.");
+                    repo.Refs.UpdateTarget(localRef, remoteRefTipId);
+                    continue;
+                }
+
+                log.Info($"Creating local branch from remote tracking '{remoteTrackingReference.CanonicalName}'.");
+                repo.Refs.Add(localCanonicalName, new ObjectId(remoteTrackingReference.ResolveToDirectReference().TargetIdentifier), true);
+
+                var branch = repo.Branches[branchName];
+                repo.Branches.Update(branch, b => b.TrackedBranch = remoteTrackingReferenceName);
+            }
+        }
+
+        private static void EnsureLocalBranchExistsForCurrentBranch(IGitRepository repo, ILog log, Remote remote, string currentBranch)
+        {
+            if (log is null)
+            {
+                throw new ArgumentNullException(nameof(log));
+            }
+
+            if (remote is null)
+            {
+                throw new ArgumentNullException(nameof(remote));
+            }
+
+            if (string.IsNullOrEmpty(currentBranch)) return;
+
+            var isRef = currentBranch.Contains("refs");
+            var isBranch = currentBranch.Contains("refs/heads");
+            var localCanonicalName = !isRef
+                ? "refs/heads/" + currentBranch
+                : isBranch
+                    ? currentBranch
+                    : currentBranch.Replace("refs/", "refs/heads/");
+
+            var repoTip = repo.Head.Tip;
+
+            // We currently have the rep.Head of the *default* branch, now we need to look up the right one
+            var originCanonicalName = $"{remote.Name}/{currentBranch}";
+            var originBranch = repo.Branches[originCanonicalName];
+            if (originBranch != null)
+            {
+                repoTip = originBranch.Tip;
+            }
+
+            var repoTipId = repoTip.Id;
+
+            if (repo.Branches.All(b => !b.CanonicalName.IsEquivalentTo(localCanonicalName)))
+            {
+                log.Info(isBranch ? $"Creating local branch {localCanonicalName}"
+                    : $"Creating local branch {localCanonicalName} pointing at {repoTipId}");
+                repo.Refs.Add(localCanonicalName, repoTipId);
+            }
+            else
+            {
+                log.Info(isBranch ? $"Updating local branch {localCanonicalName} to point at {repoTip.Sha}"
+                    : $"Updating local branch {localCanonicalName} to match ref {currentBranch}");
+                var localRef = repo.Refs[localCanonicalName];
+                repo.Refs.UpdateTarget(localRef, repoTipId);
+            }
+
+            repo.Commands.Checkout(localCanonicalName);
+        }
+
+        private static Remote EnsureOnlyOneRemoteIsDefined(IGitRepository repo, ILog log)
+        {
+            var remotes = repo.Network.Remotes;
+            var howMany = remotes.Count();
+
+            if (howMany == 1)
+            {
+                var remote = remotes.Single();
+                log.Info($"One remote found ({remote.Name} -> '{remote.Url}').");
+                return remote;
+            }
+
+            var message = $"{howMany} remote(s) have been detected. When being run on a build server, the Git repository is expected to bear one (and no more than one) remote.";
+            throw new WarningException(message);
+        }
+
+        private static void AddMissingRefSpecs(IGitRepository repo, ILog log, Remote remote)
+        {
+            if (remote.FetchRefSpecs.Any(r => r.Source == "refs/heads/*"))
+                return;
+
+            var allBranchesFetchRefSpec = $"+refs/heads/*:refs/remotes/{remote.Name}/*";
+
+            log.Info($"Adding refspec: {allBranchesFetchRefSpec}");
+
+            repo.Network.Remotes.Update(remote.Name,
+                r => r.FetchRefSpecs.Add(allBranchesFetchRefSpec));
+        }
+
+        private static void CreateFakeBranchPointingAtThePullRequestTip(IGitRepository repo, ILog log, AuthenticationInfo authentication)
+        {
+            var remote = repo.Network.Remotes.Single();
+
+            log.Info("Fetching remote refs to see if there is a pull request ref");
+            var remoteTips = (string.IsNullOrEmpty(authentication.Username) ?
+                    GetRemoteTipsForAnonymousUser(repo, remote) :
+                    GetRemoteTipsUsingUsernamePasswordCredentials(repo, remote, authentication.Username, authentication.Password))
+                .ToList();
+
+            log.Info($"Remote Refs:{System.Environment.NewLine}" + string.Join(System.Environment.NewLine, remoteTips.Select(r => r.CanonicalName)));
+
+            var headTipSha = repo.Head.Tip.Sha;
+
+            var refs = remoteTips.Where(r => r.TargetIdentifier == headTipSha).ToList();
+
+            if (refs.Count == 0)
+            {
+                var message = $"Couldn't find any remote tips from remote '{remote.Url}' pointing at the commit '{headTipSha}'.";
+                throw new WarningException(message);
+            }
+
+            if (refs.Count > 1)
+            {
+                var names = string.Join(", ", refs.Select(r => r.CanonicalName));
+                var message = $"Found more than one remote tip from remote '{remote.Url}' pointing at the commit '{headTipSha}'. Unable to determine which one to use ({names}).";
+                throw new WarningException(message);
+            }
+
+            var reference = refs[0];
+            var canonicalName = reference.CanonicalName;
+            log.Info($"Found remote tip '{canonicalName}' pointing at the commit '{headTipSha}'.");
+
+            if (canonicalName.StartsWith("refs/tags"))
+            {
+                log.Info($"Checking out tag '{canonicalName}'");
+                repo.Commands.Checkout(reference.Target.Sha);
+                return;
+            }
+
+            if (!canonicalName.StartsWith("refs/pull/") && !canonicalName.StartsWith("refs/pull-requests/"))
+            {
+                var message = $"Remote tip '{canonicalName}' from remote '{remote.Url}' doesn't look like a valid pull request.";
+                throw new WarningException(message);
+            }
+
+            var fakeBranchName = canonicalName.Replace("refs/pull/", "refs/heads/pull/").Replace("refs/pull-requests/", "refs/heads/pull-requests/");
+
+            log.Info($"Creating fake local branch '{fakeBranchName}'.");
+            repo.Refs.Add(fakeBranchName, new ObjectId(headTipSha));
+
+            log.Info($"Checking local branch '{fakeBranchName}' out.");
+            repo.Commands.Checkout(fakeBranchName);
+        }
+
+        private static IEnumerable<DirectReference> GetRemoteTipsUsingUsernamePasswordCredentials(IGitRepository repository, Remote remote, string username, string password)
+        {
+            return repository.Network.ListReferences(remote, (url, fromUrl, types) => new UsernamePasswordCredentials
+            {
+                Username = username,
+                Password = password ?? string.Empty
+            }).Select(r => r.ResolveToDirectReference());
+        }
+
+        private static IEnumerable<DirectReference> GetRemoteTipsForAnonymousUser(IGitRepository repository, Remote remote)
+        {
+            return repository.Network.ListReferences(remote).Select(r => r.ResolveToDirectReference());
+        }
     }
 }
diff --git a/src/GitVersionCore/Core/RepositoryMetadataProvider.cs b/src/GitVersionCore/Core/RepositoryMetadataProvider.cs
@@ -200,7 +200,7 @@ public Branch GetTargetBranch(string targetBranch)
 
         public Branch FindBranch(string branchName)
         {
-            return repository.FindBranch(branchName);
+            return repository.Branches.FirstOrDefault(x => x.NameWithoutRemote() == branchName);
         }
 
         public Branch GetChosenBranch(Config configuration)
diff --git a/src/GitVersionCore/Extensions/RepositoryExtensions.cs b/src/GitVersionCore/Extensions/RepositoryExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -31,10 +31,7 @@ public static void DumpGraph(this IRepository repository, Action<string> writer`
`31`	`31`
`32`	`32`	`public static VersionVariables GetVersion(this RepositoryFixtureBase fixture, Config configuration = null, IRepository repository = null, string commitId = null, bool onlyTrackedBranches = true, string branch = null)`
`33`	`33`	`{`
`34`		`- if (configuration == null)`
`35`		`- {`
`36`		`- configuration = new ConfigurationBuilder().Build();`
`37`		`- }`
	`34`	`+ configuration ??= new ConfigurationBuilder().Build();`
`38`	`35`
`39`	`36`	`repository ??= fixture.Repository;`
`40`	`37`
Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ public Branch GetTargetBranch(string targetBranch)`
`200`	`200`
`201`	`201`	`public Branch FindBranch(string branchName)`
`202`	`202`	`{`
`203`		`- return repository.FindBranch(branchName);`
	`203`	`+ return repository.Branches.FirstOrDefault(x => x.NameWithoutRemote() == branchName);`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`public Branch GetChosenBranch(Config configuration)`