Work around C#’s inability to encode large strings

“64k ought to be enough for anybody.”

csharp/DiffMatchPatch.cs

@@ -166,11 +166,9 @@ public override string ToString() {
             break;
         }
 
-        text.Append(Uri.EscapeDataString(aDiff.text).Replace('+', ' ')).Append("\n");
+        text.Append(diff_match_patch.encodeURI(aDiff.text)).Append("\n");
       }
-
-      return diff_match_patch.unescapeForEncodeUriCompatability(
-          text.ToString());
+      return text.ToString();
     }
   }
 
@@ -1026,7 +1024,7 @@ public void diff_cleanupSemanticLossless(List<Diff> diffs) {
     }
 
     /**
-     * Given two strings, comAdde a score representing whether the internal
+     * Given two strings, compute a score representing whether the internal
      * boundary falls on logical boundaries.
      * Scores range from 6 (best) to 0 (worst).
      * @param one First string.
@@ -1292,7 +1290,7 @@ public void diff_cleanupMerge(List<Diff> diffs) {
     }
 
     /**
-     * loc is a location in text1, comAdde and return the equivalent location in
+     * loc is a location in text1, compute and return the equivalent location in
      * text2.
      * e.g. "The cat" vs "The big cat", 1->1, 5->8
      * @param diffs List of Diff objects.
@@ -1431,7 +1429,7 @@ public string diff_toDelta(List<Diff> diffs) {
       foreach (Diff aDiff in diffs) {
         switch (aDiff.operation) {
           case Operation.INSERT:
-            text.Append("+").Append(Uri.EscapeDataString(aDiff.text).Replace('+', ' ')).Append("\t");
+            text.Append("+").Append(encodeURI(aDiff.text)).Append("\t");
             break;
           case Operation.DELETE:
             text.Append("-").Append(aDiff.text.Length).Append("\t");
@@ -1445,14 +1443,13 @@ public string diff_toDelta(List<Diff> diffs) {
       if (delta.Length != 0) {
         // Strip off trailing tab character.
         delta = delta.Substring(0, delta.Length - 1);
-        delta = unescapeForEncodeUriCompatability(delta);
       }
       return delta;
     }
 
     /**
      * Given the original text1, and an encoded string which describes the
-     * operations required to transform text1 into text2, comAdde the full diff.
+     * operations required to transform text1 into text2, compute the full diff.
      * @param text1 Source string for the diff.
      * @param delta Delta text.
      * @return Array of Diff objects or null if invalid.
@@ -1765,7 +1762,7 @@ protected void patch_addContext(Patch patch, string text) {
      */
     public List<Patch> patch_make(string text1, string text2) {
       // Check for null inputs not needed since null can't be passed in C#.
-      // No diffs provided, comAdde our own.
+      // No diffs provided, compute our own.
       List<Diff> diffs = diff_main(text1, text2, true);
       if (diffs.Count > 2) {
         diff_cleanupSemantic(diffs);
@@ -1782,7 +1779,7 @@ public List<Patch> patch_make(string text1, string text2) {
      */
     public List<Patch> patch_make(List<Diff> diffs) {
       // Check for null inputs not needed since null can't be passed in C#.
-      // No origin string provided, comAdde our own.
+      // No origin string provided, compute our own.
       string text1 = diff_text1(diffs);
       return patch_make(text1, diffs);
     }
@@ -2278,25 +2275,31 @@ Regex patchHeader
     private static Regex HEXCODE = new Regex("%[0-9A-F][0-9A-F]");
 
     /**
-     * Unescape selected chars for compatibility with JavaScript's encodeURI.
-     * In speed critical applications this could be dropped since the
-     * receiving application will certainly decode these fine.
-     * Note that this function is case-sensitive.  Thus "%3F" would not be
-     * unescaped.  But this is ok because it is only called with the output of
-     * Uri.EscapeDataString which returns lowercase hex.
-     *
-     * Example: "%3f" -> "?", "%24" -> "$", etc.
+     * Encodes a string with URI-style % escaping.
+     * Compatible with JavaScript's encodeURI function.
      *
-     * @param str The string to escape.
-     * @return The escaped string.
+     * @param str The string to encode.
+     * @return The encoded string.
      */
-    public static string unescapeForEncodeUriCompatability(string str) {
-      str = str.Replace("%20", " ").Replace("%21", "!").Replace("%2A", "*")
-          .Replace("%27", "'").Replace("%28", "(").Replace("%29", ")")
-          .Replace("%3B", ";").Replace("%2F", "/").Replace("%3F", "?")
-          .Replace("%3A", ":").Replace("%40", "@").Replace("%26", "&")
-          .Replace("%3D", "=").Replace("%2B", "+").Replace("%24", "$")
-          .Replace("%2C", ",").Replace("%23", "#");
+    public static string encodeURI(string str) {
+      int MAX_LENGTH = 65520 - 1;
+      // C# throws a System.UriFormatException if string is too long.
+      // Split the string into 64kb chunks.
+      StringBuilder sb = new StringBuilder();
+      while (str.Length > MAX_LENGTH) {
+        sb.Append(Uri.EscapeDataString(str.Substring(0, MAX_LENGTH)));
+        str = str.Substring(MAX_LENGTH);
+      }
+      sb.Append(Uri.EscapeDataString(str));
+      str = sb.ToString();
+      // C# is overzealous in the replacements.  Walk back on a few.
+      str = str.Replace("+", " ").Replace("%20", " ").Replace("%21", "!")
+          .Replace("%2A", "*").Replace("%27", "'").Replace("%28", "(")
+          .Replace("%29", ")").Replace("%3B", ";").Replace("%2F", "/")
+          .Replace("%3F", "?").Replace("%3A", ":").Replace("%40", "@")
+          .Replace("%26", "&").Replace("%3D", "=").Replace("%2B", "+")
+          .Replace("%24", "$").Replace("%2C", ",").Replace("%23", "#");
+      // C# uses uppercase hex codes, JavaScript uses lowercase.
       return HEXCODE.Replace(str, new MatchEvaluator(lowerHex));
     }
 

csharp/tests/DiffMatchPatchTest.cs

@@ -611,6 +611,18 @@ public void diff_deltaTest() {
 
     // Convert delta string into a diff.
     assertEquals("diff_fromDelta: Unchanged characters.", diffs, this.diff_fromDelta("", delta));
+
+    // 160 kb string.
+    string a = "abcdefghij";
+    for (int i = 0; i < 14; i++) {
+      a += a;
+    }
+    diffs = new List<Diff> {new Diff(Operation.INSERT, a)};
+    delta = this.diff_toDelta(diffs);
+    assertEquals("diff_toDelta: 160kb string.", "+" + a, delta);
+
+    // Convert delta string into a diff.
+    assertEquals("diff_fromDelta: 160kb string.", diffs, this.diff_fromDelta("", delta));
   }
 
   public void diff_xIndexTest() {