public HaymanVertex(VertexId id, RevisionId revisionId)
{
_id = id;
_revisionId = revisionId;
_outEdges = new Dictionary<EdgeId, IGenericEdge<VertexId, RevisionId, HaymanVertexData, EdgeId, RevisionId, HaymanEdgeData, HyperEdgeId, RevisionId, HaymanEdgeData>>();
_inEdges = new Dictionary<EdgeId, IGenericEdge<VertexId, RevisionId, HaymanVertexData, EdgeId, RevisionId, HaymanEdgeData, HyperEdgeId, RevisionId, HaymanEdgeData>>();
}
public override RevisionRange[] GetAfterTillHead(RevisionId @from, int pageSize)
{
SvnRevisionId svnRevisionId = from;
svnRevisionId = svnRevisionId.Value + 1;
return(GetFromTillHead(svnRevisionId, pageSize));
}
private void SaveRevisionsRelation(int tpRevisionId, RevisionId revisionId)
{
_repository.Get <RevisionIdRelation>(tpRevisionId.ToString())
.ReplaceWith(new RevisionIdRelation {
RevisionId = revisionId.Value, TpId = tpRevisionId
});
}
public void Append(RevisionId revisionId, IEnumerable <RevisionFile> changedFiles)
{
foreach (var file in changedFiles)
{
Entry entry;
if (file.IsRenamed)
{
entry = FindRenamedEntry(revisionId, file);
if (entry != null)
{
entry.File = entry.File.WithNewName(file.File.NewPath);
}
else
{
entry = FindOrCreateEntry(file);
}
}
else
{
entry = FindOrCreateEntry(file);
}
entry.Revisions[revisionId] = Status.From(file);
}
}
public RevisionRange[] GetFromTillHead(RevisionId @from, int pageSize)
{
var currentRevision = from;
var lastRevision = long.Parse(Revisions.Last().Id.Value);
return(GetFromTo(currentRevision, lastRevision, pageSize));
}
public void Append(RevisionId revisionId, PathPair path, FileHistoryEntry historyEntry)
{
string fileId;
if (historyEntry.FileId != Guid.Empty)
{
fileId = historyEntry.FileId.ToString();
}
else
{
fileId = "PROV_" + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{path.OldPath}\0{path.NewPath}"));
}
var matrixEntry = Find(x => x.FileId == fileId);
if (matrixEntry == null)
{
matrixEntry = new Entry(_revisions)
{
FileId = fileId
};
Add(matrixEntry);
}
matrixEntry.Revisions[revisionId] = Status.From(path, historyEntry);
}
public Changeset GetCommit(RevisionId id)
{
var command = new LogCommand().WithRevision(RevSpec.ById(id.Value)).WithIncludePathActions();
var changeset = _repository.Log(command).FirstOrDefault(ch => ch.Hash == id.Value);
return(changeset);
}
public RevisionInfo[] GetRevisions(RevisionId fromChangeset, RevisionId toChangeset)
{
var revisionInfos = GetChangesets(changeset => changeset.ChangesetId >= int.Parse(fromChangeset.Value) && changeset.ChangesetId <= int.Parse(toChangeset.Value))
.Select(changeset => changeset.ToRevisionInfo())
.ToArray();
return(revisionInfos);
}
ReviewRevision ISessionAdapter.GetRevision(ReviewIdentifier reviewId, RevisionId revisionId)
{
Assert.That(revisionId, Is.InstanceOf <RevisionId.Selected>());
var s = (RevisionId.Selected)revisionId;
return(Revisions[s.Revision - 1]);
}
public FileRange(string fileId, PathPair reviewFile, PathPair diffFile, RevisionId previous, RevisionId current)
{
FileId = fileId;
DiffFile = diffFile;
Previous = previous;
Current = current;
ReviewFile = reviewFile;
}
private RevisionId GetToRevision(RevisionRange processedRevisionRange, RevisionId newToRevision)
{
if (RevisionComparer.Is(newToRevision).GreaterThan(processedRevisionRange.ToChangeset))
{
return(newToRevision);
}
return(processedRevisionRange.ToChangeset);
}
public void ShouldSupportMinTime()
{
TfsRevisionId revisionId = new RevisionId {
Time = DateTime.MinValue, Value = Guid.NewGuid().ToString()
};
revisionId.Time.Should(Be.EqualTo(TfsRevisionId.UtcTimeMin));
}
public override void CheckRevision(RevisionId revision, PluginProfileErrorCollection errors)
{
TfsRevisionId revisionId = revision;
if (Int32.Parse(revisionId.Value) <= 0 || Int32.Parse(revisionId.Value) > Int32.MaxValue)
{
_errorResolver.HandleConnectionError(new InvalidRevisionException(), errors);
}
}
public override void CheckRevision(RevisionId revision, PluginProfileErrorCollection errors)
{
MercurialRevisionId revisionId = revision;
if (revisionId.Time > MercurialRevisionId.UtcTimeMax)
{
_errorResolver.HandleConnectionError(new InvalidRevisionException(), errors);
}
}
public void ResolveTest(string revisionId, string expected)
{
var result = RevisionId.Parse(revisionId).Resolve(
resolveBase: () => "base",
resolveSelected: s => $"Selected {s.Revision}",
resolveHash: h => $"Hash {h.CommitHash}"
);
Assert.That(result, Is.EqualTo(expected));
}
private static long ConvertToRevision(RevisionId revision)
{
long revisionId;
if (!Int64.TryParse(revision.Value, out revisionId))
{
revisionId = 0;
}
return(revisionId);
}
public override void CheckRevision(RevisionId revision, PluginProfileErrorCollection errors)
{
try
{
GetRevisions(new RevisionRange(revision, revision));
}
catch (VersionControlException e)
{
_errorResolver.HandleConnectionError(e, errors);
}
}
private DiffResult GetDiff(RevisionId changeset, string path, string previousRevisionId)
{
var fileContent = GetTextFileContentSafe(changeset.Value, path);
var previousRevisionFileContent = GetTextFileContentSafe(previousRevisionId, path);
var diff = _diffProcessor.GetDiff(previousRevisionFileContent, fileContent);
diff.LeftPanRevisionId = previousRevisionId;
diff.RightPanRevisionId = changeset.Value;
return(diff);
}
private RevisionId GetFrom(RevisionId @from)
{
var startRevision = _revisionComparer.ConvertToRevisionId(_settings.StartRevision);
var missingRevisionsCheckInterval = @from.Time.Value.AddDays(-MissingRevisionsCheckInterval);
var toChangeset = startRevision.Time > missingRevisionsCheckInterval
? startRevision
: new RevisionId {
Time = missingRevisionsCheckInterval
};
return(toChangeset);
}
public RevisionInfo[] GetRevisions(RevisionId fromChangeset, RevisionId toChangeset)
{
var from = new RevSpec(fromChangeset.Value);
var to = new RevSpec(toChangeset.Value);
var command = new LogCommand().WithRevision(RevSpec.Range(from, to)).WithIncludePathActions();
var revisionInfos = _repository.Log(command)
.Where(ch => ch.Timestamp >= fromChangeset.Time.Value && ch.Timestamp <= toChangeset.Time.Value)
.Select(ch => ch.ToRevisionInfo())
.ToArray();
return(revisionInfos);
}
public void ShouldHandlePosixTime()
{
var initialTime = DateTime.Today.AddHours(6);
TfsRevisionId revisionId = new RevisionId {
Time = initialTime, Value = Guid.NewGuid().ToString()
};
RevisionId revisionIdDto = revisionId;
TfsRevisionId restoredRevisionId = revisionIdDto;
restoredRevisionId.Time.Should(Be.EqualTo(initialTime));
}
private RevisionId GetFromRevision(RevisionRange processedRevisionRange, RevisionId newFromRevision)
{
if (RevisionComparer.Is(StartRevision).LessThan(newFromRevision))
{
newFromRevision = StartRevision;
}
if (RevisionComparer.Is(newFromRevision).LessThan(processedRevisionRange.FromChangeset))
{
return(newFromRevision);
}
return(processedRevisionRange.FromChangeset);
}
public IEnumerable <RevisionRange> GetAfterTillHead(RevisionId revisionId, int pageSize)
{
var revSpec = new RevSpec(revisionId.Value);
var command = new LogCommand().WithRevision(RevSpec.From(revSpec) && !new RevSpec(revisionId.Value));
var pages = _repository.Log(command)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return(result);
}
public RevCommit GetCommit(RevisionId id)
{
var revWalk = CreateRevWalker();
try
{
return(revWalk.ParseCommit(ObjectId.FromString(id.Value)));
}
finally
{
revWalk.Dispose();
}
}
public override byte[] GetBinaryFileContent(RevisionId changeset, string path)
{
try
{
using (var stream = GetSVNFileStream(new SvnRevisionId(changeset), path))
{
return(stream.ToArray());
}
}
catch (SvnFileSystemException ex)
{
throw new VersionControlException(String.Format("Subversion exception: {0}", ex.Message));
}
}
public override DiffResult GetDiff(RevisionId changeset, string path)
{
var commit = _mercurial.GetCommit(changeset);
var parent = _mercurial.GetParentCommit(commit);
try
{
return(GetDiff(path, parent, commit));
}
catch (MercurialException ex)
{
throw new VersionControlException(String.Format("Mercurial exception: {0}", ex.Message));
}
}
public override DiffResult GetDiff(RevisionId changeset, string path)
{
var revisionId = new SvnRevisionId(changeset);
var previousRevisionId = ((revisionId).Value - 1).ToString();
try
{
return(GetDiff(changeset, path, previousRevisionId));
}
catch (SvnFileSystemException ex)
{
throw new VersionControlException(String.Format("Subversion exception: {0}", ex.Message));
}
}
public override DiffResult GetDiff(RevisionId changeset, string path)
{
var commit = _git.GetCommit(changeset);
var parent = _git.GetCommit(commit.GetParent(0).Id.Name);
try
{
return(GetDiff(path, parent, commit));
}
catch (GitAPIException ex)
{
throw new VersionControlException(String.Format("Git exception: {0}", ex.Message));
}
}
public override string GetTextFileContent(RevisionId changeset, string path)
{
try
{
using (var stream = GetSVNFileStream(changeset, path))
{
stream.Position = 0;
return(new StreamReader(stream).ReadToEnd());
}
}
catch (SvnFileSystemException ex)
{
throw new VersionControlException(String.Format("Subversion exception: {0}", ex.Message));
}
}
private bool FileWasDeleted(string path, SvnRevisionId changeset)
{
var revisionId = new RevisionId {
Value = changeset.Value.ToString()
};
var arg = new SvnLogArgs(CreateSvnRevisionRangeBy(new RevisionRange(revisionId, revisionId)))
{
BaseUri = new Uri(_root), ThrowOnError = true
};
var revisions = GetSvnRevisions(arg);
var item = revisions[0].ChangedPaths.FirstOrDefault(itemCollection => itemCollection.Path == path);
return(item != null && item.Action == SvnChangeAction.Delete);
}
public RevisionInfo[] GetRevisions(RevisionId fromChangeset, RevisionId toChangeset)
{
var revWalk = CreateRevWalker();
try
{
RevFilter betweenFilter = CommitTimeRevFilter.Between(((GitRevisionId)fromChangeset).Time,
((GitRevisionId)toChangeset).Time);
revWalk.SetRevFilter(ApplyNoMergesFilter(betweenFilter));
var commits = revWalk.ToArray();
return(commits.Select(commit => commit.ConvertToRevisionInfo(_git.GetRepository())).ToArray());
}
finally
{
revWalk.Dispose();
}
}
