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); }