public IObservable <Unit> Pull(ILocalRepositoryModel repository)
{
return(Observable.Defer(() =>
{
var repo = gitService.GetRepository(repository.LocalPath);
var refspec = string.Format(CultureInfo.InvariantCulture, "{0}:{0}", repo.Head.FriendlyName);
return gitClient.Fetch(repo, "origin", new[] { refspec }).ToObservable();
}));
}
public IObservable <Unit> Checkout(ILocalRepositoryModel repository, IPullRequestModel pullRequest, string localBranchName)
{
return(Observable.Defer(async() =>
{
var repo = gitService.GetRepository(repository.LocalPath);
var existing = repo.Branches[localBranchName];
if (existing != null)
{
await gitClient.Checkout(repo, localBranchName);
}
else if (repository.CloneUrl.ToRepositoryUrl() == pullRequest.Head.RepositoryCloneUrl.ToRepositoryUrl())
{
var remote = await gitClient.GetHttpRemote(repo, "origin");
await gitClient.Fetch(repo, remote.Name);
await gitClient.Checkout(repo, localBranchName);
}
else
{
var refSpec = $"{pullRequest.Head.Ref}:{localBranchName}";
var prConfigKey = $"branch.{localBranchName}.{SettingGHfVSPullRequest}";
var remoteName = await CreateRemote(repo, pullRequest.Head.RepositoryCloneUrl);
await gitClient.Fetch(repo, remoteName);
await gitClient.Fetch(repo, remoteName, new[] { refSpec });
await gitClient.Checkout(repo, localBranchName);
await gitClient.SetTrackingBranch(repo, localBranchName, $"refs/remotes/{remoteName}/{pullRequest.Head.Ref}");
await gitClient.SetConfig(repo, prConfigKey, pullRequest.Number.ToString());
}
return Observable.Return(Unit.Default);
}));
}
public IObservable <Octokit.Repository> PublishRepository(
Octokit.NewRepository newRepository,
IAccount account,
IApiClient apiClient)
{
return(Observable.Defer(() => apiClient.CreateRepository(newRepository, account.Login, account.IsUser)
.Select(remoteRepo => new { RemoteRepo = remoteRepo, LocalRepo = activeRepository }))
.SelectMany(repo => gitClient.SetRemote(repo.LocalRepo, "origin", new Uri(repo.RemoteRepo.CloneUrl)).Select(_ => repo))
.SelectMany(repo => gitClient.Push(repo.LocalRepo, "master", "origin").Select(_ => repo))
.SelectMany(repo => gitClient.Fetch(repo.LocalRepo, "origin").Select(_ => repo))
.SelectMany(repo => gitClient.SetTrackingBranch(repo.LocalRepo, "master", "origin").Select(_ => repo.RemoteRepo)));
}
public IObservable <Octokit.Repository> PublishRepository(
Octokit.NewRepository newRepository,
IAccount account,
IApiClient apiClient)
{
return(Observable.Defer(() => Observable.Return(activeRepository))
.SelectMany(r => apiClient.CreateRepository(newRepository, account.Login, account.IsUser)
.Select(gitHubRepo => Tuple.Create(gitHubRepo, r)))
.SelectMany(repo => gitClient.SetRemote(repo.Item2, "origin", new Uri(repo.Item1.CloneUrl)).Select(_ => repo))
.SelectMany(repo => gitClient.Push(repo.Item2, "master", "origin").Select(_ => repo))
.SelectMany(repo => gitClient.Fetch(repo.Item2, "origin").Select(_ => repo))
.SelectMany(repo => gitClient.SetTrackingBranch(repo.Item2, "master", "origin").Select(_ => repo.Item1)));
}
public IObservable <Octokit.Repository> PublishRepository(
Octokit.NewRepository newRepository,
IAccount account,
IApiClient apiClient)
{
return(Observable.Defer(() => apiClient.CreateRepository(newRepository, account.Login, account.IsUser)
.ObserveOn(RxApp.MainThreadScheduler)
.Select(remoteRepo => new { RemoteRepo = remoteRepo, LocalRepo = vsGitServices.GetActiveRepo() }))
.SelectMany(async repo =>
{
await gitClient.SetRemote(repo.LocalRepo, "origin", new Uri(repo.RemoteRepo.CloneUrl));
await gitClient.Push(repo.LocalRepo, "master", "origin");
await gitClient.Fetch(repo.LocalRepo, "origin");
await gitClient.SetTrackingBranch(repo.LocalRepo, "master", "origin");
return repo.RemoteRepo;
}));
}
public async Task <byte[]> ExtractFileFromGit(
ILocalRepositoryModel repository,
int pullRequestNumber,
string sha,
string relativePath)
{
var repo = await GetRepository(repository);
try
{
return(await gitClient.ExtractFileBinary(repo, sha, relativePath));
}
catch (FileNotFoundException)
{
var pullHeadRef = $"refs/pull/{pullRequestNumber}/head";
await gitClient.Fetch(repo, "origin", sha, pullHeadRef);
return(await gitClient.ExtractFileBinary(repo, sha, relativePath));
}
}
private async Task SwitchRemotes(IRepository repository, Uri originUri, Uri upstreamUri = null, bool trackMasterUpstream = false)
{
Guard.ArgumentNotNull(originUri, nameof(originUri));
log.Verbose("Set remote origin to {OriginUri}", originUri);
await gitClient.SetRemote(repository, "origin", originUri);
if (upstreamUri != null)
{
log.Verbose("Set remote upstream to {UpstreamUri}", upstreamUri);
await gitClient.SetRemote(repository, "upstream", upstreamUri);
await gitClient.Fetch(repository, "upstream");
if (trackMasterUpstream)
{
log.Verbose("set master tracking to upstream");
await gitClient.SetTrackingBranch(repository, "master", "upstream");
}
}
}
public IObservable <Unit> Checkout(LocalRepositoryModel repository, PullRequestDetailModel pullRequest, string localBranchName)
{
return(Observable.Defer(async() =>
{
using (var repo = gitService.GetRepository(repository.LocalPath))
{
var existing = repo.Branches[localBranchName];
if (existing != null)
{
await gitClient.Checkout(repo, localBranchName);
}
else if (string.Equals(repository.CloneUrl.Owner, pullRequest.HeadRepositoryOwner, StringComparison.OrdinalIgnoreCase))
{
var remote = await gitClient.GetHttpRemote(repo, "origin");
await gitClient.Fetch(repo, remote.Name);
await gitClient.Checkout(repo, localBranchName);
}
else
{
var refSpec = $"{pullRequest.HeadRefName}:{localBranchName}";
var remoteName = await CreateRemote(repo, repository.CloneUrl.WithOwner(pullRequest.HeadRepositoryOwner));
await gitClient.Fetch(repo, remoteName);
await gitClient.Fetch(repo, remoteName, new[] { refSpec });
await gitClient.Checkout(repo, localBranchName);
await gitClient.SetTrackingBranch(repo, localBranchName, $"refs/remotes/{remoteName}/{pullRequest.HeadRefName}");
}
// Store the PR number in the branch config with the key "ghfvs-pr".
var prConfigKey = $"branch.{localBranchName}.{SettingGHfVSPullRequest}";
await gitClient.SetConfig(repo, prConfigKey, BuildGHfVSConfigKeyValue(pullRequest.BaseRepositoryOwner, pullRequest.Number));
return Observable.Return(Unit.Default);
}
}));
}
