private void UpdateDiffListOnCompareResultRecieved(CompareResult compareResult)
{
Diffs.Clear();
foreach (var file in compareResult.Files)
{
Diffs.Add(new CommitFileVm(file));
var commitFile = Diffs.Last();
_backgroundTaskRunner.AddToQueue(async() => await FetchDiffContent(new CommitFile(commitFile.GitHubCommitFile)));
}
}
/// <summary>
/// Increase the context until it is unique,
/// but don't let the pattern expand beyond Match_MaxBits.</summary>
/// <param name="text">Source text</param>
/// <param name="patchMargin"></param>
internal void AddContext(string text, short patchMargin = 4)
{
if (text.Length == 0)
{
return;
}
var pattern = text.Substring(Start2, Length1);
var padding = 0;
// Look for the first and last matches of pattern in text. If two
// different matches are found, increase the pattern length.
while (text.IndexOf(pattern, StringComparison.Ordinal)
!= text.LastIndexOf(pattern, StringComparison.Ordinal) &&
pattern.Length < Constants.MatchMaxBits - patchMargin - patchMargin)
{
padding += patchMargin;
var begin = Math.Max(0, Start2 - padding);
pattern = text.Substring(begin, Math.Min(text.Length, Start2 + Length1 + padding) - begin);
}
// Add one chunk for good luck.
padding += patchMargin;
// Add the prefix.
var begin1 = Math.Max(0, Start2 - padding);
var prefix = text.Substring(begin1, Start2 - begin1);
if (prefix.Length != 0)
{
Diffs.Insert(0, Diff.Equal(prefix));
}
// Add the suffix.
var begin2 = Start2 + Length1;
var length = Math.Min(text.Length, Start2 + Length1 + padding) - begin2;
var suffix = text.Substring(begin2, length);
if (suffix.Length != 0)
{
Diffs.Add(Diff.Equal(suffix));
}
// Roll back the start points.
Start1 -= prefix.Length;
Start2 -= prefix.Length;
// Extend the lengths.
Length1 += prefix.Length + suffix.Length;
Length2 += prefix.Length + suffix.Length;
}
public bool Merge(string title, CompareContext context)
{
if (context == null)
{
return(false);
}
if (context.Diffs.Count > 0)
{
if (!string.IsNullOrEmpty(title))
{
Diffs.Add(title);
}
Diffs.AddRange(context.Diffs);
}
return(context.Diffs.Count == 0);
}
public void Add(Entry e)
{
long diff = 0;
if (Entries.Count == 0)
{
diff = e.Value;;
}
else
{
diff = e.Value - Entries[Entries.Count - 1].Value;
}
Entries.Add(e);
Diffs.Add(diff);
BaseLine.Add(e.Value - Entries[0].Value);
Sum += diff;
Min = Math.Min(Min, e.Value);
Max = Math.Max(Max, e.Value);
}
public void AddPaddingAfterLastDiff(string nullPadding)
{
if (Diffs.Count == 0 || Diffs.Last().Operation != Operation.Equal)
{
// Add nullPadding equality.
Diffs.Add(Diff.Equal(nullPadding));
Length1 += nullPadding.Length;
Length2 += nullPadding.Length;
}
else if (nullPadding.Length > Diffs[Diffs.Count - 1].Text.Length)
{
// Grow last equality.
var lastDiff = Diffs[Diffs.Count - 1];
var extraLength = nullPadding.Length - lastDiff.Text.Length;
var text = lastDiff.Text + nullPadding.Substring(0, extraLength);
Diffs[Diffs.Count - 1] = lastDiff.Replace(text);
Length1 += extraLength;
Length2 += extraLength;
}
}
public void InitSettings(OpenSettings settings)
{
if (settings.Method == StartMethod.Open)
{
_mapsetPath = settings.MapsetPath;
var osuFiles = Directory.GetFiles(_mapsetPath, "*.osu", SearchOption.TopDirectoryOnly);
foreach (var cur in osuFiles)
{
Diffs.Add(new DiffVersion
{
DiffName = OsuParserExtensions.GetDiffName(cur),
FileName = cur
});
}
}
if (settings.Method == StartMethod.Create)
{
InitialCommand.Execute(null);
}
}
public void AddDiff(string diff)
{
Diffs.Add(diff);
}