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)
                });
            }
        }
Beispiel #2
0
        private async Task <FileMatrix> BuildMatrix(GetFileMatrix query)
        {
            var revisions = await _session.Query <ReviewRevision>()
                            .Where(x => x.ReviewId == query.ReviewId)
                            .FetchMany(x => x.Files)
                            .OrderBy(x => x.RevisionNumber)
                            .ToListAsync();

            var mergeRequest = await _api.GetMergeRequestInfo(query.ReviewId.ProjectId, query.ReviewId.ReviewId);

            var revisionIds = revisions.Select(x => (RevisionId) new RevisionId.Selected(x.RevisionNumber));

            var hasProvisional = !revisions.Any() || mergeRequest.HeadCommit != revisions.Last().HeadCommit;

            if (hasProvisional)
            {
                revisionIds = revisionIds.Union(new RevisionId.Hash(mergeRequest.HeadCommit));
            }

            var matrix = new FileMatrix(revisionIds);

            foreach (var revision in revisions)
            {
                matrix.Append(new RevisionId.Selected(revision.RevisionNumber), revision.Files);
            }

            if (hasProvisional)
            {
                var provisionalDiff = await _api.GetDiff(query.ReviewId.ProjectId, revisions.LastOrDefault()?.HeadCommit ?? mergeRequest.BaseCommit, mergeRequest.HeadCommit);

                var files = provisionalDiff.Select(RevisionFile.FromDiff);

                matrix.Append(new RevisionId.Hash(mergeRequest.HeadCommit), files);
            }

            matrix.FillUnchanged();
            return(matrix);
        }