public void Apply(ITfsChangeset changeset, string destinationRef)
{
var log = Apply(MaxCommitHash, changeset);
var commit = Commit(log);
Repository.UpdateRef(destinationRef, commit);
}
private string BuildCheckInComment(ITfsChangeset original, ITfsChangeset source)
{
string prefixText = "";
string sourceComment = source.Description;
if (CheckInCommentTemplate.Contains("{PrefixText}"))
{
int idx = sourceComment.IndexOf(':');
if (idx >= 0)
{
prefixText = sourceComment.Substring(0, idx + 1);
sourceComment = sourceComment.Substring(idx + 1).Trim();
}
}
return
(CheckInCommentTemplate
.Replace("{PrefixText}", prefixText)
.Replace("{OriginalId}", original.Changeset.ChangesetId.ToString())
.Replace("{OriginalDate}", original.Changeset.CreationDate.ToUniversalTime().ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss"))
.Replace("{OriginalComment}", original.Description)
.Replace("{SourceId}", source.Changeset.ChangesetId.ToString())
.Replace("{SourceDate}", source.Changeset.CreationDate.ToUniversalTime().ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss"))
.Replace("{SourceComment}", sourceComment)
.Replace("{SourceBranch}", MergeSource.Name)
.Replace("{TargetBranch}", MergeTarget.Name));
}
private void quickFetch(ITfsChangeset changeset)
{
var log = CopyTree(MaxCommitHash, changeset);
UpdateTfsHead(Commit(log), changeset.Summary.ChangesetId);
DoGcIfNeeded();
}
private bool ProcessMergeChangeset(ITfsChangeset changeset, bool stopOnFailMergeCommit, ref string parentCommit)
{
var parentChangesetId = Tfs.FindMergeChangesetParent(TfsRepositoryPath, changeset.Summary.ChangesetId, this);
var shaParent = Repository.FindCommitHashByChangesetId(parentChangesetId);
if (shaParent == null)
{
shaParent = FindMergedRemoteAndFetch(parentChangesetId, stopOnFailMergeCommit);
}
if (shaParent != null)
{
parentCommit = shaParent;
}
else
{
if (stopOnFailMergeCommit)
{
return(false);
}
//TODO : Manage case where there is not yet a git commit for the parent changset!!!!!
stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But it can't have been managed accordingly because one of the parent changeset "
+ parentChangesetId +
" is not present in the repository! If you want to do it, fetch the branch containing this changeset before retrying...");
}
return(true);
}
public void Apply(ITfsChangeset changeset, string destinationRef)
{
var log = Apply(MaxCommitHash, changeset);
var commit = Commit(log);
Repository.CommandNoisy("update-ref", destinationRef, commit);
}
private ITfsChangeset FindChangeset(ITfsChangeset source, ITfsBranch where)
{
if (source.GetAffectedBranchesForActiveProject().Contains(where))
{
return(source);
}
var foundLinks
= AllAssociatedChangesetsIncludingMerges.Where(link => link.Source != null && link.Source.TfsChangeset.Changeset.ChangesetId == source.Changeset.ChangesetId);
// This could be more optimized.
foreach (var foundLink in foundLinks)
{
if (foundLink.Target.TfsChangeset.GetAffectedBranchesForActiveProject().Contains(where))
{
return(foundLink.Target.TfsChangeset);
}
}
foreach (var foundLink in foundLinks)
{
var found = FindChangeset(foundLink.Target.TfsChangeset, where);
if (found != null)
{
return(found);
}
}
return(null);
}
public string BuildSingleModeMergeMessage(ITfsChangeset tfsChangeset, IBranch branch, string additionalText)
{
return(string.Format(
_singleModeMergeMessageFormat,
string.Format(_changesetNumberFormat, tfsChangeset.ChangesetNumber),
BuildBranchPartMessage(branch, additionalText),
tfsChangeset.Comment));
}
private void quickFetch(ITfsChangeset changeset)
{
AssertTemporaryIndexEmpty();
var log = CopyTree(MaxCommitHash, changeset);
UpdateRef(Commit(log), changeset.Summary.ChangesetId);
DoGcIfNeeded();
}
private bool ChangesetHasMixedContent(ITfsChangeset changeset)
{
return(changeset
.GetAllChanges()
.Any(change => change.Change.ChangeType.HasFlag(ChangeType.Merge))
&&
changeset
.GetAllChanges()
.Any(change => !change.Change.ChangeType.HasFlag(ChangeType.Merge)));
}
private bool ProcessMergeChangeset(ITfsChangeset changeset, bool stopOnFailMergeCommit, ref string parentCommit)
{
if (!Tfs.CanGetBranchInformation)
{
stdout.WriteLine("info: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But was not treated as is because this version of TFS can't manage branches...");
}
else if (!IsIgnoringBranches())
{
var parentChangesetId = Tfs.FindMergeChangesetParent(TfsRepositoryPath, changeset.Summary.ChangesetId, this);
if (parentChangesetId < 1) // Handle missing merge parent info
{
if (stopOnFailMergeCommit)
{
return(false);
}
stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId + " is a merge changeset. But git-tfs is unable to determine the parent changeset.");
return(true);
}
var shaParent = Repository.FindCommitHashByChangesetId(parentChangesetId);
if (shaParent == null)
{
string omittedParentBranch;
shaParent = FindMergedRemoteAndFetch(parentChangesetId, stopOnFailMergeCommit, out omittedParentBranch);
changeset.OmittedParentBranch = omittedParentBranch;
}
if (shaParent != null)
{
parentCommit = shaParent;
}
else
{
if (stopOnFailMergeCommit)
{
return(false);
}
stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But git-tfs failed to find and fetch the parent changeset "
+ parentChangesetId + ". Parent changeset will be ignored...");
}
}
else
{
stdout.WriteLine("info: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But was not treated as is because of your git setting...");
changeset.OmittedParentBranch = ";C" + changeset.Summary.ChangesetId;
}
return(true);
}
private string BuildCheckInComment(ITfsChangeset original, ITfsChangeset source)
{
return
(CheckInCommentTemplate
.Replace("{OriginalId}", original.Changeset.ChangesetId.ToString())
.Replace("{OriginalDate}", original.Changeset.CreationDate.ToUniversalTime().ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss"))
.Replace("{OriginalComment}", original.Description)
.Replace("{SourceId}", source.Changeset.ChangesetId.ToString())
.Replace("{SourceDate}", source.Changeset.CreationDate.ToUniversalTime().ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss"))
.Replace("{SourceComment}", source.Description)
.Replace("{SourceBranch}", MergeSource.Name)
.Replace("{TargetBranch}", MergeTarget.Name));
}
private LogEntry CopyTree(string lastCommit, ITfsChangeset changeset)
{
LogEntry result = null;
WithTemporaryIndex(() => Tfs.WithWorkspace(WorkingDirectory, this, changeset.Summary, workspace => {
GitIndexInfo.Do(Repository, index => result = changeset.CopyTree(index, workspace));
result.Tree = Repository.CommandOneline("write-tree");
}));
if (!String.IsNullOrEmpty(lastCommit))
{
result.CommitParents.Add(lastCommit);
}
return(result);
}
private LogEntry CopyTree(string lastCommit, ITfsChangeset changeset)
{
LogEntry result = null;
WithTemporaryIndex(
() => GitIndexInfo.Do(Repository, index => result = changeset.CopyTree(index)));
WithTemporaryIndex(
() => result.Tree = Repository.CommandOneline("write-tree"));
if (!String.IsNullOrEmpty(lastCommit))
{
result.CommitParents.Add(lastCommit);
}
return(result);
}
private LogEntry CopyTree(string lastCommit, ITfsChangeset changeset)
{
LogEntry result = null;
WithWorkspace(changeset.Summary, workspace => {
var treeBuilder = workspace.Remote.Repository.GetTreeBuilder(null);
result = changeset.CopyTree(treeBuilder, workspace);
result.Tree = treeBuilder.GetTree();
});
if (!String.IsNullOrEmpty(lastCommit))
{
result.CommitParents.Add(lastCommit);
}
return(result);
}
private LogEntry Apply(string parent, ITfsChangeset changeset)
{
LogEntry result = null;
WithTemporaryIndex(() => WithWorkspace(changeset.Summary, workspace =>
{
AssertTemporaryIndexClean(parent);
GitIndexInfo.Do(Repository, index => result = changeset.Apply(parent, index, workspace));
result.Tree = Repository.CommandOneline("write-tree");
}));
if (!String.IsNullOrEmpty(parent))
{
result.CommitParents.Add(parent);
}
return(result);
}
private LogEntry Apply(string parent, ITfsChangeset changeset, IDictionary <string, GitObject> entries, Action <Exception> ignorableErrorHandler)
{
LogEntry result = null;
WithWorkspace(changeset.Summary, workspace =>
{
var treeBuilder = workspace.Remote.Repository.GetTreeBuilder(parent);
result = changeset.Apply(parent, treeBuilder, workspace, entries, ignorableErrorHandler);
result.Tree = treeBuilder.GetTree();
});
if (!String.IsNullOrEmpty(parent))
{
result.CommitParents.Add(parent);
}
return(result);
}
/// <summary>
/// Gets the changesets which have resulted in the given changeset due
/// to a merge operation.
/// </summary>
/// <param name="changeset">The changeset.</param>
/// <param name="versionControlServer">The version control server.</param>
/// <returns>
/// A list of all changesets that have resulted into the given changeset.
/// </returns>
public IEnumerable <ITfsChangeset> GetMergeSourceChangesets(ITfsChangeset changeset)
{
VersionControlServer versionControlServer = Repository.Instance.TfsBridgeProvider.VersionControlServer;
// remember the already covered changeset id's
Dictionary <int, bool> alreadyCoveredChangesets = new Dictionary <int, bool>();
// initialize list of parent changesets
List <Changeset> parentChangesets = new List <Changeset>();
// go through each change inside the changeset
foreach (Change change in changeset.Changeset.Changes)
{
// query for the items' history
var queryResults = versionControlServer.QueryMergesExtended(
new ItemSpec(change.Item.ServerItem, RecursionType.Full),
new ChangesetVersionSpec(changeset.Changeset.ChangesetId),
null,
null);
// go through each changeset in the history
foreach (var result in queryResults)
{
// only if the target-change is the given changeset, we have a hit
if (result.TargetChangeset.ChangesetId == changeset.Changeset.ChangesetId)
{
// if that hit has already been processed elsewhere, then just skip it
if (!alreadyCoveredChangesets.ContainsKey(result.SourceChangeset.ChangesetId))
{
// otherwise add it
alreadyCoveredChangesets.Add(result.SourceChangeset.ChangesetId, true);
yield return(new TfsChangeset(versionControlServer.GetChangeset(result.SourceChangeset.ChangesetId)));
}
}
}
}
}
private LogEntry Apply(string parent, ITfsChangeset changeset, Action <Exception> ignorableErrorHandler)
{
return(Apply(parent, changeset, BuildEntryDictionary(), ignorableErrorHandler));
}
private LogEntry Apply(string parent, ITfsChangeset changeset, IDictionary <string, GitObject> entries)
{
return(Apply(parent, changeset, entries, null));
}
private string ProcessChangeset(ITfsChangeset changeset, LogEntry log)
{
if (ExportMetadatas)
{
if (changeset.Summary.Workitems.Any())
{
var workItemIds = TranslateWorkItems(changeset.Summary.Workitems.Select(wi => wi.Id.ToString()));
if (workItemIds != null)
{
log.Log += "\nwork-items: " + string.Join(", ", workItemIds.Select(s => "#" + s));
}
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
{
log.Log += "\n" + GitTfsConstants.GitTfsPolicyOverrideCommentPrefix + changeset.Summary.PolicyOverrideComment;
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.CodeReviewer))
{
log.Log += "\n" + GitTfsConstants.GitTfsCodeReviewerPrefix + changeset.Summary.CodeReviewer;
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.SecurityReviewer))
{
log.Log += "\n" + GitTfsConstants.GitTfsSecurityReviewerPrefix + changeset.Summary.SecurityReviewer;
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PerformanceReviewer))
{
log.Log += "\n" + GitTfsConstants.GitTfsPerformanceReviewerPrefix + changeset.Summary.PerformanceReviewer;
}
}
var commitSha = Commit(log);
UpdateTfsHead(commitSha, changeset.Summary.ChangesetId);
StringBuilder metadatas = new StringBuilder();
if (changeset.Summary.Workitems.Any())
{
string workitemNote = "Workitems:\n";
foreach (var workitem in changeset.Summary.Workitems)
{
var workitemId = workitem.Id.ToString();
var workitemUrl = workitem.Url;
if (ExportMetadatas && ExportWorkitemsMapping.Count != 0)
{
if (ExportWorkitemsMapping.ContainsKey(workitemId))
{
var oldWorkitemId = workitemId;
workitemId = ExportWorkitemsMapping[workitemId];
workitemUrl = workitemUrl.Replace(oldWorkitemId, workitemId);
}
}
workitemNote += String.Format("[{0}] {1}\n {2}\n", workitemId, workitem.Title, workitemUrl);
}
metadatas.Append(workitemNote);
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
{
metadatas.Append("\nPolicy Override Comment:" + changeset.Summary.PolicyOverrideComment);
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.CodeReviewer))
{
metadatas.Append("\nCode Reviewer:" + changeset.Summary.CodeReviewer);
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.SecurityReviewer))
{
metadatas.Append("\nSecurity Reviewer:" + changeset.Summary.SecurityReviewer);
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PerformanceReviewer))
{
metadatas.Append("\nPerformance Reviewer:" + changeset.Summary.PerformanceReviewer);
}
if (!string.IsNullOrWhiteSpace(changeset.OmittedParentBranch))
{
metadatas.Append("\nOmitted parent branch: " + changeset.OmittedParentBranch);
}
if (metadatas.Length != 0)
{
Repository.CreateNote(commitSha, metadatas.ToString(), log.AuthorName, log.AuthorEmail, log.Date);
}
return(commitSha);
}
private string ProcessChangeset(ITfsChangeset changeset, LogEntry log)
{
if (ExportMetadatas)
{
if (changeset.Summary.Workitems.Any())
{
var workItems = TranslateWorkItems(changeset.Summary.Workitems.Select(wi => new ExportWorkItem(wi)));
if (workItems != null)
{
log.Log += "\nWorkitems:";
foreach (var workItem in workItems)
{
log.Log += "\n#" + workItem.Id + " " + workItem.Title;
}
}
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
{
log.Log += "\n" + GitTfsConstants.GitTfsPolicyOverrideCommentPrefix + " " + changeset.Summary.PolicyOverrideComment;
}
foreach (var checkinNote in changeset.Summary.CheckinNotes)
{
if (!string.IsNullOrWhiteSpace(checkinNote.Name) && !string.IsNullOrWhiteSpace(checkinNote.Value))
{
log.Log += "\n" + GitTfsConstants.GitTfsPrefix + "-" + CamelCaseToDelimitedStringConverter.Convert(checkinNote.Name, "-") + ": " + checkinNote.Value;
}
}
}
var commitSha = Commit(log);
UpdateTfsHead(commitSha, changeset.Summary.ChangesetId);
StringBuilder metadatas = new StringBuilder();
if (changeset.Summary.Workitems.Any())
{
string workitemNote = "Workitems:\n";
foreach (var workitem in changeset.Summary.Workitems)
{
var workitemId = workitem.Id.ToString();
var workitemUrl = workitem.Url;
if (ExportMetadatas && ExportWorkitemsMapping.Count != 0)
{
if (ExportWorkitemsMapping.ContainsKey(workitemId))
{
var oldWorkitemId = workitemId;
workitemId = ExportWorkitemsMapping[workitemId].Id;
workitemUrl = workitemUrl.Replace(oldWorkitemId, workitemId);
}
}
workitemNote += string.Format("[{0}] {1}\n {2}\n", workitemId, workitem.Title, workitemUrl);
}
metadatas.Append(workitemNote);
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
{
metadatas.Append("\nPolicy Override Comment: " + changeset.Summary.PolicyOverrideComment);
}
foreach (var checkinNote in changeset.Summary.CheckinNotes)
{
if (!string.IsNullOrWhiteSpace(checkinNote.Name) && !string.IsNullOrWhiteSpace(checkinNote.Value))
{
metadatas.Append("\n" + checkinNote.Name + ": " + checkinNote.Value);
}
}
if (!string.IsNullOrWhiteSpace(changeset.OmittedParentBranch))
{
metadatas.Append("\nOmitted parent branch: " + changeset.OmittedParentBranch);
}
if (metadatas.Length != 0)
{
Repository.CreateNote(commitSha, metadatas.ToString(), log.AuthorName, log.AuthorEmail, log.Date);
}
return(commitSha);
}
private LogEntry CopyTree(string lastCommit, ITfsChangeset changeset)
{
LogEntry result = null;
WithTemporaryIndex(() => Tfs.WithWorkspace(WorkingDirectory, this, changeset.Summary, workspace => {
GitIndexInfo.Do(Repository, index => result = changeset.CopyTree(index, workspace));
result.Tree = Repository.CommandOneline("write-tree");
}));
if (!String.IsNullOrEmpty(lastCommit)) result.CommitParents.Add(lastCommit);
return result;
}
private LogEntry Apply(string parent, ITfsChangeset changeset)
{
LogEntry result = null;
WithTemporaryIndex(() => WithWorkspace(changeset.Summary, workspace =>
{
AssertTemporaryIndexClean(parent);
GitIndexInfo.Do(Repository, index => result = changeset.Apply(parent, index, workspace));
result.Tree = Repository.CommandOneline("write-tree");
}));
if (!String.IsNullOrEmpty(parent)) result.CommitParents.Add(parent);
return result;
}
private bool ProcessMergeChangeset(ITfsChangeset changeset, bool stopOnFailMergeCommit, ref string parentCommit)
{
var parentChangesetId = Tfs.FindMergeChangesetParent(TfsRepositoryPath, changeset.Summary.ChangesetId, this);
var shaParent = Repository.FindCommitHashByChangesetId(parentChangesetId);
if (shaParent == null)
shaParent = FindMergedRemoteAndFetch(parentChangesetId, stopOnFailMergeCommit);
if (shaParent != null)
{
parentCommit = shaParent;
}
else
{
if (stopOnFailMergeCommit)
{
return false;
}
//TODO : Manage case where there is not yet a git commit for the parent changset!!!!!
stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But it can't have been managed accordingly because one of the parent changeset "
+ parentChangesetId +
" is not present in the repository! If you want to do it, fetch the branch containing this changeset before retrying...");
}
return true;
}
private LogEntry Apply(string parent, ITfsChangeset changeset, Action<Exception> ignorableErrorHandler)
{
return Apply(parent, changeset, BuildEntryDictionary(), ignorableErrorHandler);
}
private void quickFetch(ITfsChangeset changeset)
{
var log = CopyTree(MaxCommitHash, changeset);
UpdateTfsHead(Commit(log), changeset.Summary.ChangesetId);
DoGcIfNeeded();
}
public TfsChangesetWrapper(ITfsChangeset source)
: base(typeof(TfsChangesetWrapper))
{
_tfsChangeset = source;
}
private LogEntry CopyTree(string lastCommit, ITfsChangeset changeset)
{
LogEntry result = null;
WithTemporaryIndex(
() => GitIndexInfo.Do(Repository, index => result = changeset.CopyTree(index)));
WithTemporaryIndex(
() => result.Tree = Repository.CommandOneline("write-tree"));
if (!String.IsNullOrEmpty(lastCommit)) result.CommitParents.Add(lastCommit);
return result;
}
private bool ProcessMergeChangeset(ITfsChangeset changeset, bool stopOnFailMergeCommit, ref string parentCommit)
{
if (!Tfs.CanGetBranchInformation)
{
stdout.WriteLine("info: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But was not treated as is because this version of TFS can't manage branches...");
}
else if (!IsIgnoringBranches())
{
var parentChangesetId = Tfs.FindMergeChangesetParent(TfsRepositoryPath, changeset.Summary.ChangesetId, this);
if (parentChangesetId < 1) // Handle missing merge parent info
{
if (stopOnFailMergeCommit)
{
return false;
}
stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But git-tfs is unable to determine the parent changeset.");
return true;
}
var shaParent = Repository.FindCommitHashByChangesetId(parentChangesetId);
if (shaParent == null)
{
string omittedParentBranch;
shaParent = FindMergedRemoteAndFetch(parentChangesetId, stopOnFailMergeCommit, out omittedParentBranch);
changeset.OmittedParentBranch = omittedParentBranch;
}
if (shaParent != null)
{
parentCommit = shaParent;
}
else
{
if (stopOnFailMergeCommit)
return false;
stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But git-tfs failed to find and fetch the parent changeset "
+ parentChangesetId + ". Parent changeset will be ignored...");
}
}
else
{
stdout.WriteLine("info: this changeset " + changeset.Summary.ChangesetId +
" is a merge changeset. But was not treated as is because of your git setting...");
changeset.OmittedParentBranch = ";C" + changeset.Summary.ChangesetId;
}
return true;
}
private LogEntry CopyTree(string lastCommit, ITfsChangeset changeset)
{
LogEntry result = null;
WithWorkspace(changeset.Summary, workspace => {
var treeBuilder = workspace.Remote.Repository.GetTreeBuilder(null);
result = changeset.CopyTree(treeBuilder, workspace);
result.Tree = treeBuilder.GetTree();
});
if (!String.IsNullOrEmpty(lastCommit)) result.CommitParents.Add(lastCommit);
return result;
}
private void FindMergesForChangesetAndBranch(List <MergedChangesetLink> results, ITfsChangeset changeset, ITfsBranch rootBranch)
{
var merges
= changeset.FindMergesForActiveProject(rootBranch, _potentialMergeSourceBranches)
.Select(
item => new MergedChangesetLink()
{
Source = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(item.Source)),
Target = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(item.Target))
});
results.Add(
new MergedChangesetLink()
{
Source = null,
Target = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(changeset))
});
results.AddRange(merges);
}
private LogEntry Apply(string parent, ITfsChangeset changeset)
{
IDictionary<string, GitObject> entries = new Dictionary<string, GitObject>(StringComparer.InvariantCultureIgnoreCase);
return Apply(parent, changeset, entries);
}
private string CommitChangeset(ITfsChangeset changeset, string parent)
{
var log = Apply(parent, changeset);
return Commit(log);
}
private LogEntry Apply(string parent, ITfsChangeset changeset, IDictionary<string, GitObject> entries)
{
return Apply(parent, changeset, entries, null);
}
private string CommitChangeset(ITfsChangeset changeset, string parent)
{
var log = Apply(parent, changeset);
return(Commit(log));
}
private LogEntry Apply(string parent, ITfsChangeset changeset, IDictionary<string, GitObject> entries, Action<Exception> ignorableErrorHandler)
{
LogEntry result = null;
WithWorkspace(changeset.Summary, workspace =>
{
var treeBuilder = workspace.Remote.Repository.GetTreeBuilder(parent);
result = changeset.Apply(parent, treeBuilder, workspace, entries, ignorableErrorHandler);
result.Tree = treeBuilder.GetTree();
});
if (!String.IsNullOrEmpty(parent)) result.CommitParents.Add(parent);
return result;
}
private LogEntry Apply(string parent, ITfsChangeset changeset)
{
IDictionary <string, GitObject> entries = new Dictionary <string, GitObject>(StringComparer.InvariantCultureIgnoreCase);
return(Apply(parent, changeset, entries));
}
private string ProcessChangeset(ITfsChangeset changeset, LogEntry log)
{
if (ExportMetadatas)
{
if (changeset.Summary.Workitems.Any()) {
var workItemIds = TranslateWorkItems(changeset.Summary.Workitems.Select(wi => wi.Id.ToString()));
if (workItemIds != null) {
log.Log += "\nwork-items: " + string.Join(", ", workItemIds.Select(s => "#" + s));
}
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
log.Log += "\n" + GitTfsConstants.GitTfsPolicyOverrideCommentPrefix + changeset.Summary.PolicyOverrideComment;
if (!string.IsNullOrWhiteSpace(changeset.Summary.CodeReviewer))
log.Log += "\n" + GitTfsConstants.GitTfsCodeReviewerPrefix + changeset.Summary.CodeReviewer;
if (!string.IsNullOrWhiteSpace(changeset.Summary.SecurityReviewer))
log.Log += "\n" + GitTfsConstants.GitTfsSecurityReviewerPrefix + changeset.Summary.SecurityReviewer;
if (!string.IsNullOrWhiteSpace(changeset.Summary.PerformanceReviewer))
log.Log += "\n" + GitTfsConstants.GitTfsPerformanceReviewerPrefix + changeset.Summary.PerformanceReviewer;
}
var commitSha = Commit(log);
UpdateTfsHead(commitSha, changeset.Summary.ChangesetId);
StringBuilder metadatas = new StringBuilder();
if (changeset.Summary.Workitems.Any())
{
string workitemNote = "Workitems:\n";
foreach (var workitem in changeset.Summary.Workitems)
{
var workitemId = workitem.Id.ToString();
var workitemUrl = workitem.Url;
if (ExportMetadatas && ExportWorkitemsMapping.Count != 0)
{
if (ExportWorkitemsMapping.ContainsKey(workitemId))
{
var oldWorkitemId = workitemId;
workitemId = ExportWorkitemsMapping[workitemId];
workitemUrl = workitemUrl.Replace(oldWorkitemId, workitemId);
}
}
workitemNote += String.Format("[{0}] {1}\n {2}\n", workitemId, workitem.Title, workitemUrl);
}
metadatas.Append(workitemNote);
}
if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
metadatas.Append("\nPolicy Override Comment:" + changeset.Summary.PolicyOverrideComment);
if (!string.IsNullOrWhiteSpace(changeset.Summary.CodeReviewer))
metadatas.Append("\nCode Reviewer:" + changeset.Summary.CodeReviewer);
if (!string.IsNullOrWhiteSpace(changeset.Summary.SecurityReviewer))
metadatas.Append("\nSecurity Reviewer:" + changeset.Summary.SecurityReviewer);
if (!string.IsNullOrWhiteSpace(changeset.Summary.PerformanceReviewer))
metadatas.Append("\nPerformance Reviewer:" + changeset.Summary.PerformanceReviewer);
if (!string.IsNullOrWhiteSpace(changeset.OmittedParentBranch))
metadatas.Append("\nOmitted parent branch: " + changeset.OmittedParentBranch);
if (metadatas.Length != 0)
Repository.CreateNote(commitSha, metadatas.ToString(), log.AuthorName, log.AuthorEmail, log.Date);
return commitSha;
}
private bool ChangesetConsistsOnlyOfMerges(ITfsChangeset changeset)
{
return(changeset
.GetAllChanges()
.All(change => change.Change.ChangeType.HasFlag(ChangeType.Merge)));
}
public void Apply(ITfsChangeset changeset, string destinationRef)
{
var log = Apply(MaxCommitHash, changeset);
var commit = Commit(log);
Repository.CommandNoisy("update-ref", destinationRef, commit);
}
private bool ChangesetDoesNotContainMerges(ITfsChangeset changeset)
{
return(changeset
.GetAllChanges()
.Any(change => !change.Change.ChangeType.HasFlag(ChangeType.Merge)));
}
private void quickFetch(ITfsChangeset changeset)
{
AssertTemporaryIndexEmpty();
var log = CopyTree(MaxCommitHash, changeset);
UpdateRef(Commit(log), changeset.Summary.ChangesetId);
DoGcIfNeeded();
}
public void Apply(ITfsChangeset changeset, string destinationRef)
{
var log = Apply(MaxCommitHash, changeset);
var commit = Commit(log);
Repository.UpdateRef(destinationRef, commit);
}
