public static void WriteUnifiedDiff(Diff diff, TextWriter writer, string fromfile, string tofile, int context) { writer.Write("--- "); writer.WriteLine(fromfile); writer.Write("+++ "); writer.WriteLine(tofile); ArrayList hunkset = new ArrayList(); foreach (Diff.Hunk hunk in diff) { Diff.Hunk lasthunk = null; if (hunkset.Count > 0) lasthunk = (Diff.Hunk)hunkset[hunkset.Count-1]; if (hunk.Same) { // At the start of a hunk set, keep only context lines of context. if (lasthunk == null) { if (hunk.Left.Count > context) hunkset.Add( hunk.Crop(hunk.Left.Count-context, 0) ); else hunkset.Add( hunk ); // Can't have two same hunks in a row, so the last one was a difference. } else { // Small enough context that this unified diff range will not stop. if (hunk.Left.Count <= context*2) { hunkset.Add( hunk ); // Too much of the same. Keep context lines and end this section. // And then keep the last context lines as context for the next section. } else { hunkset.Add( hunk.Crop(0, hunk.Left.Count-context) ); WriteUnifiedDiffSection(writer, hunkset); hunkset.Clear(); if (hunk.Left.Count > context) hunkset.Add( hunk.Crop(hunk.Left.Count-context, 0) ); else hunkset.Add( hunk ); } } } else { hunkset.Add(hunk); } } if (hunkset.Count > 0 && !(hunkset.Count == 1 && ((Diff.Hunk)hunkset[0]).Same)) WriteUnifiedDiffSection(writer, hunkset); }
private static IDiff[] makediffs(IList original, IList[] changed, IComparer comparer, IEqualityComparer hashcoder) { IDiff[] diffs = new IDiff[changed.Length]; for (int i = 0; i < changed.Length; i++) diffs[i] = new Diff(original, changed[i], comparer, hashcoder); return diffs; }
internal Hunk(Merge merge, Diff.Hunk[][] hunks, int start, int count, bool same) { this.merge = merge; this.hunks = hunks; this.start = start; this.count = count; this.same = same; int ct = 0; foreach (Diff.Hunk[] hh in hunks) { foreach (Diff.Hunk h in hh) { if (!h.Same) { ct++; break; } } } conflict = (ct > 1); }
public Enumerator(Diff diff) { this.diff = diff; Reset(); }
private void Refresh() { box.Show(); try { if (left is string) diff = new Diff((string)left, (string)right, true, true); else if (left is string[]) diff = new Diff((string[])left, (string[])right, null, null); } catch (Exception e) { Console.Error.WriteLine(e.ToString()); return; } if (widget != null) { pos = widget.Position; box.Remove(widget); widget.Dispose(); } DiffWidget.Options opts = new DiffWidget.Options(); opts.Font = DesktopService.DefaultMonospaceFont; opts.LeftName = "Repository"; opts.RightName = "Working Copy"; widget = new DiffWidget(diff, opts); box.Add(widget); box.ShowAll(); widget.ExposeEvent += new ExposeEventHandler(OnExposed); }
public void GetButtonPosition (Diff.Hunk hunk, int z1, int z2, int y1, int y2, out int x, out int y, out int r) { r = 14; if (hunk.Left.Count == 0) { x = 0; y = Math.Min (z1, z2); } else { x = Allocation.Width - r; y = Math.Min (y1, y2); } }
int[,] GetLCS (Diff.Hunk hunk) { int[,] result; if (llcsCache.TryGetValue (hunk, out result)) return result; return null; }
public static Cairo.Color GetColor (Diff.Hunk hunk, double alpha) { if (hunk.Left.Count == 0) return new Cairo.Color (0.4, 0.8, 0.4, alpha); if (hunk.Right.Count == 0) return new Cairo.Color (0.8, 0.4, 0.4, alpha); return new Cairo.Color (0.4, 0.8, 0.8, alpha); }
public void CreateDiff () { var leftLines = from l in OriginalEditor.Document.Lines select OriginalEditor.Document.GetTextAt (l.Offset, l.EditableLength); var rightLines = from l in DiffEditor.Document.Lines select DiffEditor.Document.GetTextAt (l.Offset, l.EditableLength); Diff = new Diff (rightLines.ToArray (), leftLines.ToArray (), true, true); QueueDraw (); }
private float CompareLists(IList left, IList right, float threshold, bool output) { // Given two lists, find the elements in the list that correspond. // Two elements correspond if their 'difference metric' is less than // or equal to threshold. For the hunks of correspondent items, // recursively descend into items not truly equal. For hunks of // irreconsiliable material, raise the threshold to the next useful // level and rescan the items. if (left.Count == 0 && right.Count == 0) return 0; NodeComparerWrapper comparer = new NodeComparerWrapper(threshold, this); Diff diff = new Diff(left, right, comparer, comparer); int nitems = 0, ndiffs = 0; foreach (Diff.Hunk hunk in diff) { if (hunk.Same || (hunk.Left.Count == 1 && hunk.Right.Count == 1)) { // This comprises a block of correspondent items who // differ by no more than the threshold value. nitems += hunk.Left.Count; bool inSameRegion = false; for (int i = 0; i < hunk.Left.Count; i++) { object oleft = hunk.Left[i]; object oright = hunk.Right[i]; NodeInterface ileft = GetInterface(oleft); NodeInterface iright = GetInterface(oright); IList cleft = null, cright = null; cleft = ileft.GetChildren(oleft); cright = iright.GetChildren(oright); float comp = 0; if (ileft == iright) comp = ileft.Compare(oleft, oright, this); // If the nodes are equal, emit one node. if (ileft == iright && comp == 0) { if (output) { if (!inSameRegion) { WritePushSame(); inSameRegion = true; } WriteNodeSame(ileft, oleft, oright); } // Recurse into the lists of each node. } else if (ileft == iright && cleft != null && cright != null && cleft.Count > 0 && cright.Count > 0 && comp <= 1.0) { if (output && inSameRegion) { WritePopSame(); inSameRegion = false; } if (output) WritePushNode(ileft, oleft, oright); float d = CompareLists(cleft, cright, 0, output); d *= hunk.Left.Count; if (d < 1) d = 1; ndiffs += (int)d; if (output) WritePopNode(); // The nodes are not equal, so emit removed and added nodes. } else { if (output && inSameRegion) { WritePopSame(); inSameRegion = false; } if (output) WriteNodeChange(ileft, oleft, iright, oright); ndiffs += hunk.Left.Count; } } if (output && inSameRegion) WritePopSame(); } else { int ct = hunk.Left.Count + hunk.Right.Count; nitems += ct; ndiffs += ct; if (output) { bool noRecurse = comparer.minimumDifference >= 1; if (hunk.Right.Count == 0 || (hunk.Left.Count > 0 && noRecurse)) WriteNodesRemoved(hunk.Left); if (hunk.Left.Count == 0 || (hunk.Right.Count > 0 && noRecurse)) WriteNodesAdded(hunk.Right); if (hunk.Right.Count != 0 && hunk.Left.Count != 0 && !noRecurse) CompareLists(hunk.Left, hunk.Right, comparer.minimumDifference, output); } } } return (float)ndiffs / (float)nitems; }
void SetDiffCellData (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter) { try { CellRendererDiff cellRendererDiff = (CellRendererDiff)cell; Change change = store.GetValue (iter, objColumn) as Change; cellRendererDiff.Visible = !(bool)store.GetValue (iter, statusVisibleColumn); if (change == null || !cellRendererDiff.Visible) { cellRendererDiff.InitCell (treeviewPreview, false, "", ""); return; } TextReplaceChange replaceChange = change as TextReplaceChange; if (replaceChange == null) return; Mono.TextEditor.Document doc = new Mono.TextEditor.Document (); doc.Text = System.IO.File.ReadAllText (replaceChange.FileName); List<string> before = new List<string> (); foreach (var line in doc.Lines) { before.Add (doc.GetTextAt (line.Offset, line.EditableLength)); } ((Mono.TextEditor.IBuffer)doc).Replace (replaceChange.Offset, replaceChange.RemovedChars, replaceChange.InsertedText); List<string> after = new List<string> (); foreach (var line in doc.Lines) { after.Add (doc.GetTextAt (line.Offset, line.EditableLength)); } Diff diff = new Diff (before.ToArray (), after.ToArray (), true, true); System.IO.StringWriter w = new System.IO.StringWriter(); UnifiedDiff.WriteUnifiedDiff (diff, w, replaceChange.FileName, replaceChange.FileName, 2); cellRendererDiff.InitCell (treeviewPreview, true, w.ToString ().Trim (), replaceChange.FileName); } catch (Exception e) { Console.WriteLine (e); } }
public DiffWidget(Diff diff, Options options) : this(Hunkify(diff), options) { }
public static void WriteUnifiedDiff(Diff diff, TextWriter writer) { WriteUnifiedDiff(diff, writer, "Left", "Right", 2); }
public static void WriteUnifiedDiff(string[] leftLines, string leftName, string[] rightLines, string rightName, System.IO.TextWriter writer, int context, bool caseSensitive, bool compareWhitespace) { Diff diff = new Diff(leftLines, rightLines, caseSensitive, compareWhitespace); WriteUnifiedDiff(diff, writer, leftName, rightName, context); }