Added support to convert to diff-match-patch

Author: Thomas Hambach

CSharpDiff.Tests/DiffCharacterTests.cs

@@ -11,7 +11,7 @@ public void ShouldDiffChars()
         {
             var diff = new Diff();
             var result = diff.diff("New Value.", "New ValueMoreData.");
-            Assert.Equal("New Value<ins>MoreData</ins>.", DiffConvertXml.Convert(result));
+            Assert.Equal("New Value<ins>MoreData</ins>.", DiffConvert.ToXml(result));
         }
 
         [Fact]
@@ -22,7 +22,7 @@ public void ShouldConsiderCase()
                 IgnoreCase = true
             });
             var result = diff.diff("New Value.", "New value.");
-            Assert.Equal("New value.", DiffConvertXml.Convert(result));
+            Assert.Equal("New value.", DiffConvert.ToXml(result));
         }
 
         [Fact]
@@ -33,7 +33,7 @@ public void ShouldConsiderCaseWithDifference()
                 IgnoreCase = true
             });
             var result = diff.diff("New Values.", "New value.");
-            Assert.Equal("New value<del>s</del>.", DiffConvertXml.Convert(result));
+            Assert.Equal("New value<del>s</del>.", DiffConvert.ToXml(result));
         }
     }
 }

CSharpDiff.Tests/DiffConvertTests.cs

@@ -0,0 +1,61 @@
+using CSharpDiff.Converters;
+using CSharpDiff.Diffs;
+using CSharpDiff.Diffs.Models;
+
+namespace CSharpDiff.Tests
+{
+    public class DiffConvertXmlTests
+    {
+        [Fact]
+        public void ShouldConvertToXml()
+        {
+
+            var changes = new List<DiffResult> {
+            new DiffResult {
+                added = false,
+                removed = true,
+                value = "test"
+            },
+            new DiffResult {
+                added = true,
+                removed = false,
+                value = "test"
+            },
+        };
+
+            var converted = DiffConvert.ToXml(changes);
+            Assert.Equal("<del>test</del><ins>test</ins>", converted);
+
+        }
+
+        [Fact]
+        public void ShouldConvertToDmp()
+        {
+            var changes = new List<DiffResult> {
+            new DiffResult {
+                added = false,
+                removed = true,
+                value = "test"
+            },
+            new DiffResult {
+                added = true,
+                removed = false,
+                value = "test"
+            },
+            new DiffResult {
+                added = false,
+                removed = false,
+                value = "test"
+            },
+        };
+
+            var converted = DiffConvert.ToDmp(changes);
+            Assert.Equal(-1, converted[0].Item1);
+            Assert.Equal("test", converted[0].Item2);
+            Assert.Equal(1, converted[1].Item1);
+            Assert.Equal("test", converted[1].Item2);
+            Assert.Equal(0, converted[2].Item1);
+        }
+
+    }
+}

CSharpDiff.Tests/DiffConvertXmlTests.cs

@@ -11,7 +11,7 @@ public void ShouldDiffSentences()
         {
             var diff = new DiffSentence();
             var diffResult = diff.diff("New Value.", "New ValueMoreData.");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("<del>New Value.</del><ins>New ValueMoreData.</ins>", converted);
         }
 
@@ -20,7 +20,7 @@ public void ShouldDiffLastSentence()
         {
             var diff = new DiffSentence();
             var diffResult = diff.diff("Here im. Rock you like old man.", "Here im. Rock you like hurricane.");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("Here im. <del>Rock you like old man.</del><ins>Rock you like hurricane.</ins>", converted);
         }
     }

CSharpDiff.Tests/DiffSentenceTests.cs

@@ -11,7 +11,7 @@ public void ShouldDiffLines()
         {
             var diff = new DiffLines();
             var diffResult = diff.diff("line\nold value\nline", "line\nnew value\nline");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("line\n<del>old value\n</del><ins>new value\n</ins>line", converted);
         }
 
@@ -20,7 +20,7 @@ public void ShouldDiffTheSameLines()
         {
             var diff = new DiffLines();
             var diffResult = diff.diff("line\nvalue\nline", "line\nvalue\nline");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("line\nvalue\nline", converted);
         }
 
@@ -29,7 +29,7 @@ public void ShouldHandleTrailingSpaces()
         {
             var diff = new DiffLines();
             var diffResult = diff.diff("line\nvalue \nline", "line\nvalue\nline");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("line\n<del>value \n</del><ins>value\n</ins>line", converted);
         }
 
@@ -38,7 +38,7 @@ public void ShouldHandleWindowsLineEndings()
         {
             var diff = new DiffLines();
             var diffResult = diff.diff("line\r\nold value\r\nline", "line\r\nnew value\r\nline");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("line\r\n<del>old value\r\n</del><ins>new value\r\n</ins>line", converted);
         }
 
@@ -47,7 +47,7 @@ public void ShouldHandleEmptyLines()
         {
             var diff = new DiffLines();
             var diffResult = diff.diff("line\n\nold value \n\nline", "line\n\nnew value\n\nline");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("line\n\n<del>old value \n</del><ins>new value\n</ins>\nline", converted);
         }
 
@@ -56,7 +56,7 @@ public void ShouldHandleEmptyInput()
         {
             var diff = new DiffLines();
             var diffResult = diff.diff("line\n\nold value \n\nline", "");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("<del>line\n\nold value \n\nline</del>", converted);
         }
 

CSharpDiff.Tests/DiffTests.cs

@@ -11,7 +11,7 @@ public void ShouldDiffWhitespace()
         {
             var diff = new DiffWord();
             var diffResult = diff.diff("New Value", "New  ValueMoreData");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("New  <del>Value</del><ins>ValueMoreData</ins>", converted);
         }
 
@@ -20,7 +20,7 @@ public void ShouldDiffMultipleWhitespace()
         {
             var diff = new DiffWord();
             var diffResult = diff.diff("New Value  ", "New  ValueMoreData ");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("New  <del>Value</del><ins>ValueMoreData</ins> ", converted);
         }
 
@@ -30,7 +30,7 @@ public void ShouldDiffOnWordBoundaries()
         {
             var diff = new DiffWord();
             var diffResult = diff.diff("New :Value:Test", "New  ValueMoreData ");
-            var converted = DiffConvertXml.Convert(diffResult);
+            var converted = DiffConvert.ToXml(diffResult);
             Assert.Equal("New  <del>:Value:Test</del><ins>ValueMoreData </ins>", converted);
 
             // @todo Tests below still bug out due to the REGEX in DiffWord.Tokenize

CSharpDiff.Tests/DiffWordTests.cs

@@ -4,7 +4,7 @@
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <PackageId>CSharpDiff</PackageId>
-    <Version>0.0.6</Version>
+    <Version>0.0.7</Version>
     <Authors>ThomasHambach</Authors>
     <Description>
       Unified Diff support for .NET. Based on the popular library JSDIFF.

CSharpDiff/CSharpDiff.csproj

@@ -3,14 +3,14 @@
 
 namespace CSharpDiff.Converters
 {
-    public static class DiffConvertXml
+    public static class DiffConvert
     {
         /// <summary>
         /// Convert the changes to an XML structure
         /// </summary>
         /// <param name="changes"></param>
         /// <returns></returns>
-        public static string Convert(IList<DiffResult> changes)
+        public static string ToXml(IList<DiffResult> changes)
         {
 
             var ret = new List<string>();
@@ -40,5 +40,38 @@ public static string Convert(IList<DiffResult> changes)
 
             return String.Join("", ret);
         }
+
+        /// <summary>
+        /// Convert to diff-match-patch format
+        /// </summary>
+        /// <param name="changes"></param>
+        /// <returns></returns>
+        public static IList<Tuple<int, string>> ToDmp(IList<DiffResult> changes)
+        {
+            var ret = new List<Tuple<int, string>>();
+            DiffResult change = null;
+            var operation = 0;
+            for (var i = 0; i < changes.Count; i++)
+            {
+                change = changes[i];
+                if (change.added == true)
+                {
+                    operation = 1;
+                }
+                else if (change.removed == true)
+                {
+                    operation = -1;
+                }
+                else
+                {
+                    operation = 0;
+                }
+
+                ret.Add(new Tuple<int, string>(operation, change.value));
+            }
+
+            return ret;
+        }
+
     }
 }

CSharpDiff/Converters/DiffConvertXml.cs

@@ -6,6 +6,36 @@ public interface IPatch
     {
         string[] contextLines(string[] lines);
 
+        /// <summary>
+        /// Create a text version of a unified diff patch.
+        /// </summary>
+        /// <param name="filename"></param>
+        /// <param name="oldStr"></param>
+        /// <param name="newStr"></param>
+        /// <returns></returns>
+        string create(string filename, string oldStr, string newStr);
+
+        /// <summary>
+        /// Create a text version of a unified diff patch.
+        /// </summary>
+        /// <param name="oldFileName"></param>
+        /// <param name="newFileName"></param>
+        /// <param name="oldStr"></param>
+        /// <param name="newStr"></param>
+        /// <returns></returns>
+        string create(string oldFileName, string newFileName, string oldStr, string newStr);
+
+        /// <summary>
+        /// Create a text version of a unified diff patch.
+        /// </summary>
+        /// <param name="filename"></param>
+        /// <param name="oldStr"></param>
+        /// <param name="newStr"></param>
+        /// <param name="oldHeader"></param>
+        /// <param name="newHeader"></param>
+        /// <returns></returns>
+        string create(string filename, string oldStr, string newStr, string oldHeader, string newHeader);
+
         /// <summary>
         /// Create a text version of a unified diff patch.
         /// </summary>

CSharpDiff/Patches/IPatch.cs

@@ -33,6 +33,21 @@ public string[] contextLines(string[] lines)
             return lines.Select((entry) => { return ' ' + entry; }).ToArray();
         }
 
+        public string create(string filename, string oldStr, string newStr)
+        {
+            return create(filename, filename, oldStr, newStr, null, null);
+        }
+
+        public string create(string oldFileName, string newFileName, string oldStr, string newStr)
+        {
+            return create(oldFileName, newFileName, oldStr, newStr, null, null);
+        }
+
+        public string create(string filename, string oldStr, string newStr, string oldHeader, string newHeader)
+        {
+            return create(filename, filename, oldStr, newStr, oldHeader, newHeader);
+        }
+
         public string create(string oldFileName, string newFileName, string oldStr, string newStr, string oldHeader, string newHeader)
         {
             var result = createPatchResult(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader);