tests with match_max_bits

Author: pzingg

lib/dmp/options.ex

@@ -5,6 +5,11 @@ defmodule Dmp.Options do
     * `:diff_timeout` - Number of seconds to map a diff before giving up (0 for infinity).
     * `:diff_edit_cost` - Cost of an empty edit operation in terms of edit characters.
     * `:match_max_bits` - The number of bits in an integer (default is expected 32).
+      This parameter controls the lengths of patterns used in matching and patch splitting.
+      Set `:match_max_bits` to 0 to disable patch splitting. To avoid long patches in
+      certain pathological cases, use 32.  Elixir supports arbitrarily large integers,
+      so we allow values of 64 and 128, as well as smaller values. Multiple short patches
+      (using native ints, `:match_max_bits` of 32 or less) should be much faster than long ones.
     * `:match_threshold` - At what point is no match declared (0.0 = perfection, 1.0 = very loose).
     * `:match_distance` - How far to search for a match (0 = exact location, 1000+ = broad match).
       A match this many characters away from the expected location will add
@@ -13,7 +18,7 @@ defmodule Dmp.Options do
       the contents have to be to match the expected contents. (0.0 = perfection,
       1.0 = very loose).  Note that `:match_threshold` controls how closely the
       end points of a delete need to match.
-    * `:patch_margin` - Chunk size for context length.
+    * `:patch_margin` - Chunk size for context length. 4 is a good value.
   """
 
   alias __MODULE__
@@ -105,7 +110,7 @@ defmodule Dmp.Options do
   end
 
   defp valid_match_max_bits?(match_max_bits) do
-    match_max_bits > 0 && match_max_bits <= 128
+    Enum.member?([0, 8, 16, 32, 64, 128], match_max_bits)
   end
 
   defp valid_threshold?(value) do
@@ -173,12 +178,9 @@ defmodule Dmp.Options do
   end
 
   defp validate_patch_margin({opts, errors}) do
-    match_max_bits = Keyword.fetch!(opts, :match_max_bits)
     patch_margin = Keyword.fetch!(opts, :patch_margin)
 
-    if patch_margin >= 0 &&
-         (!valid_match_max_bits?(match_max_bits) ||
-            patch_margin < match_max_bits) do
+    if patch_margin >= 0 do
       {opts, errors}
     else
       {opts, [{"patch_margin", patch_margin} | errors]}

lib/dmp/patch.ex

@@ -451,10 +451,10 @@ defmodule Dmp.Patch do
   as an array of true/false values indicating which patches were applied.
 
     * `patches` - A patchlist.
-    * `text` - Old text.
+    * `text` - Text to apply patch to.
     * `opts` - A options keyword list, `[]` to use the default options.
 
-  Returns a tuple with two elements: the new text, and a list of
+  Returns a tuple with two elements: the patched text, and a list of
   boolean values. Each boolean corresponds to a patch in the patchlist,
   and is `true` if a match was found for the corresponding patch.
   """
@@ -635,6 +635,7 @@ defmodule Dmp.Patch do
 
   @doc """
   Add some padding on text start and end so that edges can match something.
+
   Intended to be called only from within `Patch.apply`.
 
     * `patches` - A patchlist..

mix.exs

@@ -20,7 +20,7 @@ defmodule Dmp.MixProject do
   end
 
   # Load KaTeX JavaScript to docs for math expressions
-  def docs do
+  defp docs do
     [
       main: "Diff Match Patch",
       authors: ["Peter Zingg <peter.zingg@gmail.com>"],

test/patch_test.exs

@@ -221,6 +221,7 @@ defmodule PatchTest do
       assert diffs == patch_diffs
     end
 
+    @tag :match_max_32
     test "long string with repeats" do
       text1 = repeats()
       text2 = text1 <> "123"
@@ -241,12 +242,30 @@ defmodule PatchTest do
         )
 
       patches = Patch.split_max(patches, 4)
-      assert patches != []
 
       assert "@@ -1,32 +1,46 @@\n+X\n ab\n+X\n cd\n+X\n ef\n+X\n gh\n+X\n ij\n+X\n kl\n+X\n mn\n+X\n op\n+X\n qr\n+X\n st\n+X\n uv\n+X\n wx\n+X\n yz\n+X\n 012345\n@@ -25,13 +39,18 @@\n zX01\n+X\n 23\n+X\n 45\n+X\n 67\n+X\n 89\n+X\n 0\n" ==
                Patch.to_text(patches)
     end
 
+    test "example 1, no splitting" do
+      opts = [match_max_bits: 0]
+
+      patches =
+        Patch.make(
+          "abcdefghijklmnopqrstuvwxyz01234567890",
+          "XabXcdXefXghXijXklXmnXopXqrXstXuvXwxXyzX01X23X45X67X89X0",
+          opts
+        )
+
+      unsplit =
+        "@@ -1,37 +1,56 @@\n+X\n ab\n+X\n cd\n+X\n ef\n+X\n gh\n+X\n ij\n+X\n kl\n+X\n mn\n+X\n op\n+X\n qr\n+X\n st\n+X\n uv\n+X\n wx\n+X\n yz\n+X\n 01\n+X\n 23\n+X\n 45\n+X\n 67\n+X\n 89\n+X\n 0\n"
+
+      assert unsplit == Patch.to_text(patches)
+
+      patches = Patch.split_max(patches, 4, opts)
+      assert unsplit == Patch.to_text(patches)
+    end
+
     test "example 2" do
       patches =
         Patch.make(
@@ -272,7 +291,8 @@ defmodule PatchTest do
                Patch.to_text(patches)
     end
 
-    test "example 4" do
+    @tag :match_max_32
+    test "example 4, 32 bits" do
       patches =
         Patch.make(
           "abcdefghij , h : 0 , t : 1 abcdefghij , h : 0 , t : 1 abcdefghij , h : 0 , t : 1",
@@ -284,6 +304,60 @@ defmodule PatchTest do
       assert "@@ -2,32 +2,32 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdef\n@@ -29,32 +29,32 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdef\n" ==
                Patch.to_text(patches)
     end
+
+    @tag :match_max_64
+    test "example 4, 64 bits" do
+      text1 = "abcdefghij , h : 0 , t : 1 abcdefghij , h : 0 , t : 1 abcdefghij , h : 0 , t : 1"
+      text2 = "abcdefghij , h : 1 , t : 1 abcdefghij , h : 1 , t : 1 abcdefghij , h : 0 , t : 1"
+      # text1, with only the first patch applied
+      expected3 =
+        "abcdefghij , h : 1 , t : 1 abcdefghij , h : 0 , t : 1 abcdefghij , h : 0 , t : 1"
+
+      patches_32 = Patch.make(text1, text2)
+
+      assert "@@ -2,33 +2,33 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdefg\n@@ -29,33 +29,33 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdefg\n" ==
+               Patch.to_text(patches_32)
+
+      # Only apply the first patch
+      {text3, _} = patches_32 |> Enum.take(1) |> Patch.apply(text1)
+      # Only the first "h : 0" was changed
+      assert expected3 == text3
+
+      # Then apply the second patch
+      {text4, _} = patches_32 |> Enum.drop(1) |> Patch.apply(text3)
+      assert text2 == text4
+
+      patches_32 = Patch.split_max(patches_32, 4)
+      # After splitting, the patches are slightly different
+      assert "@@ -2,32 +2,32 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdef\n@@ -29,32 +29,32 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdef\n" ==
+               Patch.to_text(patches_32)
+
+      {text3, _} = Patch.apply(patches_32, text1)
+      assert text2 == text3
+
+      opts_64 = [match_max_bits: 64]
+      patches_64 = Patch.make(text1, text2, opts_64)
+      # The patches are different than the 32-bit case
+      assert "@@ -1,58 +1,58 @@\n abcdefghij , h : \n-0\n+1\n  , t : 1 abcdefghij , h : 0 , t : 1 abcd\n@@ -29,33 +29,33 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdefg\n" ==
+               Patch.to_text(patches_64)
+
+      # Only apply the first patch
+      {text3, _} = patches_64 |> Enum.take(1) |> Patch.apply(text1)
+      # Only the first "h : 0" was changed
+      assert expected3 == text3
+
+      # Then apply the second patch
+      {text4, _} = patches_64 |> Enum.drop(1) |> Patch.apply(text3)
+      assert text2 == text4
+
+      patches_64 = Patch.split_max(patches_64, 4, opts_64)
+      # split_max has no effect
+      assert "@@ -1,58 +1,58 @@\n abcdefghij , h : \n-0\n+1\n  , t : 1 abcdefghij , h : 0 , t : 1 abcd\n@@ -29,33 +29,33 @@\n bcdefghij , h : \n-0\n+1\n  , t : 1 abcdefg\n" ==
+               Patch.to_text(patches_64)
+
+      {text3, _} = Patch.apply(patches_64, text1)
+      assert text2 == text3
+    end
   end
 
   describe "add_padding" do
@@ -337,6 +411,7 @@ defmodule PatchTest do
       assert {"I am the very model of a modern major general.", [false, false]} == results
     end
 
+    @tag :match_max_32
     test "big delete, small change" do
       patches =
         Patch.make(
@@ -353,6 +428,7 @@ defmodule PatchTest do
       assert {"xabcy", [true, true]} == results
     end
 
+    @tag :match_max_32
     test "big delete, big change 1" do
       patches =
         Patch.make(
@@ -370,6 +446,7 @@ defmodule PatchTest do
               [false, true]} == results
     end
 
+    @tag :match_max_32
     test "big delete, big change 2" do
       patches =
         Patch.make(
@@ -415,6 +492,7 @@ defmodule PatchTest do
       assert {"test", [true]} == results
     end
 
+    @tag :match_max_32
     test "no side effects with major delete" do
       patches = Patch.make("The quick brown fox jumps over the lazy dog.", "Woof")
       patchstr = Patch.to_text(patches)

test/test_helper.exs

@@ -1 +1,8 @@
-ExUnit.start(exclude: [:skip, :good])
+# These tests depend on a specific `:match_max_bits` value.
+excluded =
+  case Dmp.Options.default() |> Keyword.fetch!(:match_max_bits) do
+    32 -> []
+    _ -> [:match_max_32]
+  end
+
+ExUnit.start(exclude: [:skip | excluded])