Merge branch 'grokys/maintainer-workflow' of https://github.com/github/VisualStudio into don/status-polish

Author: donokuda

src/GitHub.App/SampleData/PullRequestDetailViewModelDesigner.cs

@@ -69,10 +69,13 @@ public PullRequestDetailViewModelDesigner()
         public CheckoutMode CheckoutMode { get; set; }
         public string CheckoutError { get; set; }
         public int CommitsBehind { get; set; }
+        public string CheckoutDisabledMessage { get; set; }
 
         public ReactiveCommand<Unit> Checkout { get; }
         public ReactiveCommand<object> OpenOnGitHub { get; }
+        public ReactiveCommand<object> OpenFile { get; }
         public ReactiveCommand<object> ToggleChangedFilesView { get; }
         public ReactiveCommand<object> ToggleOpenChangedFileAction { get; }
+        public ReactiveCommand<object> ViewOpenFile { get; }
     }
 }

src/GitHub.App/Services/GitClient.cs

@@ -113,11 +113,20 @@ public Task SetTrackingBranch(IRepository repository, string branchName, string
             });
         }
 
-        public Task<Remote> GetHttpRemote(IRepository repo, string remote)
+        public Task UnsetConfig(IRepository repository, string key)
         {
+            Guard.ArgumentNotEmptyString(key, nameof(key));
+
             return Task.Factory.StartNew(() =>
             {
+                repository.Config.Unset(key);
+            });
+        }
 
+        public Task<Remote> GetHttpRemote(IRepository repo, string remote)
+        {
+            return Task.Factory.StartNew(() =>
+            {
                 var uri = GitService.GitServiceHelper.GetRemoteUri(repo, remote);
                 var remoteName = uri.IsHypertextTransferProtocol ? remote : remote + "-http";
                 var ret = repo.Network.Remotes[remoteName];

src/GitHub.App/Services/PullRequestService.cs

@@ -14,6 +14,7 @@
 using System.Reactive;
 using System.Collections.Generic;
 using LibGit2Sharp;
+using PullRequest =  Octokit.PullRequest;
 
 namespace GitHub.Services
 {
@@ -83,14 +84,33 @@ public IObservable<string> GetPullRequestTemplate(ILocalRepositoryModel reposito
             });
         }
 
+        public IObservable<bool> CleanForCheckout(ILocalRepositoryModel repository)
+        {
+            var repo = gitService.GetRepository(repository.LocalPath);
+            return Observable.Return(!repo.RetrieveStatus().IsDirty);
+        }
+
         public IObservable<Unit> FetchAndCheckout(ILocalRepositoryModel repository, int pullRequestNumber, string localBranchName)
         {
             return DoFetchAndCheckout(repository, pullRequestNumber, localBranchName).ToObservable();
         }
 
-        public string GetDefaultLocalBranchName(int pullRequestNumber, string pullRequestTitle)
+        public IObservable<string> GetDefaultLocalBranchName(ILocalRepositoryModel repository, int pullRequestNumber, string pullRequestTitle)
         {
-            return "pr/" + pullRequestNumber + "-" + GetSafeBranchName(pullRequestTitle);
+            return Observable.Defer(() =>
+            {
+                var initial = "pr/" + pullRequestNumber + "-" + GetSafeBranchName(pullRequestTitle);
+                var current = initial;
+                var repo = gitService.GetRepository(repository.LocalPath);
+                var index = 2;
+
+                while (repo.Branches[current] != null)
+                {
+                    current = initial + '-' + index++;
+                }
+
+                return Observable.Return(current);
+            });
         }
 
         public IObservable<HistoryDivergence> CalculateHistoryDivergence(ILocalRepositoryModel repository, int pullRequestNumber)
@@ -117,43 +137,92 @@ public IObservable<HistoryDivergence> CalculateHistoryDivergence(ILocalRepositor
             });
         }
 
-        public IObservable<IBranch> GetLocalBranches(ILocalRepositoryModel repository, int number)
+        public IObservable<IBranch> GetLocalBranches(ILocalRepositoryModel repository, PullRequest pullRequest)
         {
             return Observable.Defer(() =>
             {
                 var repo = gitService.GetRepository(repository.LocalPath);
-                var result = GetLocalBranchesInternal(repo, number).Select(x => new BranchModel(x, repository));
+                var result = GetLocalBranchesInternal(repository, repo, pullRequest).Select(x => new BranchModel(x, repository));
                 return result.ToObservable();
             });
         }
 
-        public IObservable<Unit> SwitchToBranch(ILocalRepositoryModel repository, int number)
+        public bool IsPullRequestFromFork(ILocalRepositoryModel repository, PullRequest pullRequest)
         {
-            return Observable.Defer(() =>
+            var sourceUrl = new UriString(pullRequest.Head.Repository.CloneUrl);
+            return sourceUrl.ToRepositoryUrl() != repository.CloneUrl.ToRepositoryUrl();
+        }
+
+        public IObservable<Unit> SwitchToBranch(ILocalRepositoryModel repository, PullRequest pullRequest)
+        {
+            return Observable.Defer(async () =>
             {
                 var repo = gitService.GetRepository(repository.LocalPath);
-                var branch = GetLocalBranchesInternal(repo, number).First();
-                gitClient.Checkout(repo, branch);
+                var branchName = GetLocalBranchesInternal(repository, repo, pullRequest).First();
+
+                await gitClient.Fetch(repo, "origin");
+
+                var branch = repo.Branches[branchName];
+
+                if (branch == null)
+                {
+                    var trackedBranchName = $"refs/remotes/origin/" + branchName;
+                    var trackedBranch = repo.Branches[trackedBranchName];
+
+                    if (trackedBranch != null)
+                    {
+                        branch = repo.CreateBranch(branchName, trackedBranch.Tip);
+                        await gitClient.SetTrackingBranch(repo, branchName, trackedBranchName);
+                    }
+                    else
+                    {
+                        throw new InvalidOperationException($"Could not find branch '{trackedBranchName}'.");
+                    }
+                }
+
+                await gitClient.Checkout(repo, branchName);
+
                 return Observable.Empty<Unit>();
             });
         }
 
+        public IObservable<Unit> UnmarkLocalBranch(ILocalRepositoryModel repository)
+        {
+            return Observable.Defer(async () =>
+            {
+                var repo = gitService.GetRepository(repository.LocalPath);
+                var configKey = $"branch.{repo.Head.FriendlyName}.ghfvs-pr";
+                await gitClient.UnsetConfig(repo, configKey);
+                return Observable.Return(Unit.Default);
+            });
+        }
+
         async Task DoFetchAndCheckout(ILocalRepositoryModel repository, int pullRequestNumber, string localBranchName)
         {
             var repo = gitService.GetRepository(repository.LocalPath);
-            var configKey = $"branch.{BranchNameToConfigKey(localBranchName)}.ghfvs-pr";
+            var configKey = $"branch.{localBranchName}.ghfvs-pr";
             await gitClient.Fetch(repo, "origin", new[] { $"refs/pull/{pullRequestNumber}/head:{localBranchName}" });
             await gitClient.Checkout(repo, localBranchName);
             await gitClient.SetConfig(repo, configKey, pullRequestNumber.ToString());
         }
 
-        IEnumerable<string> GetLocalBranchesInternal(IRepository repository, int number)
+        IEnumerable<string> GetLocalBranchesInternal(
+            ILocalRepositoryModel localRepository,
+            IRepository repository,
+            PullRequest pullRequest)
         {
-            var pr = number.ToString();
-            return repository.Config
-                .Select(x => new { Branch = BranchCapture.Match(x.Key).Groups["branch"].Value, Value = x.Value })
-                .Where(x => !string.IsNullOrWhiteSpace(x.Branch) && x.Value == pr)
-                .Select(x => ConfigKeyToBranchName(x.Branch));
+            if (!IsPullRequestFromFork(localRepository, pullRequest))
+            {
+                return new[] { pullRequest.Head.Ref };
+            }
+            else
+            {
+                var pr = pullRequest.Number.ToString(CultureInfo.InvariantCulture);
+                return repository.Config
+                    .Select(x => new { Branch = BranchCapture.Match(x.Key).Groups["branch"].Value, Value = x.Value })
+                    .Where(x => !string.IsNullOrWhiteSpace(x.Branch) && x.Value == pr)
+                    .Select(x => x.Branch);
+            }
         }
 
         async Task<IPullRequestModel> PushAndCreatePR(IRepositoryHost host,
@@ -191,23 +260,19 @@ void EnsurePullRefSpecExists(IRepository repo)
 
         static string GetSafeBranchName(string name)
         {
-            var before = InvalidBranchCharsRegex.Replace(name, "-");
+            var before = InvalidBranchCharsRegex.Replace(name, "-").TrimEnd('-');
 
             for (;;)
             {
                 string after = before.Replace("--", "-");
 
                 if (after == before)
                 {
-                    return before.ToLower(CultureInfo.InvariantCulture);
+                    return before.ToLower(CultureInfo.CurrentCulture);
                 }
 
                 before = after;
             }
         }
-
-        static string BranchNameToConfigKey(string name) => name.Replace("/", ".");
-
-        static string ConfigKeyToBranchName(string name) => name.Replace(".", "/");
     }
 }