Philippe Miossec
e956d1d340
Since 21f36fa47c, tfs changesets are
fetched by batches of 100 changesets (instead of all at once)
to better support big history when cloning (and use less memory).
This option let the user specify the size of the batch
(because perhaps even 100 is too big for some big repositories).
Values accepted:
x < 0 => Only one batch with ALL the changesets
x == 0 => default value of 100
x > 0 => batches of x changesets
653 lines
24 KiB
C#
653 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
using StructureMap;
|
|
using LibGit2Sharp;
|
|
using Branch = LibGit2Sharp.Branch;
|
|
|
|
namespace Sep.Git.Tfs.Core
|
|
{
|
|
public class GitRepository : GitHelpers, IGitRepository
|
|
{
|
|
private readonly IContainer _container;
|
|
private readonly Globals _globals;
|
|
private IDictionary<string, IGitTfsRemote> _cachedRemotes;
|
|
private Repository _repository;
|
|
private RemoteConfigConverter _remoteConfigReader;
|
|
|
|
public GitRepository(TextWriter stdout, string gitDir, IContainer container, Globals globals, RemoteConfigConverter remoteConfigReader)
|
|
: base(stdout, container)
|
|
{
|
|
_container = container;
|
|
_globals = globals;
|
|
GitDir = gitDir;
|
|
_repository = new LibGit2Sharp.Repository(GitDir);
|
|
_remoteConfigReader = remoteConfigReader;
|
|
}
|
|
|
|
~GitRepository()
|
|
{
|
|
if (_repository != null)
|
|
_repository.Dispose();
|
|
}
|
|
|
|
public GitCommit Commit(LogEntry logEntry)
|
|
{
|
|
var parents = logEntry.CommitParents.Select(sha => _repository.Lookup<Commit>(sha));
|
|
var commit = _repository.ObjectDatabase.CreateCommit(
|
|
new Signature(logEntry.AuthorName, logEntry.AuthorEmail, logEntry.Date.ToUniversalTime()),
|
|
new Signature(logEntry.CommitterName, logEntry.CommitterEmail, logEntry.Date.ToUniversalTime()),
|
|
logEntry.Log,
|
|
logEntry.Tree,
|
|
parents,
|
|
false);
|
|
changesetsCache[logEntry.ChangesetId] = commit.Sha;
|
|
return new GitCommit(commit);
|
|
}
|
|
|
|
public void UpdateRef(string gitRefName, string shaCommit, string message = null)
|
|
{
|
|
if (message == null)
|
|
_repository.Refs.Add(gitRefName, shaCommit, allowOverwrite: true);
|
|
else
|
|
_repository.Refs.Add(gitRefName, shaCommit, _repository.Config.BuildSignature(DateTime.Now), message, true);
|
|
}
|
|
|
|
public static string ShortToLocalName(string branchName)
|
|
{
|
|
return "refs/heads/" + branchName;
|
|
}
|
|
|
|
public string GitDir { get; set; }
|
|
public string WorkingCopyPath { get; set; }
|
|
public string WorkingCopySubdir { get; set; }
|
|
|
|
protected override Process Start(string[] command, Action<ProcessStartInfo> initialize)
|
|
{
|
|
return base.Start(command, initialize.And(SetUpPaths));
|
|
}
|
|
|
|
private void SetUpPaths(ProcessStartInfo gitCommand)
|
|
{
|
|
if (GitDir != null)
|
|
gitCommand.EnvironmentVariables["GIT_DIR"] = GitDir;
|
|
if (WorkingCopyPath != null)
|
|
gitCommand.WorkingDirectory = WorkingCopyPath;
|
|
if (WorkingCopySubdir != null)
|
|
gitCommand.WorkingDirectory = Path.Combine(gitCommand.WorkingDirectory, WorkingCopySubdir);
|
|
}
|
|
|
|
public string GetConfig(string key)
|
|
{
|
|
var entry = _repository.Config.Get<string>(key);
|
|
return entry == null ? null : entry.Value;
|
|
}
|
|
|
|
public T GetConfig<T>(string key)
|
|
{
|
|
try
|
|
{
|
|
var entry = _repository.Config.Get<T>(key);
|
|
return entry.Value;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return default(T);
|
|
}
|
|
}
|
|
|
|
public void SetConfig(string key, string value)
|
|
{
|
|
_repository.Config.Set<string>(key, value, ConfigurationLevel.Local);
|
|
}
|
|
|
|
|
|
public IEnumerable<IGitTfsRemote> ReadAllTfsRemotes()
|
|
{
|
|
var remotes = GetTfsRemotes().Values;
|
|
foreach (var remote in remotes)
|
|
remote.EnsureTfsAuthenticated();
|
|
|
|
return remotes;
|
|
}
|
|
|
|
public IGitTfsRemote ReadTfsRemote(string remoteId)
|
|
{
|
|
if (!HasRemote(remoteId))
|
|
throw new GitTfsException("Unable to locate git-tfs remote with id = " + remoteId)
|
|
.WithRecommendation("Try using `git tfs bootstrap` to auto-init TFS remotes.");
|
|
var remote = GetTfsRemotes()[remoteId];
|
|
remote.EnsureTfsAuthenticated();
|
|
return remote;
|
|
}
|
|
|
|
private IGitTfsRemote ReadTfsRemote(string tfsUrl, string tfsRepositoryPath)
|
|
{
|
|
var allRemotes = GetTfsRemotes();
|
|
var matchingRemotes =
|
|
allRemotes.Values.Where(
|
|
remote => remote.MatchesUrlAndRepositoryPath(tfsUrl, tfsRepositoryPath));
|
|
switch (matchingRemotes.Count())
|
|
{
|
|
case 0:
|
|
return new DerivedGitTfsRemote(tfsUrl, tfsRepositoryPath);
|
|
case 1:
|
|
var remote = matchingRemotes.First();
|
|
return remote;
|
|
default:
|
|
Trace.WriteLine("More than one remote matched!");
|
|
goto case 1;
|
|
}
|
|
}
|
|
|
|
public IEnumerable<string> GetGitRemoteBranches(string gitRemote)
|
|
{
|
|
gitRemote = gitRemote + "/";
|
|
var references = _repository.Branches.Where(b => b.IsRemote && b.Name.StartsWith(gitRemote) && !b.Name.EndsWith("/HEAD"));
|
|
return references.Select(r => r.Name);
|
|
}
|
|
|
|
private IDictionary<string, IGitTfsRemote> GetTfsRemotes()
|
|
{
|
|
return _cachedRemotes ?? (_cachedRemotes = ReadTfsRemotes());
|
|
}
|
|
|
|
public IGitTfsRemote CreateTfsRemote(RemoteInfo remote, string autocrlf = null, string ignorecase = null)
|
|
{
|
|
if (HasRemote(remote.Id))
|
|
throw new GitTfsException("A remote with id \"" + remote.Id + "\" already exists.");
|
|
|
|
// The autocrlf default (as indicated by a null) is false and is set to override the system-wide setting.
|
|
// When creating branches we use the empty string to indicate that we do not want to set the value at all.
|
|
if (autocrlf == null)
|
|
autocrlf = "false";
|
|
if (autocrlf != String.Empty)
|
|
_repository.Config.Set("core.autocrlf", autocrlf);
|
|
|
|
if (ignorecase != null)
|
|
_repository.Config.Set("core.ignorecase", ignorecase);
|
|
|
|
foreach (var entry in _remoteConfigReader.Dump(remote))
|
|
{
|
|
if (entry.Value != null)
|
|
{
|
|
_repository.Config.Set(entry.Key, entry.Value);
|
|
}
|
|
else
|
|
{
|
|
_repository.Config.Unset(entry.Key);
|
|
}
|
|
}
|
|
|
|
var gitTfsRemote = BuildRemote(remote);
|
|
gitTfsRemote.EnsureTfsAuthenticated();
|
|
|
|
return _cachedRemotes[remote.Id] = gitTfsRemote;
|
|
}
|
|
|
|
public void DeleteTfsRemote(IGitTfsRemote remote)
|
|
{
|
|
if (remote == null)
|
|
throw new GitTfsException("error: the name of the remote to delete is invalid!");
|
|
|
|
UnsetTfsRemoteConfig(remote.Id);
|
|
_repository.Refs.Remove(remote.RemoteRef);
|
|
}
|
|
|
|
private void UnsetTfsRemoteConfig(string remoteId)
|
|
{
|
|
foreach (var entry in _remoteConfigReader.Delete(remoteId))
|
|
{
|
|
_repository.Config.Unset(entry.Key);
|
|
}
|
|
_cachedRemotes = null;
|
|
}
|
|
|
|
public void MoveRemote(string oldRemoteName, string newRemoteName)
|
|
{
|
|
if (!Reference.IsValidName(ShortToLocalName(oldRemoteName)))
|
|
throw new GitTfsException("error: the name of the remote to move is invalid!");
|
|
|
|
if (!Reference.IsValidName(ShortToLocalName(newRemoteName)))
|
|
throw new GitTfsException("error: the new name of the remote is invalid!");
|
|
|
|
if (HasRemote(newRemoteName))
|
|
throw new GitTfsException(string.Format("error: this remote name \"{0}\" is already used!", newRemoteName));
|
|
|
|
var oldRemote = ReadTfsRemote(oldRemoteName);
|
|
if(oldRemote == null)
|
|
throw new GitTfsException(string.Format("error: the remote \"{0}\" doesn't exist!", oldRemoteName));
|
|
|
|
var remoteInfo = oldRemote.RemoteInfo;
|
|
remoteInfo.Id = newRemoteName;
|
|
|
|
CreateTfsRemote(remoteInfo);
|
|
var newRemote = ReadTfsRemote(newRemoteName);
|
|
|
|
_repository.Refs.Move(oldRemote.RemoteRef, newRemote.RemoteRef);
|
|
UnsetTfsRemoteConfig(oldRemoteName);
|
|
}
|
|
|
|
public Branch RenameBranch(string oldName, string newName)
|
|
{
|
|
var branch = _repository.Branches[oldName];
|
|
|
|
if (branch == null)
|
|
return null;
|
|
|
|
return _repository.Branches.Rename(branch, newName);
|
|
}
|
|
|
|
private IDictionary<string, IGitTfsRemote> ReadTfsRemotes()
|
|
{
|
|
// does this need to ensuretfsauthenticated?
|
|
_repository.Config.Set("tfs.touch", "1"); // reload configuration, because `git tfs init` and `git tfs clone` use Process.Start to update the config, so _repository's copy is out of date.
|
|
return _remoteConfigReader.Load(_repository.Config).Select(x => BuildRemote(x)).ToDictionary(x => x.Id);
|
|
}
|
|
|
|
private IGitTfsRemote BuildRemote(RemoteInfo remoteInfo)
|
|
{
|
|
return _container.With(remoteInfo).With<IGitRepository>(this).GetInstance<IGitTfsRemote>();
|
|
}
|
|
|
|
public bool HasRemote(string remoteId)
|
|
{
|
|
return GetTfsRemotes().ContainsKey(remoteId);
|
|
}
|
|
|
|
public bool HasRef(string gitRef)
|
|
{
|
|
return _repository.Refs[gitRef] != null;
|
|
}
|
|
|
|
public void MoveTfsRefForwardIfNeeded(IGitTfsRemote remote)
|
|
{
|
|
long currentMaxChangesetId = remote.MaxChangesetId;
|
|
var untrackedTfsChangesets = from cs in GetLastParentTfsCommits("HEAD")
|
|
where cs.Remote.Id == remote.Id && cs.ChangesetId > currentMaxChangesetId
|
|
orderby cs.ChangesetId
|
|
select cs;
|
|
foreach (var cs in untrackedTfsChangesets)
|
|
{
|
|
// UpdateTfsHead sets tag with TFS changeset id on each commit so we can't just update to latest
|
|
remote.UpdateTfsHead(cs.GitCommit, cs.ChangesetId);
|
|
}
|
|
}
|
|
|
|
public GitCommit GetCommit(string commitish)
|
|
{
|
|
return new GitCommit(_repository.Lookup<Commit>(commitish));
|
|
}
|
|
|
|
public MergeResult Merge(string commitish)
|
|
{
|
|
var commit = _repository.Lookup<Commit>(commitish);
|
|
if(commit == null)
|
|
throw new GitTfsException("error: commit '"+ commitish + "' can't be found and merged into!");
|
|
return _repository.Merge(commit, _repository.Config.BuildSignature(new DateTimeOffset(DateTime.Now)));
|
|
}
|
|
|
|
public String GetCurrentCommit()
|
|
{
|
|
return _repository.Head.Commits.First().Sha;
|
|
}
|
|
|
|
public IEnumerable<TfsChangesetInfo> GetLastParentTfsCommits(string head)
|
|
{
|
|
var changesets = new List<TfsChangesetInfo>();
|
|
var commit = _repository.Lookup<Commit>(head);
|
|
if (commit == null)
|
|
return changesets;
|
|
FindTfsParentCommits(changesets, commit);
|
|
return changesets;
|
|
}
|
|
|
|
private void FindTfsParentCommits(List<TfsChangesetInfo> changesets, Commit commit)
|
|
{
|
|
var commitsToFollow = new Stack<Commit>();
|
|
commitsToFollow.Push(commit);
|
|
var alreadyVisitedCommits = new HashSet<string>();
|
|
while (commitsToFollow.Any())
|
|
{
|
|
commit = commitsToFollow.Pop();
|
|
|
|
alreadyVisitedCommits.Add(commit.Sha);
|
|
|
|
var changesetInfo = TryParseChangesetInfo(commit.Message, commit.Sha);
|
|
if (changesetInfo == null)
|
|
{
|
|
// If commit was not a TFS commit, continue searching all new parents of the commit
|
|
// Add parents in reverse order to keep topology (main parent should be treated first!)
|
|
foreach (var parent in commit.Parents.Where(x => !alreadyVisitedCommits.Contains(x.Sha)).Reverse())
|
|
commitsToFollow.Push(parent);
|
|
}
|
|
else
|
|
{
|
|
changesets.Add(changesetInfo);
|
|
}
|
|
}
|
|
Trace.WriteLine("Commits visited count:" + alreadyVisitedCommits.Count);
|
|
}
|
|
|
|
public TfsChangesetInfo GetTfsChangesetById(string remoteRef, long changesetId)
|
|
{
|
|
var commit = FindCommitByChangesetId(changesetId, remoteRef);
|
|
if (commit == null)
|
|
return null;
|
|
return TryParseChangesetInfo(commit.Message, commit.Sha);
|
|
}
|
|
|
|
public TfsChangesetInfo GetCurrentTfsCommit()
|
|
{
|
|
var currentCommit = _repository.Head.Commits.First();
|
|
return TryParseChangesetInfo(currentCommit.Message, currentCommit.Sha);
|
|
}
|
|
|
|
public TfsChangesetInfo GetTfsCommit(string sha)
|
|
{
|
|
return TryParseChangesetInfo(GetCommit(sha).Message, sha);
|
|
}
|
|
|
|
private TfsChangesetInfo TryParseChangesetInfo(string gitTfsMetaInfo, string commit)
|
|
{
|
|
var match = GitTfsConstants.TfsCommitInfoRegex.Match(gitTfsMetaInfo);
|
|
if (match.Success)
|
|
{
|
|
var commitInfo = _container.GetInstance<TfsChangesetInfo>();
|
|
commitInfo.Remote = ReadTfsRemote(match.Groups["url"].Value, match.Groups["repository"].Success ? match.Groups["repository"].Value : null);
|
|
commitInfo.ChangesetId = Convert.ToInt32(match.Groups["changeset"].Value);
|
|
commitInfo.GitCommit = commit;
|
|
return commitInfo;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public IDictionary<string, GitObject> CreateObjectsDictionary()
|
|
{
|
|
return new Dictionary<string, GitObject>(StringComparer.InvariantCultureIgnoreCase);
|
|
}
|
|
|
|
public IDictionary<string, GitObject> GetObjects(string commit, IDictionary<string, GitObject> entries)
|
|
{
|
|
if (commit != null)
|
|
{
|
|
ParseEntries(entries, _repository.Lookup<Commit>(commit).Tree, commit);
|
|
}
|
|
return entries;
|
|
}
|
|
|
|
public IDictionary<string, GitObject> GetObjects(string commit)
|
|
{
|
|
var entries = CreateObjectsDictionary();
|
|
return GetObjects(commit, entries);
|
|
}
|
|
|
|
public IGitTreeBuilder GetTreeBuilder(string commit)
|
|
{
|
|
if (commit == null)
|
|
{
|
|
return new GitTreeBuilder(_repository.ObjectDatabase);
|
|
}
|
|
else
|
|
{
|
|
return new GitTreeBuilder(_repository.ObjectDatabase, _repository.Lookup<Commit>(commit).Tree);
|
|
}
|
|
}
|
|
|
|
public string GetCommitMessage(string head, string parentCommitish)
|
|
{
|
|
var message = new System.Text.StringBuilder();
|
|
foreach (Commit comm in
|
|
_repository.Commits.QueryBy(new CommitFilter { Since = head, Until = parentCommitish }))
|
|
{
|
|
// Normalize commit message line endings to CR+LF style, so that message
|
|
// would be correctly shown in TFS commit dialog.
|
|
message.AppendLine(NormalizeLineEndings(comm.Message));
|
|
}
|
|
|
|
return GitTfsConstants.TfsCommitInfoRegex.Replace(message.ToString(), "").Trim(' ', '\r', '\n');
|
|
}
|
|
|
|
private static string NormalizeLineEndings(string input)
|
|
{
|
|
return string.IsNullOrEmpty(input)
|
|
? input
|
|
: input.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "\r\n");
|
|
}
|
|
|
|
private void ParseEntries(IDictionary<string, GitObject> entries, Tree treeInfo, string commit)
|
|
{
|
|
var treesToDescend = new Queue<Tree>(new[] {treeInfo});
|
|
while (treesToDescend.Any())
|
|
{
|
|
var currentTree = treesToDescend.Dequeue();
|
|
foreach (var item in currentTree)
|
|
{
|
|
if (item.TargetType == TreeEntryTargetType.Tree)
|
|
{
|
|
treesToDescend.Enqueue((Tree)item.Target);
|
|
}
|
|
var path = item.Path.Replace('\\', '/');
|
|
entries[path] = new GitObject
|
|
{
|
|
Mode = item.Mode,
|
|
Sha = item.Target.Sha,
|
|
ObjectType = item.TargetType,
|
|
Path = path,
|
|
Commit = commit
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
public IEnumerable<IGitChangedFile> GetChangedFiles(string from, string to)
|
|
{
|
|
using (var diffOutput = CommandOutputPipe("diff-tree", "-r", "-M", "-z", from, to))
|
|
{
|
|
var changes = GitChangeInfo.GetChangedFiles(diffOutput);
|
|
foreach (var change in changes)
|
|
{
|
|
yield return BuildGitChangedFile(change);
|
|
}
|
|
}
|
|
}
|
|
|
|
private IGitChangedFile BuildGitChangedFile(GitChangeInfo change)
|
|
{
|
|
return change.ToGitChangedFile(_container.With((IGitRepository) this));
|
|
}
|
|
|
|
public bool WorkingCopyHasUnstagedOrUncommitedChanges
|
|
{
|
|
get
|
|
{
|
|
if (IsBare)
|
|
return false;
|
|
return (from
|
|
entry in _repository.Index.RetrieveStatus()
|
|
where
|
|
entry.State != FileStatus.Ignored &&
|
|
entry.State != FileStatus.Untracked
|
|
select entry).Any();
|
|
}
|
|
}
|
|
|
|
public void CopyBlob(string sha, string outputFile)
|
|
{
|
|
Blob blob;
|
|
var destination = new FileInfo(outputFile);
|
|
if (!destination.Directory.Exists)
|
|
destination.Directory.Create();
|
|
if ((blob = _repository.Lookup<Blob>(sha)) != null)
|
|
using (Stream stream = blob.GetContentStream())
|
|
using (var outstream = File.Create(destination.FullName))
|
|
stream.CopyTo(outstream);
|
|
}
|
|
|
|
public string AssertValidBranchName(string gitBranchName)
|
|
{
|
|
if (!Reference.IsValidName(ShortToLocalName(gitBranchName)))
|
|
throw new GitTfsException("The name specified for the new git branch is not allowed. Choose another one!");
|
|
return gitBranchName;
|
|
}
|
|
|
|
public bool CreateBranch(string gitBranchName, string target)
|
|
{
|
|
Reference reference;
|
|
try
|
|
{
|
|
reference = _repository.Refs.Add(gitBranchName, target);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return false;
|
|
}
|
|
return reference != null;
|
|
}
|
|
|
|
private readonly Dictionary<long, string> changesetsCache = new Dictionary<long, string>();
|
|
private bool cacheIsFull = false;
|
|
|
|
public string FindCommitHashByChangesetId(long changesetId)
|
|
{
|
|
var commit = FindCommitByChangesetId(changesetId);
|
|
if (commit == null)
|
|
return null;
|
|
|
|
return commit.Sha;
|
|
}
|
|
|
|
private static readonly Regex tfsIdRegex = new Regex("^git-tfs-id: .*;C([0-9]+)\r?$", RegexOptions.Multiline | RegexOptions.Compiled | RegexOptions.RightToLeft);
|
|
|
|
public static bool TryParseChangesetId(string commitMessage, out long changesetId)
|
|
{
|
|
var match = tfsIdRegex.Match(commitMessage);
|
|
if (match.Success)
|
|
{
|
|
changesetId = long.Parse(match.Groups[1].Value);
|
|
return true;
|
|
}
|
|
|
|
changesetId = 0;
|
|
return false;
|
|
}
|
|
|
|
private Commit FindCommitByChangesetId(long changesetId, string remoteRef = null)
|
|
{
|
|
Trace.WriteLine("Looking for changeset " + changesetId + " in git repository...");
|
|
|
|
if (remoteRef == null)
|
|
{
|
|
string sha;
|
|
if (changesetsCache.TryGetValue(changesetId, out sha))
|
|
return _repository.Lookup<Commit>(sha);
|
|
if (cacheIsFull)
|
|
return null;
|
|
}
|
|
|
|
var reachableFromRemoteBranches = new CommitFilter
|
|
{
|
|
Since = _repository.Branches.Where(p => p.IsRemote),
|
|
SortBy = CommitSortStrategies.Time
|
|
};
|
|
|
|
if (remoteRef != null)
|
|
reachableFromRemoteBranches.Since = _repository.Branches.Where(p => p.IsRemote && p.CanonicalName.EndsWith(remoteRef));
|
|
var commitsFromRemoteBranches = _repository.Commits.QueryBy(reachableFromRemoteBranches);
|
|
|
|
Commit commit = null;
|
|
foreach (var c in commitsFromRemoteBranches)
|
|
{
|
|
long id;
|
|
if (TryParseChangesetId(c.Message, out id))
|
|
{
|
|
changesetsCache[id] = c.Sha;
|
|
if (id == changesetId)
|
|
{
|
|
commit = c;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (remoteRef == null && commit == null)
|
|
cacheIsFull = true; // repository fully scanned
|
|
Trace.WriteLine((commit == null) ? " => Commit not found!" : " => Commit found! hash: " + commit.Sha);
|
|
return commit;
|
|
}
|
|
|
|
public void CreateTag(string name, string sha, string comment, string Owner, string emailOwner, System.DateTime creationDate)
|
|
{
|
|
if (_repository.Tags[name] == null)
|
|
_repository.ApplyTag(name, sha, new Signature(Owner, emailOwner, new DateTimeOffset(creationDate)), comment);
|
|
}
|
|
|
|
public void CreateNote(string sha, string content, string owner, string emailOwner, DateTime creationDate)
|
|
{
|
|
Signature author = new Signature(owner, emailOwner, creationDate);
|
|
_repository.Notes.Add(new ObjectId(sha), content, author, author, "commits");
|
|
}
|
|
|
|
public void ResetHard(string sha)
|
|
{
|
|
_repository.Reset(ResetMode.Hard, sha);
|
|
}
|
|
|
|
public bool IsBare { get { return _repository.Info.IsBare; } }
|
|
|
|
/// <summary>
|
|
/// Gets all configured "subtree" remotes which point to the same Tfs URL as the given remote.
|
|
/// If the given remote is itself a subtree, an empty enumerable is returned.
|
|
/// </summary>
|
|
public IEnumerable<IGitTfsRemote> GetSubtrees(IGitTfsRemote owner)
|
|
{
|
|
//a subtree remote cannot have subtrees itself.
|
|
if (owner.IsSubtree)
|
|
return Enumerable.Empty<IGitTfsRemote>();
|
|
|
|
return ReadAllTfsRemotes().Where(x => x.IsSubtree && string.Equals(x.OwningRemoteId, owner.Id, StringComparison.InvariantCultureIgnoreCase));
|
|
}
|
|
|
|
public void ResetRemote(IGitTfsRemote remoteToReset, string target)
|
|
{
|
|
_repository.Refs.UpdateTarget(remoteToReset.RemoteRef, target);
|
|
}
|
|
|
|
public string GetCurrentBranch()
|
|
{
|
|
return _repository.Head.CanonicalName;
|
|
}
|
|
|
|
public void GarbageCollect(bool auto, string additionalMessage)
|
|
{
|
|
try
|
|
{
|
|
if (auto)
|
|
_globals.Repository.CommandNoisy("gc", "--auto");
|
|
else
|
|
_globals.Repository.CommandNoisy("gc");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Trace.WriteLine(e);
|
|
realStdout.WriteLine("Warning: `git gc` failed! " + additionalMessage);
|
|
}
|
|
}
|
|
|
|
public bool Checkout(string commitish)
|
|
{
|
|
try
|
|
{
|
|
_repository.Checkout(commitish);
|
|
return true;
|
|
}
|
|
catch (MergeConflictException ex)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|