public void BuildDiffViewWithMargin(FileSet set)
{
var basePatch = FourWayDiff.MakePatch(set.Previous, set.Previous);
var classifiedPatches = FourWayDiff.ClassifyPatches(
set.Previous, basePatch,
set.Current, set.ReviewPatch
);
var currentLines = LineList.SplitLines(set.Current);
var previousLines = LineList.SplitLines(set.Previous);
DiffView.AssignPatchesToLines(classifiedPatches, currentLines, previousLines);
List <Line> cleared = new List <Line>();
DiffView.RemoveDiffsFromIdenticalLines(currentLines, previousLines, cleared);
Console.WriteLine("Cleared:");
foreach (var line in cleared)
{
Console.WriteLine(line);
}
DumpLines(currentLines, previousLines);
var hunks = DiffView.BuildHunks(currentLines, previousLines, true).ToList();
Assert.That(hunks, Has.Count.EqualTo(set.ExpectedPatchesWithMargin.Count), "Proper number of hunks generated");
AssertHunks(hunks, previousLines, currentLines, set.ExpectedPatchesWithMargin);
}
public async Task <Result> Execute(GetFileDiff query)
{
var previousCommit = query.Hashes.PreviousHead;
var currentCommit = query.Hashes.CurrentHead;
var previousBaseCommit = query.Hashes.PreviousBase;
var currentBaseCommit = query.Hashes.CurrentBase;
var contents = (await new[]
{
new { Commit = previousCommit, Path = query.OldPath },
new { Commit = currentCommit, Path = query.NewPath },
new { Commit = previousBaseCommit, Path = query.OldPath },
new { Commit = currentBaseCommit, Path = query.OldPath }
}
.DistinctBy(x => x.Commit)
.Select(async c => new
{
File = c,
Content = (await _api.GetFileContent(query.ReviewId.ProjectId, c.Commit, c.Path)).DecodeString()
})
.WhenAll())
.ToDictionary(x => x.File.Commit, x => x.Content);
if (contents[previousCommit] == "" && query.OldPath != query.NewPath)
{
contents[previousCommit] =
(await _api.GetFileContent(query.ReviewId.ProjectId, previousCommit, query.NewPath)).DecodeString();
}
foreach (var content in contents)
{
if (IsBinaryFile(content.Value))
{
return(HandleBinaryFile(contents[previousCommit], contents[currentCommit], previousBaseCommit, currentBaseCommit, previousCommit, currentCommit));
}
}
var basePatch = FourWayDiff.MakePatch(contents[previousBaseCommit], contents[currentBaseCommit]);
var reviewPatch = FourWayDiff.MakePatch(contents[previousCommit], contents[currentCommit]);
var classifiedPatches = FourWayDiff.ClassifyPatches(
contents[currentBaseCommit], basePatch,
contents[currentCommit], reviewPatch
);
var previousLines = LineList.SplitLines(contents[previousCommit]);
var currentLines = LineList.SplitLines(contents[currentCommit]);
DiffView.AssignPatchesToLines(classifiedPatches, currentLines, previousLines);
List <Line> cleared = new List <Line>();
DiffView.RemoveDiffsFromIdenticalLines(currentLines, previousLines, cleared);
HunkInfo MakeHunkInfo(DiffView.HunkInfo hunk)
{
var lines = new List <LineInfo>();
foreach (var(previous, current) in hunk.Lines)
{
if (previous != null && current != null)
{
lines.Add(new LineInfo
{
Text = previous.Text,
Classification = previous.Classification.ToString(),
Operation = previous.Diff?.Operation.ToString() ?? "Equal"
});
continue;
}
if (previous != null)
{
lines.Add(new LineInfo
{
Text = previous.Text,
Classification = previous.Classification.ToString(),
Operation = previous.Diff?.Operation.ToString() ?? "Equal"
});
}
if (current != null)
{
lines.Add(new LineInfo
{
Text = current.Text,
Classification = current.Classification.ToString(),
Operation = current.Diff?.Operation.ToString() ?? "Equal"
});
}
}
return(new HunkInfo
{
OldPosition = new PatchPosition
{
Start = hunk.StartPrevious,
End = hunk.EndPrevious,
Length = hunk.LengthPrevious
},
NewPosition = new PatchPosition
{
Start = hunk.StartCurrent,
End = hunk.EndCurrent,
Length = hunk.LengthCurrent
},
Lines = lines
});
}
var baseHunks = DiffView.BuildHunks(currentLines, previousLines, true);
var hunks = baseHunks.Select(MakeHunkInfo).ToList();
return(new Result
{
Commits = new ReviewDebugInfo
{
Review = new RevisionDebugInfo
{
Previous = previousCommit,
Current = currentCommit
},
Base = new RevisionDebugInfo
{
Previous = previousBaseCommit,
Current = currentBaseCommit
}
},
Contents = new ReviewDebugInfo
{
Review = new RevisionDebugInfo
{
Previous = contents[previousCommit],
PreviousTotalLines = previousLines.Count,
Current = contents[currentCommit],
CurrentTotalLines = currentLines.Count
},
Base = new RevisionDebugInfo
{
Previous = contents[previousBaseCommit],
Current = contents[currentBaseCommit]
}
},
Hunks = hunks
});
}
public void DiffViewIsCorrect(FileSet set)
{
var basePatch = FourWayDiff.MakePatch(set.Previous, set.Previous);
var classifiedPatches = FourWayDiff.ClassifyPatches(
set.Previous, basePatch,
set.Current, set.ReviewPatch
);
var currentLines = LineList.SplitLines(set.Current);
var previousLines = LineList.SplitLines(set.Previous);
DiffView.AssignPatchesToLines(classifiedPatches, currentLines, previousLines);
List <Line> cleared = new List <Line>();
DiffView.RemoveDiffsFromIdenticalLines(currentLines, previousLines, cleared);
DumpLines(currentLines, previousLines);
var previousIndex = 0;
var currentIndex = 0;
while (previousIndex < previousLines.Count && currentIndex < currentLines.Count)
{
void NextPrevious()
{
if (previousIndex < previousLines.Count)
{
previousIndex++;
}
}
void NextCurrent()
{
if (currentIndex < currentLines.Count)
{
currentIndex++;
}
}
var previousLine = previousLines[previousIndex];
var currentLine = currentLines[currentIndex];
if (!previousLine.IsNoChange)
{
NextPrevious();
}
if (!currentLine.IsNoChange)
{
NextCurrent();
}
if (previousLine.IsNoChange && currentLine.IsNoChange)
{
Assert.That(previousLine.Text, Is.EqualTo(currentLine.Text), () =>
{
return($"Equal lines does not have the same text\nPrevious: {previousIndex,5} {previousLine}\nCurrent: {currentIndex,5} {currentLine}");
});
NextPrevious();
NextCurrent();
}
}
}