public async Task MakeReviewBasedOnProvisionalAfterRevisionHasBeenSaved(string oldFileName, string newFileName)
{
var commits1 = Commits(Head1);
_repository.SetupDiff(commits1.Base, commits1.Head,
Modified("file1"),
Modified("file2"),
Modified("file3"),
Modified("file4")
);
var file1 = PathPair.Make(oldFileName, newFileName);
await Handle(commits1, _reviewer1,
MakeReviewDiscussion(Head1, 1),
MakeFileDiscussion(Head1, file1, 1),
ReviewedFiles(Head1, file1)
);
await Handle(commits1, _reviewer2,
MakeReviewDiscussion(Head1, 1),
MakeFileDiscussion(Head1, file1, 1),
ReviewedFiles(Head1, "file2")
);
Assert.That(_sessionAdapter.Revisions, Has.Count.EqualTo(1));
Assert.That(_sessionAdapter.Reviews, HasReviewFor(_reviewer1, _sessionAdapter.Revisions[0]));
Assert.That(_sessionAdapter.Reviews, HasReviewFor(_reviewer2, _sessionAdapter.Revisions[0]));
Assert.That(_sessionAdapter.FilesInRevision(1), Is.EquivalentTo(new[] { "file1", "file2", "file3", "file4" }));
Assert.That(_sessionAdapter.ReviewedFiles(_reviewer1, 1), Is.EquivalentTo(new[] { "file1" }));
Assert.That(_sessionAdapter.ReviewedFiles(_reviewer2, 1), Is.EquivalentTo(new[] { "file2" }));
}
private void cmdOk_Click(object sender, EventArgs e)
{
if (lvPaths.Items.Count == 0 && !string.IsNullOrEmpty(txtSource.Text) && !string.IsNullOrEmpty(txtDestination.Text))
{
var result = MessageBox.Show($"Would you like to add the following paths to the list of paths to compare?\r\r\r\n{txtSource.Text}\r\n{txtDestination.Text}", "InZync - Paths", MessageBoxButtons.YesNoCancel);
if (result == DialogResult.Yes)
{
cmdAdd_Click(sender, e);
} else if (result == DialogResult.Cancel)
{
DialogResult = DialogResult.None;
return;
}
}
// copy items from ListView to ArrayList
pathList.Clear();
foreach (ListViewItem lvi in lvPaths.Items)
{
PathPair pp = new PathPair();
pp.Source = lvi.SubItems[0].Text;
if (!pp.Source.EndsWith("\\") && (pp.Source != ""))
{
pp.Source += "\\";
}
pp.Destination = lvi.SubItems[1].Text;
if (!pp.Destination.EndsWith("\\") && (pp.Destination != ""))
{
pp.Destination += "\\";
}
pathList.Add(pp);
}
DialogResult = DialogResult.OK;
}
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 static Status From(PathPair path, FileHistoryEntry historyEntry) => new Status
{
File = path,
IsNew = historyEntry.IsNew,
IsRenamed = historyEntry.IsRenamed,
IsDeleted = historyEntry.IsDeleted,
IsUnchanged = !historyEntry.IsModified,
};
public static Status Unchanged(PathPair file) => new Status
{
File = PathPair.Make(file.NewPath),
IsDeleted = false,
IsNew = false,
IsRenamed = false,
IsUnchanged = true
};
public FileRange(string fileId, PathPair reviewFile, PathPair diffFile, RevisionId previous, RevisionId current)
{
FileId = fileId;
DiffFile = diffFile;
Previous = previous;
Current = current;
ReviewFile = reviewFile;
}
public void WriteProvisionalIdOnlyNew()
{
var clientFileId = ClientFileId.Provisional(PathPair.Make("path"));
var text = ClientFileId.Write(clientFileId);
Assert.That(text, Is.EqualTo("PROV_cGF0aABwYXRo"));
}
public void WriteProvisionalIdOldAndNew()
{
var clientFileId = ClientFileId.Provisional(PathPair.Make("path1", "path2"));
var text = ClientFileId.Write(clientFileId);
Assert.That(text, Is.EqualTo("PROV_cGF0aDEAcGF0aDI="));
}
public void TMP_FillFullRangeFilePath()
{
foreach (var entry in this)
{
var oldPath = entry.Revisions.First().Value.File.OldPath;
var newPath = entry.Revisions.Last().Value.File.NewPath;
entry.File = PathPair.Make(oldPath, newPath);
}
}
public static ClientFileId Parse(string s)
{
if (s.StartsWith("PROV_"))
{
var bytes = Convert.FromBase64String(s.Substring(5));
var decoded = Encoding.UTF8.GetString(bytes);
var parts = decoded.Split('\0', 2);
return(ClientFileId.Provisional(PathPair.Make(parts[0], parts[1])));
}
else
{
return(ClientFileId.Persistent(Guid.Parse(s)));
}
}
public static IEnumerable <FileRange> FindFilesToReview(this FileMatrix matrix, string reviewerUserName)
{
foreach (var entry in matrix)
{
var(lastChangedIndex, lastChanged) = entry.Revisions.LastWithIndex(x => !x.Value.IsUnchanged);
var lastReviewed = entry.Revisions
.Take(lastChangedIndex + 1)
.Select(x => x.WrapAsNullable())
.Reverse()
.SkipWhile(x => !x.Value.Value.Reviewers.Contains(reviewerUserName))
.FirstOrDefault();
PathPair fileToReview;
RevisionId previousRevision;
IEnumerable <KeyValuePair <RevisionId, FileMatrix.Status> > reviewedRange;
var currentRevision = lastChanged.Key;
if (!lastReviewed.HasValue)
{
fileToReview = entry.Revisions.First().Value.File.WithNewName(lastChanged.Value.File.NewPath);
previousRevision = new RevisionId.Base();
reviewedRange = entry.Revisions.Take(lastChangedIndex + 1);
}
else
{
fileToReview = PathPair.Make(lastReviewed.Value.Value.File.NewPath, lastChanged.Value.File.NewPath);
previousRevision = lastReviewed.Value.Key;
var lastIndex = entry.Revisions.Keys.IndexOf(lastReviewed.Value.Key);
reviewedRange = entry.Revisions.Skip(lastIndex + 1).Take(lastChangedIndex - lastIndex + 1);
}
yield return(new FileRange(entry.FileId, entry.File, fileToReview, previousRevision, currentRevision)
{
ChangeType = DetermineChangeType(reviewedRange)
});
}
}
public async Task Publish(NewFileDiscussion[] discussions, Dictionary <string, Guid> newCommentsMap, Dictionary <string, Guid> newDiscussionsMap)
{
foreach (var discussion in discussions)
{
var commentId = GuidComb.Generate();
var discussionId = GuidComb.Generate();
newCommentsMap[discussion.TemporaryId] = commentId;
newDiscussionsMap[discussion.TemporaryId] = discussionId;
var review = _reviewForRevision(discussion.TargetRevisionId);
var resolvedFileId = _resolveFileId(discussion.FileId);
var currentRevision = _sessionAdapter.GetRevision(review.RevisionId);
var prevRevision = _sessionAdapter.GetPreviousRevision(currentRevision);
var currentEntry = _sessionAdapter.GetFileHistoryEntry(resolvedFileId, currentRevision);
var prevEntry = _sessionAdapter.GetFileHistoryEntry(resolvedFileId, prevRevision);
_sessionAdapter.Save(new FileDiscussion
{
RevisionId = review.RevisionId,
Id = discussionId,
FileId = resolvedFileId,
File = PathPair.Make(prevEntry?.FileName ?? currentEntry.FileName, currentEntry.FileName),
LineNumber = discussion.LineNumber,
State = discussion.State.AsCommentState(),
RootComment = new Comment
{
Id = commentId,
PostedInReviewId = review.Id,
Content = discussion.Content,
CreatedAt = DateTimeOffset.UtcNow
}
});
}
}
public ExternalFile NextFile()
{
//Sanity check
if (m_files == null || m_files.Count == 0)
{
return(null);
}
//Prepare external file
PathPair curpath = (PathPair)m_files[0];
ExternalFile file = new ExternalFile();
FileStream data = new FileStream(curpath.AbsolutePath, FileMode.Open);
file.DataStream = data;
file.Directory = false;
file.Path = curpath.RelativePath;
file.Size = (int)data.Length;
//Pop off a file
m_files.RemoveAt(0);
return(file);
}
public WatcherItem(PathPair file, WatcherItemType type)
{
m_type = type;
m_sFullPathFileName = file.m_sFull_FileName;
m_sParsedFileName = file.m_sMatch_FileName;
if (type == WatcherItemType.Added)
fileInfo = new FileInfo(file.m_sFull_FileName);
LogMyFilms.Debug("File monitor: " + m_sParsedFileName + " " + m_type);
}
public WatcherItem(PathPair file, WatcherItemType type)
{
m_type = type;
m_sFullPathFileName = file.m_sFull_FileName;
m_sParsedFileName = file.m_sMatch_FileName;
if (type == WatcherItemType.Added)
fileInfo = new FileInfo(file.m_sFull_FileName);
MPTVSeriesLog.Write("File monitor: " + m_sParsedFileName + " " + m_type);
}
private async Task <FileMatrix> BuildMatrix(GetFileMatrix query)
{
var revisions = await _session.Query <ReviewRevision>()
.Where(x => x.ReviewId == query.ReviewId)
.OrderBy(x => x.RevisionNumber)
.ToListAsync();
var revisionIds = revisions.Select(x => (RevisionId) new RevisionId.Selected(x.RevisionNumber));
var mergeRequest = await _api.GetMergeRequestInfo(query.ReviewId.ProjectId, query.ReviewId.ReviewId);
var hasProvisional = !revisions.Any() || mergeRequest.HeadCommit != revisions.Last().HeadCommit;
if (hasProvisional)
{
revisionIds = revisionIds.Union(new RevisionId.Hash(mergeRequest.HeadCommit));
}
var fileHistoryEntries = await _session.Query <FileHistoryEntry>()
.Where(x => x.ReviewId == query.ReviewId)
.GroupBy(x => x.FileId)
.ToListAsync();
var provisionalDiff = new List <FileDiff>();
if (hasProvisional)
{
provisionalDiff = await _api.GetDiff(query.ReviewId.ProjectId, revisions.LastOrDefault()?.HeadCommit ?? mergeRequest.BaseCommit, mergeRequest.HeadCommit);
if (_features.For("dont-show-excesive-files-from-rebases").IsActive)
{
if (revisions.Any() && revisions.Last().HeadCommit != mergeRequest.HeadCommit)
{
provisionalDiff = (await RelevantFilesFilter.Filter(provisionalDiff, fileHistoryEntries, query.ReviewId, mergeRequest.BaseCommit, mergeRequest.HeadCommit, _api)).ToList();
}
}
}
var remainingDiffs = new HashSet <FileDiff>(provisionalDiff);
var matrix = new FileMatrix(revisionIds);
var revisionsMap = revisions.ToDictionary(x => (Guid?)x.Id);
foreach (var(fileId, history) in fileHistoryEntries)
{
var sortedHistory = history
.OrderBy(x => x.RevisionId.HasValue ? revisionsMap[x.RevisionId].RevisionNumber : int.MinValue);
FileHistoryEntry previousEntry = null;
foreach (var entry in sortedHistory)
{
if (entry.RevisionId == null)
{
previousEntry = entry;
continue;
}
var rev = revisionsMap[entry.RevisionId];
string oldPath = previousEntry?.FileName ?? entry.FileName;
var path = PathPair.Make(oldPath, entry.FileName);
matrix.Append(new RevisionId.Selected(rev.RevisionNumber), path, entry);
previousEntry = entry;
}
if (hasProvisional)
{
var diff = remainingDiffs.SingleOrDefault(x => x.Path.OldPath == previousEntry.FileName);
remainingDiffs.Remove(diff);
if (diff != null)
{
matrix.Append(new RevisionId.Hash(mergeRequest.HeadCommit), diff.Path, new FileHistoryEntry
{
FileId = fileId,
FileName = diff.Path.NewPath,
IsNew = diff.NewFile,
IsDeleted = diff.DeletedFile,
IsModified = true,
IsRenamed = diff.RenamedFile
});
}
}
}
foreach (var diff in remainingDiffs)
{
matrix.Append(new RevisionId.Hash(mergeRequest.HeadCommit), diff.Path, new FileHistoryEntry
{
FileId = Guid.Empty,
FileName = diff.Path.NewPath,
IsNew = diff.NewFile,
IsDeleted = diff.DeletedFile,
IsModified = true,
IsRenamed = diff.RenamedFile
});
}
matrix.TMP_FillFullRangeFilePath();
matrix.FillUnchanged();
matrix.Sort(DelegateComparer.For((FileMatrix.Entry e) => e.File.NewPath));
return(matrix);
}
public FileReview(PathPair file, Guid fileId)
{
File = file;
FileId = fileId;
}
public static ClientFileId Provisional(PathPair path) => new ClientFileId
{
PersistentId = Guid.Empty, ProvisionalPathPair = path
};
