public void IntersectFalseTest()
{
var original = @"
var total = 0;
var n = 100;
for (var i = n - 1; i >= 0; i--)
{
total = i + total;
}
".WrapWithMethod().Parse();
var changed1 = @"
var total = 0;
var n = 100;
for (var i = 0; i < n; i++)
{
total = i + total;
}
".WrapWithMethod().Parse();
var changed2 = @"
var total = 0;
var n = 100;
for (var i = n - 1; i >= 0; i--)
{
total += i;
}
".WrapWithMethod().Parse();
var c1s = Diff.Compare(original, changed1).ToList();
var c2 = Diff.Compare(original, changed2).Single();
foreach (var x in Enumerable.Range(0, 3))
{
Assert.IsFalse(Diff.Intersects(c1s[x], c2));
Assert.IsFalse(Diff.Intersects(c2, c1s[x]));
}
}
public void IntersectTrueOverlapingTest()
{
var original = @"
var total = 0;
var n = 100;
for (var i = 0; i < n; i++)
{
total = i + total;
}
".WrapWithMethod().Parse();
var changed1 = @"
var total = 0;
".WrapWithMethod().Parse();
var changed2 = @"
var total = 0;
var n = 100;
for (var i = 0; i < n; i++)
{
total += i;
}
".WrapWithMethod().Parse();
var c1 = Diff.Compare(original, changed1).Single();
var c2 = Diff.Compare(original, changed2).Single();
Assert.IsTrue(Diff.Intersects(c1, c2));
Assert.IsTrue(Diff.Intersects(c2, c1));
}
public void GetChangesChangedTwiceTest()
{
var original = @"
var total = 0;
var n = 100;
for (var i = n - 1; i >= 0; i--)
{
total = i + total;
}
".WrapWithMethod().Parse();
var changed = @"
var total = 0;
var n = 100;
for (var i = 0; i < n; i++)
{
total += i;
}
".WrapWithMethod().Parse();
var changes = Diff.Compare(original, changed).ToList();
Assert.AreEqual(4, changes.Count()); //Even though two changes are made it is interpreted as 4!
Assert.AreEqual("n - 1", changes[0].Ancestor.Text);
Assert.AreEqual("0", changes[0].Changed.Text);
Assert.AreEqual(">= 0", changes[1].Ancestor.Text);
Assert.AreEqual("< n", changes[1].Changed.Text);
Assert.AreEqual("--", changes[2].Ancestor.Text);
Assert.AreEqual("++", changes[2].Changed.Text);
Assert.AreEqual("= i + total", changes[3].Ancestor.Text);
Assert.AreEqual("+= i", changes[3].Changed.Text);
}
/*
* /// <summary>
* /// Reserve position for the current branch. Any branch on the same position should move right.
* /// </summary>
* /// <param name="snapshot">Comit that claims position</param>
* private void ReserveBranchOffset(Snapshot snapshot) {
* for (int i = snapshot.VisibleOrder + 1; i < snapshots.Where(e => e.IsCommitVisible).Count(); i++) {
* if (snapshots[i].TreeOffset == snapshot.TreeOffset) {
* snapshots[i].TreeOffset++;
* ReserveBranchOffset(snapshots[i]);
* }
* }
* }
*/
/// <summary>
/// Verify is file had the same name in the previous commit or was renamed/moved
/// </summary>
/// <param name="snapshot">Observable snapshot</param>
/// <param name="diff">Commits comparer</param>
/// <param name="commit">Current commit</param>
/// <param name="name">Current file name</param>
/// <returns>File name in previous commit</returns>
private string GetPreviousCommitFileName(Snapshot snapshot, Diff diff, LibGit2Sharp.Commit commit, string name)
{
// When you git commit normally, the current commit
// becomes the parent commit of the new commit that's introduced by the command.
// When you git merge two commits (or branches, whatever) without fast-forwarding,
// a new commit will be created with both commits as parents.
// You can merge more than two commits in that way, so the new commit may have more than two parents.
if (!commit.Parents.Any())
{
// No parent commits. Stop history looping. Probably is't already last (first) commit.
snapshot.FilePathState = FilePathState.Unknown;
return(string.Empty);
}
foreach (var parent in commit.Parents)
{
var treeComparer = diff.Compare <TreeChanges>(parent.Tree, commit.Tree);
// If file was renamed than continue to work with previous name
foreach (var f in treeComparer.Renamed)
{
if (name == f.Path)
{
snapshot.FilePathState |= FilePathState.Changed;
snapshot.PreviousFilePath = f.OldPath;
}
}
// If file was just added than nothing to continue
foreach (var f in treeComparer.Added)
{
if (name == f.Path)
{
snapshot.FilePathState |= FilePathState.Added;
}
}
// TODO: Probably we should set branch source in commit
// TODO: Not sure about files conflicts (paralel creating the same file and moving to one branch!)
// TODO: Add notificaton message: Added/Removed/Updated Code // Renamed/Moved/Created File
// TODO: Investigate:
// - treeComparer.TypeChanged
// - treeComparer.Copied
}
if (snapshot.FilePathState == FilePathState.Added)
{
return(string.Empty);
}
if (snapshot.FilePathState == FilePathState.Changed)
{
return(snapshot.PreviousFilePath);
}
// No path/name changes was found.
snapshot.FilePathState = FilePathState.NotChanged;
return(name);
}
/// <summary>
/// Executes the specified domains.
/// </summary>
/// <param name="domains">The domains.</param>
/// <param name="args">The arguments.</param>
/// <param name="callback">The callback.</param>
/// <returns></returns>
public static ExecutedResult Execute(Domains domains, IAddonInteractive interactive)
{
var r = default(ExecutedResult);
lock (((ICollection)s_container).SyncRoot)
{
switch (s_container.Count)
{
case 0:
r = ExecutedResult.NoAddon;
break;
case 1:
{
var m = s_container[0];
var diff = Diff.Compare(m.Metadata.Domains, domains.Keywords);
if (diff != 0.0 && Toggle[m.Metadata.Name])
{
var result = m.CreateExport().Value.Execute(domains, interactive);
r = result.HasValue ? (result.Value ? ExecutedResult.Success : ExecutedResult.Failure) : ExecutedResult.Disabled;
}
else
{
r = ExecutedResult.NoMatched;
}
break;
}
default:
{
var top_v = 0.0;
var a = default(ExportFactory <IAddonContract, AddonDefinition>);
foreach (var m in s_container)
{
var diff = Diff.Compare(m.Metadata.Domains, domains.Keywords);
// Debug.WriteLine("N: " + m.Metadata.Name + " | " + diff);
if (diff >= top_v && Toggle[m.Metadata.Name])
{
top_v = diff;
a = m;
}
}
if (top_v == 0.0)
{
r = ExecutedResult.NoMatched;
}
else if (Toggle[a.Metadata.Name])
{
//Found the highest similar object
var result = a.CreateExport().Value.Execute(domains, interactive);
r = result.HasValue ? (result.Value ? ExecutedResult.Success : ExecutedResult.Failure) : ExecutedResult.Disabled;
}
break;
}
}
}
return(r);
}
/// <summary>
/// Executes the specified domains.
/// </summary>
/// <param name="domains">The domains.</param>
/// <param name="args">The arguments.</param>
/// <param name="callback">The callback.</param>
/// <returns></returns>
public ExecutedResult Execute(string[] domains, string[] args, out object callback)
{
var r = default(ExecutedResult);
callback = null;
switch (this._container.Count)
{
case 0:
r = ExecutedResult.NoAddon;
break;
case 1:
{
var m = this._container[0];
var diff = Diff.Compare(m.Metadata.Domains, domains);
if (diff != 0.0)
{
var result = m.Value.Execute(args, out callback);
r = result.HasValue ? (result.Value ? ExecutedResult.Success : ExecutedResult.Failure) : ExecutedResult.Disabled;
}
else
{
r = ExecutedResult.NoMatched;
}
break;
}
default:
{
var top_v = 0.0;
var a = default(Lazy <IAddon, IAddonMetadata>);
foreach (var m in this._container)
{
var diff = Diff.Compare(m.Metadata.Domains, domains);
// Debug.WriteLine("N: " + m.Metadata.Name + " | " + diff);
if (diff >= top_v)
{
top_v = diff;
a = m;
}
}
if (top_v == 0.0)
{
r = ExecutedResult.NoMatched;
}
else
{
//Found the highest similar object
var result = a.Value.Execute(args, out callback);
r = result.HasValue ? (result.Value ? ExecutedResult.Success : ExecutedResult.Failure) : ExecutedResult.Disabled;
}
break;
}
}
return(r);
}
static bool CommitContainsApi(Diff diff, Commit commit, Func <string, bool> pathFilter)
{
if (commit.Parents.Count() != 1)
{
return(false);
}
var tree = commit.Tree;
var parentTree = commit.Parents.First().Tree;
var comparison = diff.Compare <TreeChanges>(parentTree, tree);
return(comparison.Select(change => change.Path).Any(pathFilter));
}
static bool CommitContainsApi(Diff diff, Commit commit, string apiDirectory)
{
if (commit.Parents.Count() != 1)
{
return(false);
}
var tree = commit.Tree;
var parentTree = commit.Parents.First().Tree;
var comparison = diff.Compare <TreeChanges>(parentTree, tree);
return(comparison.Any(change => change.Path.StartsWith(apiDirectory)));
}
private void ComparisonListView_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
if (e.IsSelected)
{
CustomizationComparison comparison = (CustomizationComparison)e.Item.Tag;
SourceBusyPicture.Visible = true;
TargetBusyPicture.Visible = true;
SourceWebBrowser.Document.Body.InnerHtml = "";
TargetWebBrowser.Document.Body.InnerHtml = "";
ThreadPool.QueueUserWorkItem(delegate(object state)
{
if (comparison.IsDifferent)
{
CustomizationSerializer serializer = new CustomizationSerializer();
IEnumerable <String> sourceLines = serializer.SerializeObjectToLines(comparison, comparison.SourceValue);
IEnumerable <String> targetLines = serializer.SerializeObjectToLines(comparison, comparison.TargetValue);
Diff diff = new Diff();
DiffResult <String>[] results = diff.Compare(sourceLines.Take(LineCountLimit).ToArray(), targetLines.Take(LineCountLimit).ToArray()).ToArray();
this.Invoke(_updateBrowsersCaller, comparison, results);
}
else
{
CustomizationSerializer serializer = new CustomizationSerializer();
IEnumerable <String> lines = serializer.SerializeObjectToLines(comparison, comparison.TargetValue);
DiffResult <String>[] results = new DiffResult <string>[]
{
new DiffResult <String>
{
Owner = DiffOwner.Both,
}
};
results[0].AddValues(lines.ToList());
this.Invoke(_updateBrowsersCaller, comparison, results);
}
});
}
}
public bool Execute(string[] keywords, string[] args, out object callback)
{
var top_v = 0.0;
var top = default(Lazy <IModule, IModuleMetadata>);
foreach (var m in this._modules)
{
var diff = Diff.Compare(m.Metadata.Keywords, keywords);
if (diff > top_v)
{
top_v = diff;
top = m;
}
}
//Found the highest similar object
return(top.Value.Execute(args, out callback));
}
public void GetChangesNotChangedTest()
{
var original = @"
var total = 0;
var n = 100;
for (var i = n - 1; i >= 0; i--)
{
total = i + total;
}
".WrapWithMethod().Parse();
var changed = @"
var total = 0;
var n = 100;
for (var i = n - 1; i >= 0; i--)
{
total = i + total;
}
".WrapWithMethod().Parse();
var changes = Diff.Compare(original, changed);
Assert.AreEqual(0, changes.Count());
}
public void GetChangesChangedOnceTest()
{
var original = @"
var total = 0;
var n = 100;
for (var i = n - 1; i >= 0; i--)
{
total = i + total;
}
".WrapWithMethod().Parse();
var changed = @"
var total = 0;
var n = 100;
for (var i = n - 1; i >= 0; i--)
{
total += i;
}
".WrapWithMethod().Parse();
var changes = Diff.Compare(original, changed);
Assert.AreEqual("= i + total", changes.Single().Ancestor.Text);
Assert.AreEqual("+= i", changes.Single().Changed.Text);
}
