public string GetDiffedFile()
{
var stringBuilder = new StringBuilder();
var differ = new Differ();
var inlineDiffBuilder = new InlineDiffBuilder(differ);
var result = inlineDiffBuilder.BuildDiffModel(oldText, newText);
foreach (var line in result.Lines)
{
if (line.Type == ChangeType.Inserted)
{
stringBuilder.Append("+ ");
}
else if (line.Type == ChangeType.Deleted)
{
stringBuilder.Append("- ");
}
else if (line.Type == ChangeType.Modified)
{
stringBuilder.Append("* ");
}
else if (line.Type == ChangeType.Imaginary)
{
stringBuilder.Append("? ");
}
else if (line.Type == ChangeType.Unchanged)
{
stringBuilder.Append(" ");
}
stringBuilder.Append(line.Text + "\r\n");
}
return(stringBuilder.ToString());
}
private static void Diff(string expected, string actual, string message = null)
{
var d = new Differ();
var inlineBuilder = new InlineDiffBuilder(d);
var result = inlineBuilder.BuildDiffModel(expected, actual);
var hasChanges = result.Lines.Any(l => l.Type != ChangeType.Unchanged);
if (!hasChanges)
{
return;
}
var diff = result.Lines.Aggregate(new StringBuilder().AppendLine(message), (sb, line) =>
{
if (line.Type == ChangeType.Inserted)
{
sb.Append("+ ");
}
else if (line.Type == ChangeType.Deleted)
{
sb.Append("- ");
}
else
{
sb.Append(" ");
}
sb.AppendLine(line.Text);
return(sb);
}, sb => sb.ToString());
throw new Exception(diff);
}
// https://github.com/mmanela/diffplex#sample-code
public static void ToConsole(string before, string after)
{
var diff = InlineDiffBuilder.Diff(before, after);
var savedColor = Console.ForegroundColor;
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("+ ");
break;
case ChangeType.Deleted:
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("- ");
break;
default:
Console.ForegroundColor = ConsoleColor.Gray; // compromise for dark or light background
Console.Write(" ");
break;
}
Console.WriteLine(line.Text);
}
Console.ForegroundColor = savedColor;
}
private static void Main()
{
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(OldText, NewText);
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("+ ");
break;
case ChangeType.Deleted:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("- ");
break;
default:
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" ");
break;
}
Console.WriteLine(line.Text);
}
Console.ReadKey();
}
private static string CreateDiff(string expected, string actual, string message, Differ d)
{
var inlineBuilder = new InlineDiffBuilder(d);
var result = inlineBuilder.BuildDiffModel(expected, actual);
var hasChanges = result.Lines.Any(l => l.Type != ChangeType.Unchanged);
if (!hasChanges)
{
return(string.Empty);
}
return(result.Lines.Aggregate(new StringBuilder().AppendLine(message), (sb, line) =>
{
if (line.Type == ChangeType.Inserted)
{
sb.Append("+ ");
}
else if (line.Type == ChangeType.Deleted)
{
sb.Append("- ");
}
else
{
sb.Append(" ");
}
sb.AppendLine(line.Text);
return sb;
}, sb => sb.ToString()));
}
// Copied from https://github.com/VerifyTests/Verify.DiffPlex/blob/master/src/Verify.DiffPlex/VerifyDiffPlex.cs
public static Task <CompareResult> OnlyIncludeChanges(string received, string verified, IReadOnlyDictionary <string, object> _)
{
var diff = InlineDiffBuilder.Diff(verified, received);
var builder = new StringBuilder();
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
builder.Append("+ ");
break;
case ChangeType.Deleted:
builder.Append("- ");
break;
default:
// omit unchanged files
continue;
}
builder.AppendLine(line.Text);
}
var compareResult = CompareResult.NotEqual(builder.ToString());
return(Task.FromResult(compareResult));
}
static void Main(string[] args)
{
var compilerinvocations1 = CompilerInvocationsReader.ReadInvocations(args[0])
.ToDictionary(x => x.ProjectFilePath);
var compilerinvocations2 = CompilerInvocationsReader.ReadInvocations(args[1])
.ToDictionary(x => x.ProjectFilePath);
var projectsInSecondButNotFirst = new List <string>();
foreach (var(projectPath, compilerInvocation2) in compilerinvocations2)
{
if (!compilerinvocations1.TryGetValue(projectPath, out var compilerInvocation1))
{
projectsInSecondButNotFirst.Add(projectPath);
continue;
}
var before = string.Join('\n', compilerInvocation1.CommandLineArguments.Split(' ').OrderByDescending(x => x));
var after = string.Join('\n', compilerInvocation2.CommandLineArguments.Split(' ').OrderByDescending(x => x));;
var diff = InlineDiffBuilder.Diff(before, after);
PrintDiff(diff);
}
if (projectsInSecondButNotFirst.Any())
{
Console.WriteLine("Projects in second build but not in the first: ");
Console.WriteLine(string.Join('\n', projectsInSecondButNotFirst));
}
}
public bool Commit2(string newContent)
{
//var mc = new FlowMicroCommit();
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(FullContent, newContent);
Form1.D3.Clear();
string log3 = "";
string log2 = "";
foreach (var dl in diff.Lines)
{
switch (dl.Type)
{
case ChangeType.Unchanged:
{
log2 += "[ ] " + dl.Text + "\r\n";
break;
}
case ChangeType.Deleted: break;
case ChangeType.Modified:
{
log2 += "[m] " + dl.Text + "\r\n";
break;
}
case ChangeType.Inserted:
{
log2 += "[i] " + dl.Text + "\r\n";
break;
}
case ChangeType.Imaginary:
{
log2 += "[g] " + dl.Text + "\r\n";
break;
}
}
//var mc = new FlowMicroCommit();
//mc.N = LastN++;
//mc.P = dl.Position.Value;
//mc.C = dl.Text;
log3 += string.Format("{0}| {1}, \"{2}\"\r\n", dl.Type, dl.Position, dl.Text);
//dl.Type
}
Form1.D2.Text = log2;
Form1.D3.Text = log3;
LastN++;
FullContent = newContent;
return(false);
}
public static string Compare(string oldText, string newText)
{
StringBuilder sb = new StringBuilder();
var d = new Differ();
var builder = new InlineDiffBuilder(d);
var result = builder.BuildDiffModel(oldText, newText);
foreach (var line in result.Lines)
{
if (line.Type == ChangeType.Inserted)
{
sb.Append("+ ");
}
else if (line.Type == ChangeType.Deleted)
{
sb.Append("- ");
}
else if (line.Type == ChangeType.Modified)
{
sb.Append("* ");
}
else if (line.Type == ChangeType.Imaginary)
{
sb.Append("? ");
}
//else if (line.Type == ChangeType.Unchanged)
//{
// sb.Append(" ");
//}
sb.Append(line.Text + "<br/>");
}
return(sb.ToString());
}
public static void Initialize()
{
VerifierSettings.SetDefaultStringComparer((received, verified, _) =>
{
var diff = InlineDiffBuilder.Diff(verified, received);
var builder = new StringBuilder();
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
builder.Append("+ ");
break;
case ChangeType.Deleted:
builder.Append("- ");
break;
default:
builder.Append(" ");
break;
}
builder.AppendLine(line.Text);
}
var compareResult = CompareResult.NotEqual(builder.ToString());
return(Task.FromResult(compareResult));
});
}
public DiffRenderer(string oldText, string newText, int maxContextLines = 3, int tabWidth = 8)
{
this.maxContextLines = maxContextLines;
var inlineBuilder = new InlineDiffBuilder(new Differ());
var diff = inlineBuilder.BuildDiffModel(oldText, newText);
int maxLineNumber = 0;
DiffPieceGroup currentGroup = null;
foreach (var line in diff.Lines)
{
if (currentGroup == null || currentGroup.Type != line.Type)
{
currentGroup = new DiffPieceGroup(currentGroup, line.Type);
if (FirstGroup == null)
{
FirstGroup = currentGroup;
}
}
if (line.Position != null)
{
maxLineNumber = Math.Max(maxLineNumber, line.Position.Value);
}
maxLineWidth = Math.Max(maxLineWidth, GetLineWidth(line.Text, tabWidth));
currentGroup.Lines.Add(line);
}
maxLineNumberDigits = (int)Math.Floor(Math.Log10(maxLineNumber) + 1);
}
public void Will_build_diffModel_for_duplicate_strings()
{
string text = "a\nb\nc\nd\n\n";
string[] textLines = { "a", "b", "c", "d", "" };
var differ = new Mock <IDiffer>();
differ.Setup(x => x.CreateLineDiffs(text, text, true))
.Returns(new DiffResult(textLines, textLines, new List <DiffBlock>()
{
new DiffBlock(0, 0, 5, 0)
}));
var builder = new InlineDiffBuilder(differ.Object);
var bidiff = builder.BuildDiffModel(text, text);
Assert.NotNull(bidiff);
Assert.Equal(textLines.Length, bidiff.Lines.Count);
for (int i = 0; i < textLines.Length; i++)
{
Assert.Equal(textLines[i], bidiff.Lines[i].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.Lines[i].Type);
Assert.Equal(i + 1, bidiff.Lines[i].Position);
}
}
private void DiffButton_Click(object sender, RoutedEventArgs e)
{
if (SideBySideDiff.Visibility == Visibility.Visible)
{
SideBySideDiff.Visibility = Visibility.Collapsed;
InlineDiff.Visibility = Visibility.Visible;
if (inline == null)
{
var builder = new InlineDiffBuilder(new Differ());
inline = builder.BuildDiffModel(TestData.DuplicateText(TestData.OldText, 50), TestData.DuplicateText(TestData.NewText, 50));
}
InlineDiff.DiffModel = inline;
return;
}
InlineDiff.Visibility = Visibility.Collapsed;
SideBySideDiff.Visibility = Visibility.Visible;
if (sideBySide == null)
{
var builder = new SideBySideDiffBuilder(new Differ());
sideBySide = builder.BuildDiffModel(TestData.DuplicateText(TestData.OldText, 50), TestData.DuplicateText(TestData.NewText, 50));
}
SideBySideDiff.DiffModel = sideBySide;
}
public static DiffPiece[] DiffAndShow(string before, string after)
{
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(before, after);
var oldColor = Console.ForegroundColor;
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("+ ");
break;
case ChangeType.Deleted:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("- ");
break;
default:
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" ");
break;
}
Console.WriteLine(line.Text);
}
Console.ForegroundColor = oldColor;
return(diff.Lines.Where(line => line.Type != ChangeType.Unchanged).ToArray());
}
private static void Main(string[] args)
{
OldText = CorrectWordnewLine(CorrectInLine(CorrectSpace(OldText)));
NewText = CorrectWordnewLine(CorrectInLine(CorrectSpace(NewText)));
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(OldText, NewText);
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
FinalText += " {" + line.Text + "}";
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("+ ");
break;
case ChangeType.Deleted:
FinalText += " <" + line.Text + ">";
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("- ");
break;
default:
FinalText += " " + line.Text;
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" ");
break;
}
Console.WriteLine(line.Text);
}
Console.WriteLine(CorrectSpace(FinalText).Replace("} {", " ").Replace("> <", " ").Replace("<>", "").Replace("{}", ""));
Console.ReadKey();
}
public static Task Report(string receivedFile, string verifiedFile, string?message)
{
#if (!DEBUG)
var receivedText = File.ReadAllText(receivedFile);
var verifiedText = File.ReadAllText(verifiedFile);
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(verifiedText, receivedText);
foreach (var line in diff.Lines)
{
if (line.Type == ChangeType.Unchanged)
{
continue;
}
var prefix = " ";
switch (line.Type)
{
case ChangeType.Inserted:
prefix = "+ ";
break;
case ChangeType.Deleted:
prefix = "- ";
break;
}
Console.WriteLine("{0}{1}", prefix, line.Text);
}
#endif
return(Task.CompletedTask);
}
public void Will_build_diffModel_when_oldText_is_empty()
{
string textOld = "";
string textNew = "z\ny\nx\nw\n";
string[] textLinesOld = { };
string[] textLinesNew = { "z", "y" };
var differ = new Mock <IDiffer>();
differ.Setup(x => x.CreateLineDiffs(textOld, textNew, true))
.Returns(new DiffResult(textLinesOld, textLinesNew, new List <DiffBlock> {
new DiffBlock(0, 0, 0, 2)
}));
var builder = new InlineDiffBuilder(differ.Object);
var bidiff = builder.BuildDiffModel(textOld, textNew);
Assert.NotNull(bidiff);
Assert.Equal(2, bidiff.Lines.Count);
for (int j = 0; j < textLinesNew.Length; j++)
{
Assert.Equal(textLinesNew[j], bidiff.Lines[j].Text);
Assert.Equal(ChangeType.Inserted, bidiff.Lines[j].Type);
Assert.Equal(j + 1, bidiff.Lines[j].Position);
}
}
public void Will_build_diffModel_when_newText_is_empty()
{
string textNew = "";
string textOld = "z\ny\nx\nw\n";
string[] textLinesNew = { };
string[] textLinesOld = { "z", "y" };
var differ = new Mock <IDiffer>();
differ.Setup(x => x.CreateDiffs(textOld, textNew, true, false, It.IsNotNull <IChunker>()))
.Returns(new DiffResult(textLinesOld, textLinesNew, new List <DiffBlock> {
new DiffBlock(0, 2, 0, 0)
}));
var builder = new InlineDiffBuilder(differ.Object);
var bidiff = builder.BuildDiffModel(textOld, textNew);
Assert.NotNull(bidiff);
Assert.Equal(2, bidiff.Lines.Count);
for (int j = 0; j < textLinesOld.Length; j++)
{
Assert.Equal(textLinesOld[j], bidiff.Lines[j].Text);
Assert.Equal(ChangeType.Deleted, bidiff.Lines[j].Type);
Assert.Null(bidiff.Lines[j].Position);
}
Assert.True(bidiff.HasDifferences);
}
private static DiffPaneModel GetDiff(string oldText, string newText)
{
var differ = new Differ();
var inlineBuilder = new InlineDiffBuilder(differ);
return(inlineBuilder.BuildDiffModel(oldText, newText));
}
public void Report(string approved, string received)
{
var approvedText = File.Exists(approved) ? File.ReadAllText(approved) : string.Empty;
var receivedText = File.ReadAllText(received);
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(approvedText, receivedText);
foreach (var line in diff.Lines)
{
if (line.Type == ChangeType.Unchanged)
{
continue;
}
var prefix = " ";
switch (line.Type)
{
case ChangeType.Inserted:
prefix = "+ ";
break;
case ChangeType.Deleted:
prefix = "- ";
break;
}
Output.WriteLine("{0}{1}", prefix, line.Text);
}
}
private async Task <Boolean> getUrlChanges(Link link, Boolean enableOverwrite)
{
using (HttpClient client = new HttpClient()) {
using (HttpResponseMessage response = await client.GetAsync(link.Url, HttpCompletionOption.ResponseHeadersRead)) {
Boolean shouldAdd = false;
if (System.IO.File.Exists(link.PathToFile))
{
shouldAdd = true;
string newText = await response.Content.ReadAsStringAsync();
string oldText = await System.IO.File.ReadAllTextAsync(link.PathToFile);
var d = new Differ();
var builder = new InlineDiffBuilder(d);
var result = builder.BuildDiffModel(oldText, newText);
foreach (var line in result.Lines)
{
if (line.Type == ChangeType.Inserted)
{
additions.Add(line.Text);
}
}
}
else
{
using (Stream streamToWriteTo = System.IO.File.Open(link.PathToFile, FileMode.Create))
{
Stream webStream = await response.Content.ReadAsStreamAsync();
await webStream.CopyToAsync(streamToWriteTo);
}
}
if (enableOverwrite)
{
using (Stream streamToWriteTo = System.IO.File.Open(link.PathToFile, FileMode.Create))
{
Stream webStream = await response.Content.ReadAsStreamAsync();
await webStream.CopyToAsync(streamToWriteTo);
}
}
List <string> res = new List <string>();
if (shouldAdd)
{
foreach (var addition in additions)
{
res.Add(addition);
}
}
changesPerUrl.Add(link.Url, res);
additions.Clear();
}
}
return(true);
}
public static void Diff(this string expected, string actual, string message = null)
{
var d = new Differ();
var inlineBuilder = new InlineDiffBuilder(d);
var result = inlineBuilder.BuildDiffModel(expected, actual);
var hasChanges = result.Lines.Any(l => l.Type != ChangeType.Unchanged);
if (!hasChanges)
{
return;
}
var diff = result.Lines.Aggregate(new StringBuilder().AppendLine(message), (sb, line) =>
{
if (line.Type == ChangeType.Inserted)
{
sb.Append("+ ");
}
else if (line.Type == ChangeType.Deleted)
{
sb.Append("- ");
}
else
{
sb.Append(" ");
}
sb.AppendLine(line.Text);
return(sb);
}, sb => sb.ToString());
diff += "\r\n C# approximation of actual ------ ";
diff += "\r\n new ";
var approx = Regex.Replace(actual, @"^(?=.*:.*)[^:]+:", (s) => s
.Value.Replace("\"", "")
.Replace(":", " =")
, RegexOptions.Multiline)
.Replace(" = {", " = new {")
.Replace(" = [", " = new [] {")
;
approx = Regex.Replace(approx, @"^\s*\],?.*$", s => s.Value.Replace("]", "}"), RegexOptions.Multiline);
diff += approx + ";";
diff += "\r\n C# approximation of expected ------ ";
diff += "\r\n new ";
approx = Regex.Replace(expected, @"^(?=.*:.*)[^:]+:", (s) => s
.Value.Replace("\"", "")
.Replace(":", " =")
, RegexOptions.Multiline)
.Replace(" = {", " = new {")
.Replace(" = [", " = new [] {")
;
approx = Regex.Replace(approx, @"^\s*\],?.*$", s => s.Value.Replace("]", "}"), RegexOptions.Multiline);
diff += approx + ";";
throw new Exception(diff.Substring(0, diff.Length > 4896 ? 4896 : diff.Length));
}
/// <summary>
/// Insert line, mark with "++++"
/// delete line, mark with "----"
/// </summary>
/// <param name="oldFileFullPath"></param>
/// <param name="newFileFullPath"></param>
/// <param name="diffMessage"></param>
/// <returns></returns>
private static bool CompareFiles(string oldFileFullPath, string newFileFullPath, out string diffMessage)
{
StringBuilder diffSb = new StringBuilder();
var diffBuilder = new InlineDiffBuilder(new Differ());
string oldText = File.ReadAllText(oldFileFullPath);
string newText = File.ReadAllText(newFileFullPath);
var diff = diffBuilder.BuildDiffModel(oldText, newText);
int lineCount = 1;
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
if (line.Position.HasValue)
{
diffSb.AppendLine(string.Format("Line:{0} ++++", line.Position));
}
else
{
diffSb.AppendLine("++++");
}
diffSb.AppendLine(line.Text);
break;
case ChangeType.Deleted:
if (line.Position.HasValue)
{
diffSb.AppendLine(string.Format("Line:{0} ----", line.Position));
}
else
{
diffSb.AppendLine("----");
}
diffSb.AppendLine(line.Text);
break;
default:
break;
}
lineCount++;
}
diffMessage = diffSb.ToString();
if (string.IsNullOrEmpty(diffMessage))
{
return(true);
}
else
{
return(false);
}
}
public string GetDiff(SiteResponse currentResponse, SiteResponse lastResponse)
{
string currentResponseText = SiteHtmlUtil.StripHTMLAdvanced(currentResponse.Contents);
string lastResponseText = "";
if (lastResponse != null)
{
lastResponseText = SiteHtmlUtil.StripHTMLAdvanced(lastResponse.Contents);
}
StringBuilder stringBuilder = new StringBuilder();
Differ differ = new Differ();
InlineDiffBuilder inlineDiffBuilder = new InlineDiffBuilder(differ);
var result = inlineDiffBuilder.BuildDiffModel(lastResponseText, currentResponseText);
bool added_anchor_to_first_change = false;
foreach (var line in result.Lines)
{
if (line.Type == ChangeType.Inserted)
{
if (!added_anchor_to_first_change)
{
stringBuilder.Append("<p class='added'><a name='anchor'>+</a> ");
added_anchor_to_first_change = true;
}
else
{
stringBuilder.Append("<p class='added'>+ ");
}
stringBuilder.AppendLine(line.Text);
stringBuilder.Append("</p>");
}
else if (line.Type == ChangeType.Deleted)
{
if (!added_anchor_to_first_change)
{
stringBuilder.Append("<p class='removed'><a name='anchor'>-</a> ");
added_anchor_to_first_change = true;
}
else
{
stringBuilder.Append("<p class='removed'>- ");
}
stringBuilder.AppendLine(line.Text);
stringBuilder.Append("</p>");
}
else
{
stringBuilder.Append("<p class='notchanged'>");
stringBuilder.AppendLine(line.Text);
stringBuilder.Append("</p>");
}
//stringBuilder.Append("<br/>");
}
return(stringBuilder.ToString());
}
public void Will_build_diffModel_for_multiple_diff_blocks()
{
string textOld = "1\n2\na\nb\nc\nd\ne\f\n";
string textNew = "1\n2\nz\ny\nc\nw\ne\f\n";
string[] textLinesOld = { "1", "2", "a", "b", "c", "d", "e", "f" };
string[] textLinesNew = { "1", "2", "z", "y", "c", "w", "e", "f" };
var differ = new Mock <IDiffer>();
differ.Setup(x => x.CreateDiffs(textOld, textNew, true, false, It.IsNotNull <IChunker>()))
.Returns(new DiffResult(textLinesOld, textLinesNew, new List <DiffBlock> {
new DiffBlock(2, 2, 2, 2), new DiffBlock(5, 1, 5, 1)
}));
var builder = new InlineDiffBuilder(differ.Object);
var bidiff = builder.BuildDiffModel(textOld, textNew);
Assert.NotNull(bidiff);
Assert.Equal(11, bidiff.Lines.Count);
Assert.Equal("1", bidiff.Lines[0].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.Lines[0].Type);
Assert.Equal(1, bidiff.Lines[0].Position);
Assert.Equal("2", bidiff.Lines[1].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.Lines[1].Type);
Assert.Equal(2, bidiff.Lines[1].Position);
Assert.Equal("a", bidiff.Lines[2].Text);
Assert.Equal(ChangeType.Deleted, bidiff.Lines[2].Type);
Assert.Null(bidiff.Lines[2].Position);
Assert.Equal("b", bidiff.Lines[3].Text);
Assert.Equal(ChangeType.Deleted, bidiff.Lines[3].Type);
Assert.Null(bidiff.Lines[3].Position);
Assert.Equal("z", bidiff.Lines[4].Text);
Assert.Equal(ChangeType.Inserted, bidiff.Lines[4].Type);
Assert.Equal(3, bidiff.Lines[4].Position);
Assert.Equal("y", bidiff.Lines[5].Text);
Assert.Equal(ChangeType.Inserted, bidiff.Lines[5].Type);
Assert.Equal(4, bidiff.Lines[5].Position);
Assert.Equal("c", bidiff.Lines[6].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.Lines[6].Type);
Assert.Equal(5, bidiff.Lines[6].Position);
Assert.Equal("d", bidiff.Lines[7].Text);
Assert.Equal(ChangeType.Deleted, bidiff.Lines[7].Type);
Assert.Null(bidiff.Lines[7].Position);
Assert.Equal("w", bidiff.Lines[8].Text);
Assert.Equal(ChangeType.Inserted, bidiff.Lines[8].Type);
Assert.Equal(6, bidiff.Lines[8].Position);
Assert.Equal("e", bidiff.Lines[9].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.Lines[9].Type);
Assert.Equal(7, bidiff.Lines[9].Position);
Assert.Equal("f", bidiff.Lines[10].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.Lines[10].Type);
Assert.Equal(8, bidiff.Lines[10].Position);
Assert.True(bidiff.HasDifferences);
}
public static string GenerateDiff(string oldText, string newText, out bool hasDifferences)
{
DiffPaneModel result = new InlineDiffBuilder(new Differ()).BuildDiffModel(oldText, newText);
hasDifferences = result.HasDifferences;
StringBuilder output = new StringBuilder(oldText.Length + newText.Length);
foreach (var line in result.Lines)
{
string lineRaw = line.Text;
output.Append(line.Type switch { ChangeType.Inserted => '+', ChangeType.Deleted => '-', ChangeType.Imaginary => '@', ChangeType.Modified => '+', ChangeType.Unchanged => ' ', _ => ' ' });
public static void EqualJson <T>(T expected, T actual, string?description = null)
{
var options = new JsonSerializerOptions()
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
WriteIndented = true,
};
options.Converters.Add(BytesReadOnlyMemoryConverter.Default);
var expectedJsonString = JsonSerializer.Serialize(expected, options);
var actualJsonString = JsonSerializer.Serialize(actual, options);
if (expectedJsonString == actualJsonString)
{
return;
}
var diff = InlineDiffBuilder.Diff(expectedJsonString, actualJsonString);
var savedColor = Console.ForegroundColor;
try
{
foreach (var line in diff.Lines)
{
switch (line.Type)
{
case ChangeType.Inserted:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("+ ");
break;
case ChangeType.Deleted:
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("- ");
break;
default:
Console.ForegroundColor = ConsoleColor.Gray; // compromise for dark or light background
Console.Write(" ");
break;
}
Console.WriteLine(line.Text);
}
}
finally
{
Console.ForegroundColor = savedColor;
}
throw new AssertException($"EqualJson Error: {description}");
}
public static void DownloadPage(Uri uri, ExtractResult result, ExtractBlock block, PageDownloadHandler handler, int maxRetry = 10)
{
handler(uri, result);
var pages = new Dictionary <string, ExtractResult>();
pages.Add(uri.ToString(), result);
var lines = String.Join("\n", result.Paging.Distinct());
var reader = new StringReader(lines);
var crawler = new RuiJiCrawler();
var url = reader.ReadLine();
var diffBuilder = new InlineDiffBuilder(new Differ());
while (!string.IsNullOrEmpty(url))
{
var u = new Uri(uri, url);
if (pages.ContainsKey(u.ToString()))
{
url = reader.ReadLine();
continue;
}
var request = new Request(u);
var response = crawler.Request(request);
var content = response.Data.ToString();
var r = RuiJiExtractor.Extract(content, block);
if (r.Paging == null || r.Paging.Count == 0)
{
Thread.Sleep(5000);
if (--maxRetry == 0)
{
break;
}
continue;
}
pages.Add(u.ToString(), r);
handler(u, r);
var nlines = String.Join("\n", r.Paging.Distinct());
var diff = diffBuilder.BuildDiffModel(lines, nlines);
nlines = string.Join("\n", diff.Lines.Select(m => m.Text));
reader = new StringReader(nlines);
url = reader.ReadLine();
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var diffBuilder = new InlineDiffBuilder(new Differ());
var before = "The text without changes\nThe text without changes\nThe text without changes\n";
var after = "The text without changes\nThe text with change. A little one\nThe text without changes\n";
var diff = diffBuilder.BuildDiffModel(before, after);
_ = diff;
}
public static DiffResult Diff([CanBeNull] this string actual, [CanBeNull] string expected)
{
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(expected, actual);
if (diff.Lines.All(p => p.Type == ChangeType.Unchanged))
{
return(DiffResult.Equivalent);
}
return(new DiffResult(diff.Lines));
}
